Skip to content
Cutaway of a steel checkpoint validator in dark space, a latch still holding a teal imprint props the gate arm up while a gloved hand slides a blank red token beneath it.
exploitsNovember 11, 20264 min read

zkLink Nova's $783K Bridge Drain: A Transient-Storage Check That Outlived Its Call

Aron Turner
Aron TurnerCo-Founder & CTO

Updated on November 11, 2026

TL;DR

At 22:21:35 UTC on October 28, 2026, one Ethereum transaction wrote a forged batch root into zkLink Nova's L1 contract and then withdrew 22.43 ETH and 11 ERC-20 tokens against it. SlowMist's analysis puts the loss at about $783,000 and traces it to the Arbitrator contract's claimMessage. That function ran an attacker-chosen call under its own identity, then validated it against a message hash held in EIP-1153 transient storage. The attacker filled that slot with one genuine, harmless Linea claim, then made a second call that claimed no message, pointed the Arbitrator at its own gateway, and passed the check on the leftover hash. The gas fee was 0.00116 ETH, under $3. A second wallet, which Etherscan labels "X100 Exploiter 2", withdrew from the same bridge about three hours later, and a third about 12 hours later. zkLink halted Nova, patched the contracts and offered a 20% bounty. As of November 11 we found no post-mortem. A check that reads transient storage proves that something happened somewhere in the transaction. zkLink treated it as proof that it happened in this call.


zkLink Nova is an aggregated rollup whose Ethereum side holds two treasuries. Per SlowMist, the ZkLink contract (0x5fd9f73286b7e8683bab45019c94553b93e015cf) is the L1 messaging service and holds the ETH, and its companion L1ERC20Bridge (0xad16edcf7deb7e90096a259c81269d811544b6b6) holds the ERC-20s. Withdrawals are proven against a per-batch log root. Forge the root and any withdrawal can be "proven".

The first transaction forged one. The attacker EOA 0xaca0655a11200a80d33d0e48786317304cde5718 called its attack contract 0xd5f162b68a0281686e8dc76db8d67d2f3e6aff07, which overwrote the empty root for batch 116409 and then ran 12 withdrawals against it: one in ETH, eleven in ERC-20s. Etherscan shows all 12 transfers paid to the attacker EOA. The biggest was 245.74 pufETH, a restaked ether token.

Blockaid raised the alarm at 10:24 p.m. ET, about four hours after the transaction, saying the attacker "used a public relayer to inject a forged batch root on Ethereum." By Thursday morning zkLink said it had stopped block production, patched the affected contracts and switched off withdrawals. It also said the attack targeted Nova's Arbitrator contract on both Ethereum and Optimism, and offered a "20% white hat bounty" for returned funds, adding that no further action would be pursued if they came back.


What Is Transient Storage, and Why Does It Matter Here?

Transient storage is contract storage that lives for one transaction. EIP-1153 added two opcodes, TSTORE and TLOAD, whose values behave like normal storage except that they are discarded at the end of the transaction, never at the end of a call. Every frame of the owning contract reads the same slot, so call one can write a value and call five can still read it.

The canonical use is a cheap reentrancy lock: set a flag on entry, clear it on exit. The danger is the clearing. The EIP's own security section warns that developers "may be tempted to avoid clearing slots as part of a call in order to save gas," and that this can "cause other bugs." When Solidity 0.8.24 shipped the opcodes in January 2024, the compiler team went further: it made the compiler emit a warning on any tstore in inline assembly, to raise awareness of the composability hazard.

zkLink's Arbitrator used a transient slot as evidence that a message had just been claimed. The slot was written during a claim and read right after it. Nothing cleared it in between. Within a single transaction, a second call could read the first call's evidence.


The Arbitrator sits between chains. A trusted relayer calls claimMessage, which asks a source-chain messaging service to release a message and then forwards it to the destination gateway. During a real claim, the source gateway calls back into the Arbitrator's receiveMessage, which writes the message hash into a transient slot named finalizeMessageHash. claimMessage then compares that slot with the gateway, value and calldata the relayer declared.

SlowMist identifies two flaws in that function, and the attack needed both. Simplified from their published excerpt:

function claimMessage(
    address _sourceChainCanonicalMessageService,
    bytes calldata _sourceChainClaimCallData,
    IL1Gateway _sourceChainL1Gateway,
    uint256 _receiveValue,
    bytes calldata _receiveCallData,
    bytes calldata _forwardParams
) external payable nonReentrant onlyRelayer {
    // Flaw 1: target and calldata are relayer-supplied, executed as the Arbitrator
    Address.functionCall(_sourceChainCanonicalMessageService, _sourceChainClaimCallData);
    bytes32 _finalizeMessageHash;
    assembly { _finalizeMessageHash := tload(finalizeMessageHash.slot) }
    // Flaw 2: compares against whatever is in the slot, set by this call or an earlier one
    require(
        _finalizeMessageHash == keccak256(abi.encode(_sourceChainL1Gateway, _receiveValue, _receiveCallData)),
        "Incorrect finalize data"
    );
    // ... forward to destination gateway
}

The first flaw turns the Arbitrator into a proxy for anyone holding the relayer role. The second makes the only integrity check replayable inside a transaction. Neither the external call's target nor its calldata goes into the hash being compared.

Per SlowMist, a helper contract called SyncL2TxHashRelayer (0x0fdc28e64772a70109d10fd068f859cfa7dea2c6) was registered as a relayer, and its claimPrimaryChainSyncL2TxHashMessage function had no access control. It passed any caller's parameters straight to Arbitrator.claimMessage (a helper, registered with production privileges, open to the world).

The Attack, Step by Step

StepCallWhat it achieved
1Attack contract reads totalBatchesExecuted() on ZkLink, gets 116408Picks 116409, the next unexecuted batch, as the batch to forge
2Relayer helper calls claimMessage with a genuine Linea message the attacker had sent to themselvesLinea verifies the proof, the callback writes the real hash into finalizeMessageHash
3Relayer helper calls claimMessage again, same declared gateway, value and calldata, but the target is now EthereumGateway with sendMessage(0, syncBatchRoot(116409, forgedRoot, 0), "")The Arbitrator calls its own gateway; the stale hash passes the check
4EthereumGateway forwards the calldata to ZkLink; syncBatchRoot accepts it because the caller is a gatewayl2LogsRootHashes[116409] goes from zero to the forged root, totalBatchesExecuted rises to 116409
5Attack contract submits 12 withdrawals against batch 116409, each with a four-node Merkle proof built from the forged tree22.43 ETH from ZkLink and 11 tokens from L1ERC20Bridge go to the attacker EOA

The first call is honest. Per SlowMist, both calls also forwarded a harmless syncL2TxHash write. The first call's real job was to plant the hash. The second call claims no message at all.

rendering diagram…

Why Did Every Caller Check Pass?

Every layer authenticated the caller and forwarded the request untouched. The gateway's sendMessage carries onlyArbitrator, and the Arbitrator was the caller. ZkLink's syncBatchRoot carries onlyGateway, and the gateway was the caller. Per SlowMist, syncBatchRoot "does not verify any batch proof": it overwrites the root for whatever batch number it is handed and advances totalBatchesExecuted if that number is higher.

The attacker borrowed the identity of a contract that already held the access. Once the Arbitrator would make an arbitrary call, onlyArbitrator meant "anyone who can reach the relayer helper," and onlyGateway meant the same thing one hop later.

The withdrawal side behaved as designed. Both contracts marked each message as withdrawn, which blocks a double claim. SlowMist's point is that this marker "cannot identify whether the message itself had ever occurred on L2." A Merkle proof shows that a leaf belongs to a tree, and the root write in step 4 decided which tree counted.


The published figures range from $778,625 to $797,000, and the spread comes mostly from when each estimate priced an ether-denominated basket. Hokanews, syndicating The Defiant, totalled $778,625.84 from Etherscan's displayed prices about four hours after the transaction. SlowMist says about $783,000. Blockaid said about $786,000 while the attack was "still ongoing" and called that preliminary, per CoinAlertNews. ChainCatcher reports GoPlus at about $797,000.

The units are not in dispute. The first transaction moved 22.43 ETH plus 245.74 pufETH, 12.57 ezETH, 18,113 USDC, 6.87 rsETH, 6.30 STONE, 0.1736 WBTC, 3,361 USDT and four smaller liquid-staking positions. Etherscan valued the ETH leg at $52,877.96 on the day, at an ether price of $2,357.33. At today's ether price the same page shows about $46,000 for it. Most of the basket is ether-denominated, so every estimate moves with the ether price at the moment it was taken. We use SlowMist's $783K as the headline because it is a near-time valuation from a firm that traced the transaction itself.

Most of the loss sat in one asset. Hokanews put the pufETH leg at about $613,536, roughly 79% of the $778,625 total. Per Hokanews, Etherscan afterwards showed about 0.001 ETH left in the ETH escrow.

The transaction fee was 0.00116 ETH, under $3 at the day's ether price, against a take of about $783,000.

These figures cover the first transaction only. We could not establish whether any firm's estimate includes the follow-on withdrawals below.


How Was the Attack Staged, and Where Did the Money Go?

The preparation took six and a half hours and about 0.027 ETH. At 15:49:11 UTC on October 28, FixedFloat's Hot Wallet 2 sent the attacker EOA 0.02723853 ETH. About eleven minutes later the wallet swapped 0.00045 ETH for about 1.05 USDC on Uniswap V2 and deposited 1 USDC into zkLink Nova's own ERC-20 bridge. Its purpose is not public. Our reading, an inference, is a test of the deposit path the drain would later reverse. At 17:49 UTC the wallet sent 0.002 ETH to Linea through Linea's L1 message service, which we infer funded the Linea side of the genuine message SlowMist describes. At 18:51 UTC it deployed the attack contract. The drain followed three and a half hours later.

The exit was faster than the alarm. Three minutes after the drain, the wallet redeemed pufETH with Puffer for 143.39 ETH, paid out as WETH. Four minutes later a Curve swap returned 123.26 ETH, and at 22:57 UTC it unwrapped 141.95 WETH. Between 22:58 and 23:01 UTC it sent 101 ETH, 100 ETH and 102.06 ETH to three fresh addresses. That is about 303 ETH, gone inside 40 minutes of the drain and more than three hours before Blockaid's public alert. We did not trace past those three addresses.


Who Else Came Through the Same Hole?

Two more wallets followed. At 01:43:11 UTC on October 29, a second transaction from 0xDAB137F390dF77caA97fd492540E973fd5e2F8c8 pulled 33 token types out of the same L1ERC20Bridge. Unchained says most were dust, and about 216.4 million ZKL, worth roughly $50,000 at Thursday prices, made up most of the value. Etherscan labels that sender "X100 Exploiter 2". We have not traced the address, so treat the link to X100 as Etherscan's attribution, not ours.

At 10:06:35 UTC, nearly 12 hours after the first transaction, a third wallet deployed a contract, and in the same transaction 0.0025 ETH left the ZkLink contract for that wallet. Unchained reports that it repeated the first transaction's steps. The amount is trivial, but half a day after the root was forged, the path still worked for a stranger. zkLink said the attack also targeted its Arbitrator on Optimism. Unchained checked only Ethereum, and we found no public figure for any Optimism-side loss.

In August 2022, Nomad lost $190M after a routine upgrade set the zero root as trusted. Copycats pasted the original call into Etherscan with their own address. The mechanics differ, since Nomad trusted the zero root and zkLink took a root from any gateway caller. In both, a root accepted without proof turned a bridge into a public tap, and a second wave followed once the first transaction was public on-chain.


Transient storage changed what "this call" means, and older review habits miss it. With normal storage, auditors ask which values should not outlive a transaction. With transient storage, the question is which values should outlive a call. The slot is shared by every call in the transaction, and beyond a compiler warning on tstore, the language leaves the reset to the developer.

The same shape appears wherever a contract uses a transient slot as a receipt: callback-verified claims, flash-accounting deltas, "was I called back" flags. If the slot is written by a callback and read by the caller, and the caller can be entered twice in one transaction, the second entry inherits the first's receipt. A nonReentrant guard does not help. The two calls in this attack were sequential, never nested.

An audit is a strong control for exactly this bug, provided the reviewer knows transient storage is a lifetime question. The EIP's authors said so in its security section, and the Solidity team said so in January 2024.


What Should Bridge and Relayer Operators Do Now?

  1. Clear every transient receipt before the call that is supposed to set it. SlowMist's fix: zero finalizeMessageHash before Address.functionCall, then require it to be non-zero and to match this call's declaration, or bind it to a per-call nonce.

  2. Never let a relayer choose the target of a privileged call. Allowlist the source-chain messaging services claimMessage may call, and exclude the Arbitrator's own gateways explicitly. Fold the target and calldata into whatever hash you verify.

  3. Treat helper contracts as production principals. A dev or sync helper registered as a relayer holds the relayer's full authority. Gate it, or deregister it. Inventory every address on every onlyX list and ask who can reach it in one hop.

  4. Make root writes prove something. syncBatchRoot should refuse to overwrite an existing root and should refuse a batch number that skips ahead of the executed sequence. Caller identity alone should never be enough to install a root that can release funds.

  5. Keep a pause lever that someone can pull within minutes, on every contract that holds funds. The second and third withdrawals landed 3 hours and nearly 12 hours after the first. Whoever holds the pause key needs an alert that wakes them.

The first transaction was atomic: the root write and all 12 withdrawals sat in one transaction, so no alert or pause could touch them. What followed sat in plain contract state. ZkLink's totalBatchesExecuted jumped to 116409, a root appeared for that batch in a transaction routed through the relayer helper, and the ETH escrow dropped to about 0.001 ETH. Tripwire runs rules on contract state like that on every block and pending transaction, and can send a pause through a pause-only role that the protocol grants. A rule on the root write fires on the drain's own block. By then the ETH escrow was nearly empty, so what a pause could still protect sat in the ERC-20 bridge, where the second wallet took about $50,000 of ZKL more than three hours later. The ZkLink contract's pause flag read false about four hours after the drain, per Hokanews, and was set by the next afternoon, per Unchained. With a pause role reaching both contracts, that three-hour window closes in the first block.

The $783K itself had to be stopped in code, before launch. This bug sat where our bridge audits spend most of their time: the message verification mechanism, where forged and replayed messages originate, and the relayer trust model around it. We map the whole system, relayer infrastructure included, before reviewing a line, so a helper contract on the relayer list is in scope, and so is a check that a second call in the same transaction can replay.


Frequently Asked Questions

No. No key was stolen. Per SlowMist, the attacker used a publicly callable relayer helper to make the Arbitrator contract call its own gateway, and reused a transient-storage hash from a genuine claim earlier in the same transaction to pass the integrity check. Every signature and caller check behaved as written.

Is EIP-1153 transient storage unsafe to use?

No. The opcodes do what the specification says. The hazard is lifetime: a transient value survives until the end of the transaction, so a slot that is not cleared can be read by a later call. EIP-1153's security section and the Solidity 0.8.24 announcement both warn about uncleared slots.

Have the funds been recovered?

No. zkLink offered a 20% white hat bounty. Etherscan shows the first wallet sending about 303 ETH to three addresses within 40 minutes of the drain, and as of November 11 we found no recovery announcement and no post-mortem.

Would a smart contract audit have caught this?

Yes, if the review checked transient-storage lifetime. The flaw is in deployed code: a relayer-controlled call target, and an integrity check that reads an uncleared transient slot. Both are visible in source, and the EIP-1153 specification names uncleared slots as a bug source. We do not know whether the Arbitrator was in scope of any prior audit.


Sources / References

Aron Turner
Aron Turner

Co-Founder & CTO

CTO of SigIntZero. Engineering leadership, infrastructure architecture, and security tooling.