In the first article of this series we explained why Nexa builds hardware. Proof-of-work spent seventeen years accelerating a computation that does nothing for the network’s capacity, and Nexa intends to point that same force at the work a money network actually needs. This article shows what that hardware actually is, a machine for validating money, built out of the simplest electrical parts there are.
Nexa Chief Scientist, Dr Peter Rizun, is building a node as a circuit of digital logic gates. To see how a circuit can validate a money transaction with no software involved, you only need to meet six components.
The Most Important Component
The most important component in digital logic is a wire, and its behavior is so simple that it is beyond the grasp of many software developers. Apply zero volts at the input, and you get zero at the output. Apply one volt at the input, and you get one volt at the output. That is everything a wire does.
You can model this behavior in software as a while loop that is always mapping the input to the output. In Python, it takes several hundred clock cycles for the input signal to propagate to the output. How long does it take in the hardware case? This is the part that stumps the software guys. They might answer that, with a lot of work, it could be as fast as one clock cycle. That is totally wrong.
“It takes no work at all, and the signal propagates at the speed of light. It’s literally just a wire. And this is part of why hardware can be so fast. You get this built-in while loop for free.” – Dr Peter Rizun, Australian Crypto Convention, Sydney, 2024
Six Building Blocks
The rest of the toolkit is nearly as simple. A NOT gate: if the input is zero, the output is one, and vice versa. An AND gate: the output is one if all of the inputs are one. An OR gate. A multiplexer, which is like a switch. And a flip-flop, which stores state: the input gets saved to the output when the clock goes from zero to one.
Together, these gates form a Turing-complete set. Any computation that can be performed, can be performed by a suitable combination made of these six components. Another way to look at it: you could solder together your own Turing machine made with only those six building blocks.
A little vocabulary completes the toolbox. A wire carries a single bit, and a flip-flop stores a single bit. A bus is a collection of wires and carries a bunch of bits that we call a symbol. Symbols are saved in registers, and registers are just flip-flops side by side. Keep the word “symbol” in mind, because the whole node runs on symbols.
The Validation Engine
Built from those six components, the heart of Nexa’s hardware node can be described in one breath. The node consists of a tape of squares, and on each square a symbol may be written. The read-write head can inspect the symbol on the square in front of it, and optionally overwrite it. It can splice a new square into the tape. And it can request information from the UTXO database, the ledger of unspent coins. That’s the validation engine.
The engine was designed against four targets for a better Bitcoin: it must be scalable, compressible, extensible, and incentive compatible. Scalable means pipelineable (transactions validated with the tape only moving in the forward direction) and parallelizable, with the work to validate a transaction growing very slowly as the network gets bigger. Compressible means that a coin’s existence and its unspent status can each be shown with a small, compact proof. Extensible means the engine can emulate a Turing machine, so new script capabilities become a localized change to the circuit inside the head. And incentive compatible means hash-per-second mining coupled directly to transactions-per-second validating, the story of the first article. This article builds the machine and the series ticks the boxes one by one.
One Hundred Million Symbols per Second
In the real circuit, the tape is implemented as a bus (a bundle of wires) connected to the head so it can read and write the symbols. Alongside each symbol runs a wire that lets the head know how to interpret what it sees: is it a pubkey? Is it a signature?
The clock rate is about 100 megahertz, which means that 100 million symbols are flying past the head every second. But sometimes the head needs longer than the ten nanoseconds a clock cycle gives it. In the design presented in Sydney, verifying a digital signature takes about 20 microseconds. So the engine carries two extra control wires implementing hardware flow control. To get more time, the head asserts the “full” wire, which tells the upstream process not to send any more symbols. That flow-control signal propagates in a few dozen picoseconds, less than a clock period, so the bus stops instantly. When the head is done verifying the signature, it releases the flow-control lines and the symbols flow again.
It is not possible to achieve sub-nanosecond flow control like this in software.
Alice Pays Bob, Square by Square
So what does this machine do all day? It executes the diagram Satoshi drew in the Bitcoin white paper, in wires.
Alice’s transaction that pays Bob contains the TXID of the coin she is going to spend, Bob’s pubkey, who she is sending the coin to, and her signature that authorizes the transaction. To process it, the node needs to know a little bit more: Alice’s pubkey, and a value called the signing hash. Here is how the engine handles the transaction, square by square.
First, the head sees the ID of the coin being spent and saves a copy of that symbol into an internal register. It also looks to see whether the coin exists in the UTXO set and is unspent. If it isn’t spent, the head saves Alice’s pubkey into an internal register and also splices the pubkey into the tape.
The next symbol to pass is Bob’s pubkey, which is saved into a register of its own. Now there is enough information to compute the signing hash. The circuit performs this hash automatically, because it is fixed, dedicated hardware, so it happens almost instantly, and the hash is spliced back into the tape.
The next square to pass is the signature of Alice, and now there is enough information to verify the transaction. The hardwired verify module, just a bunch of transistors, verifies the transaction very quickly, and if it is valid, marks that symbol on the tape as valid and pushes what is now Bob’s coin into the UTXO set. And we’re done.
Notice what just happened, the tape only ever moved in the forward direction. No seeking backwards, no revisiting old squares. That is exactly what pipelineable means, and it is the first of the four boxes the engine gets to tick.
A Validator, Not a Miner
One thing this machine is not: a miner. Nothing on the tape hashes block headers or searches for nonces. The engine does the everyday work of a full node, checking signatures and looking up coins, which is precisely the work the first article argued the network should be rewarding. When this series reaches mining, it will be because Nexa’s mining algorithm is being redesigned to exercise exactly this kind of validation machinery.
Six components, a tape, and a head. That is the entire conceptual foundation of Nexa’s hardware node, and everything else in this series builds on it.
Sources
-
The six building blocks, the validation engine, and the transaction walkthrough: Peter Rizun, “A New Chapter in Scaling: Cryptocurrency-specific integrated circuits,” Australian Crypto Convention, Sydney, 23 November 2024. Transcript: Peter R. Rizun on X: "https://t.co/AQnAQyUHa1" / X.
-
The Alice-pays-Bob transaction diagram: Satoshi Nakamoto, “Bitcoin: A Peer-to-Peer Electronic Cash System,” 2008, https://bitcoin.org/bitcoin.pdf.
-
Previous article in this series: “Why Nexa Builds Hardware,” Why Nexa Builds Hardware.