The zkLink Nova bridge to Ethereum was emptied in a single transaction. On the night of October 28, at 22:21 UTC, a contract created by the attacker wrote its own batch root into the bridge's registry and withdrew 22.43 ETH plus eleven ERC-20 tokens using proofs that he had fabricated himself. Loss estimates vary by count: $786,000 at the highest and $779,000 at the lowest, with $783,100 in between. No private key was stolen and no signature was forged.
It is worth understanding what a bridge like this holds in custody. zkLink Nova is an aggregated layer 3 rollup that relies on Ethereum and several layer 2s, and its mainnet contract holds the funds users deposit from other networks. To authorize a withdrawal, that contract compares the user's Merkle proof against the batch root it has stored for that number. If the root is correct, the proof demonstrates membership; if a third party writes the root, the proof demonstrates whatever that third party wants.
That is the lesson, and it is not cryptographic. The proof system worked as designed: it verified against the root it found and approved twelve withdrawals in a row. The failure came earlier, in the path by which that root reached the contract, and in a check that took as valid a delivery that had occurred seconds earlier within the same transaction. Nova halted block production on October 29 and still has no reopening date.
Twelve withdrawals within a single block
The transaction entered block 26,294,188 and touched two contracts at once. 22.4313 ETH left the ZkLink escrow and eleven ERC-20 balances left L1ERC20Bridge, the contract that holds the tokens in custody. The breakdown was as follows.
| Asset |
Amount |
| ETH (ZkLink escrow) |
22,4313 |
| pufETH |
245,7379 |
| USDC |
18.113,45 |
| ezETH |
12,5693 |
| rsETH |
6,8665 |
| USDT |
3.360,90 |
| WBTC |
0,1736 |
All twelve movements went to the same address, that of the contract that executed the attack, and each carried four custom-built Merkle nodes. Hours later, that wallet had drained almost everything and its ETH balance was below 0.001.
The next day brought more: Parapet Labs attributes a second wave at 07:16 UTC on October 29 to a different actor, with 24.76 ETH and tokens from the bridge's copies on Optimism, Base and two other networks. The figure matters less than the pattern: the same path was still open nine hours after the first hit.
What does a ZK proof prove?
A validity proof demonstrates, with a cheap check, that a batch of transactions was executed correctly and that the resulting state is what it claims to be, without the verifier having to repeat the entire computation.
In Nova that verification happens on Linea, the primary chain that sets the protocol's settlement architecture , and the batch root then travels to the rest of the networks so that each one authorizes withdrawals against it.
The circuit answers the question of whether the batch was computed correctly. It does not answer who can assert what that batch's root is, and that second question is what took the money. A bridge can have flawless proofs and, at the same time, a root-update procedure that accepts the word of a contract with special permissions.
A forged root that passed every filter
The bridge does not accept roots from just anyone. On Ethereum there is a relay chain: a relayer calls the Arbitrator contract, the Arbitrator claims a message from the source chain, that chain's gateway signals back, and only then can the EthereumGateway write the root into ZkLink. Each hop trusts the previous one by the calling address, not by the content of the message.
The attack rode on that trust in four chained steps within a single transaction. None required breaking an encryption or guessing a key: it was enough for each contract to recognize the previous one by the address that called.
- The attacker called the public SyncL2TxHashRelayer to claim a real, pending message from Linea that synchronized two transaction hashes. The Linea gateway verified the proof and notified the Arbitrator, which stored the message summary in a transient storage slot.
- In the same transaction, the attacker called the relayer again with the same gateway, the same value and the same declared data, but swapped the source message service for the EthereumGateway and inserted a call that wrapped the writing of batch root 116409.
- The gateway accepted the call because it came from the Arbitrator, and ZkLink wrote the chosen root because the call came from its gateway. No one checked that the batch existed or that there was a proof behind that root.
- With the root now in the registry, twelve withdrawals passed the membership verification, because the verifier compared against the tree the attacker had just defined.
The detail that links the steps is a hash that was never cleared. The Arbitrator stored the summary of the genuine delivery in transient storage (EIP-1153), which lasts as long as the transaction rather than as long as the call. By not zeroing it after use, the check stopped asking whether something real had arrived in that call and began asking whether something with those same parameters had ever arrived within that same transaction. The nonReentrant modifier was no obstacle, because the two calls were sequential and not nested.
Parapet Labs reconstructed that trace and recommended to other teams that they clear authentication flags stored in transient storage and avoid making external calls chosen by the caller from a privileged identity. Both pieces of the failure are textbook: a function that executes whatever it is asked to and a check that outlives the call that justified it.
State accounting is what gets lost
A bridge is a ledger with two columns. One says which assets came in and remain in custody; the other says which messages arrived from the source network. Cryptography protects the arithmetic of that ledger, not the decision of which entries are accepted. When the second column admits an entry without backing, the balance in the first can be claimed in full.
The most expensive thefts of recent months did not break an encryption. In the Binance theftthe entry point was a compromised engineer's laptop, in a heist valued at around $6.3 billion.
In the Initia exploitthe flaw allowed assets to be minted without backing and the network was shut down on October 23, eleven days ago, to halt further issuance of a token that never entered custody.
Nova is the cleanest variant of the pattern. No keys, no signatures, no broken cryptographic proof: a registry that accepted a foreign root and a verifier that did its job correctly with false data. The attack surface was not in the circuit, it was in the procedure that decided which root was the right one.
What zkLink shut down and what remains unanswered
zkLink acknowledged the attack on October 29 and listed three measures: suspend block production, patch the affected contracts and close the withdrawal channel. The company said Nova would only return once it had confirmed the risks had disappeared, and offered the attacker 20% of the loot if the funds were returned. It gave no deadline or cause.
Nor did it confirm the account given by the security firms, which reconstructed the mechanism on their own. That gap is usual in the first 48 hours of an incident and is a reminder that the official version arrives later and with less detail than the on-chain trail.
A trustless bridge that trusts its gatekeeper
The trustless label describes the destination, not the path. A bridge can verify every withdrawal with proofs and, at the same time, depend on a contract with special permissions not making a mistake when updating the registry. There are no mathematics to audit there, there is a procedure to review line by line, and it is almost always the part nobody looks at because it does not seem important.
The figure helps to measure the lesson. $779,000 is little for a sector that has seen nine-figure thefts, but Nova's escrow was not huge either, and the attacker took everything behind that route. With more liquidity, the same flaw would have drained a much larger contract in the same block and without touching a single key.