At 07:10:59 UTC on Saturday 21 November, one Ethereum transaction emptied Chainflip’s vault. It took 520.22 ETH, 3,249,631.41 USDC and 758,141.33 USDT, every unit of all three the contract held. Chainflip Labs later added 122.86 BTC from its Bitcoin side and put the total at about $12 million. The vault never complained, because nothing was wrong with the request. It carried a valid signature from the aggregate key that Chainflip’s 150 validators share, and checking that key is the vault’s whole job. The one odd thing about the request was its nonce, the number that stops a signed payment being replayed. Every legitimate payout uses a number from Chainflip’s running count, which stood at about 314,568 that morning. The drain used 190262553000735942938746936035352881278. The contract accepted it, because the only question it asks about a nonce is whether it has been used before.
The question everyone asked this weekend is how the key leaked. Chainflip says it knows and has not said yet. This is the hundred-and-seventh unasked half of fairness, and it is about the other question: why a contract that sits on three years of perfectly ordered numbers had no way to notice one that came from nowhere.
TL;DR
- Chainflip’s Ethereum vault was drained on 21 November 2026 by one transaction carrying a valid aggregate-key signature and a 39-digit nonce, against a running count near 314,568.
- The deployed KeyManager (verified source on Sourcify) checks a nonce for one thing only:
!_isNonceUsedByAggKey[nonce]. Any unused 256-bit number passes. - Satoshie’s own read of the 120 signatures around the drain: 119 legitimate nonces, 25 landing out of order, none more than 22 from the running maximum. A window check would have rejected the drain’s number.
- A window would not stop a thief who knows the rule. It would force the thief onto the live count, where the theft collides with the network’s own next payout and becomes visible.
- Chainlink VRF does this differently: the coordinator mints the request number on the same chain that checks the answer, and refuses any proof for a request it never recorded. Ask your game which kind it is.
What the vault actually checks
Chainflip moves real coins between chains, not wrapped ones. Users’ deposits sit in vaults on each chain, and only a signature from the shared aggregate key can move them. That key is produced with FROST, a threshold signature scheme: per Chainflip’s documentation, at least 100 of the 150 validators must take part to sign, no single validator holds the whole key, and the validator set makes a fresh key every three days. The last scheduled rotation before the drain was on 18 November.
On Ethereum, the signature check lives in the KeyManager contract at 0xCd351d3626Dc244730796A3168D315168eBf08Be. The drain transaction’s own log came from that address, and its verified source on Sourcify is short enough to quote the part that matters:
require(
verifySignature(msgHash, sigData.sig, key.pubKeyX, key.pubKeyYParity, sigData.kTimesGAddress),
"KeyManager: Sig invalid"
);
require(!_isNonceUsedByAggKey[sigData.nonce], "KeyManager: nonce already used");
Two rules. The signature must verify against the current key, and the nonce must not appear in a mapping(uint256 => bool) of used numbers. That second rule does exactly what it was written to do: it stops anyone resubmitting yesterday’s payout. It says nothing about where a number came from. There are 2256 possible nonces and Chainflip has used about 315,000 of them, so anybody holding a valid signature can pick a fresh number at will.
Bitquery read every SignatureAccepted log the KeyManager has ever written, 299,677 of them since 2023, and found exactly one off the running count: the drain. Three years of discipline, kept perfectly by the honest side, and recorded in the contract’s own event log. The contract simply never read it.
We checked the count ourselves
“Off the count” invites the obvious fix: make the contract demand the next number. That would have broken Chainflip on a normal Tuesday. We pulled every SignatureAccepted event from Ethereum blocks 26,461,600 to 26,462,300, roughly 70 minutes either side of the drain, from a public RPC.
- 120 signatures were accepted. 119 carry nonces between 314,512 and 314,653. One carries the 39-digit number, in block 26,461,896.
- 25 of the 119 landed out of order. Signed payouts are broadcast in parallel, so 314,520 can arrive after 314,523. A strict “next number only” rule would have reverted about one honest payout in five.
- No honest nonce strayed far. The furthest any legitimate number ran ahead of the highest already seen was 11. The furthest any arrived behind it was 22.
- The count did not flinch. The highest nonce before the drain was 314,568 and the lowest after it was 314,569. The network kept signing normal payouts from the same count for another hour and a half, until Chainflip moved to a new key at 08:53 UTC, 1 hour 42 minutes after the theft.
Bitquery also reports that about one number in twenty is skipped and never appears on Ethereum, which is consistent with what we saw: the 119 legitimate nonces span 142 values. So the honest pattern is not a perfect sequence. It is a tight band that moves forward, with stragglers a couple of dozen behind and nothing more than a dozen ahead. The drain’s number sat 39 digits ahead of that band.
A rule as crude as “reject any nonce more than 10,000 above the highest one seen” would have let every one of the 119 honest payouts through and refused the drain. It costs one storage slot and one comparison.
What a window would and would not have done
Here is the part a cheerleading post would skip. A nonce window does not protect a vault from someone who holds the key. A thief who knows the rule signs with a number inside the band, and the vault pays.
But look at what that costs the thief. Inside the band, the thief’s number is one the network is about to use, or has just used. If the thief takes 314,569 first, the network’s own payout carrying 314,569 reverts with nonce already used, and the network watches a payment it signed bounce off a number it never spent. That is the kind of failure an operator notices within minutes. If the thief picks a number already consumed, the theft reverts instead. The random 39-digit nonce was the clean way to avoid that collision entirely. Under a window rule, the clean way does not exist.
We cannot tell whether that would have changed Saturday. One transaction moved the whole balance, so any alarm would have rung after the money left. The window is a tripwire, not a lock. What it changes is the shape of the attack: a stolen key stops being silently spendable and becomes something that has to interfere with the honest system to work. That is the property the contract had available and did not ask for.
It is also worth noticing which safety the contract did write down. The KeyManager carries a dead man’s switch: governance can replace the aggregate key with its own signature, but only after _AGG_KEY_TIMEOUT = 2 days in which the aggregate key has signed nothing. That protects users if the validators vanish. It does nothing if the key is in the wrong hands, because a working thief signs immediately. Chainflip’s recovery on Saturday came from the validators rotating the key themselves, which they could do only because the honest majority was still intact.
Why the count was never the contract’s to check
The deeper problem is where the count lives. Chainflip’s running count is kept on the Chainflip State Chain, where the validators agree what to pay. The Ethereum vault only ever sees the finished product: a signature and a number. The count is off-chain from Ethereum’s point of view, so the contract cannot ask whether a payout was ever scheduled. It can only ask whether the key signed it. A signature proves who approved something. It does not prove that the approved thing was ever on the list.
Fair games have the same shape. A game asks an oracle for a random number, the oracle answers with a proof, and the contract has to decide whether to believe the answer. The question that matters is the same one the vault never asked: does the contract know which questions it asked?
Chainlink VRF v2.5 answers it in the coordinator itself. When a game requests randomness, the coordinator increments that consumer’s nonce on-chain, derives the request ID from the key hash, the consumer, the subscription and that nonce, and stores a commitment to the request in s_requestCommitments. When the oracle answers, the coordinator looks the commitment up first. An answer to a request that was never recorded reverts with NoCorrespondingRequest. An answer whose details do not match reverts with IncorrectCommitment. Once a request is fulfilled the commitment is deleted, which is why a refused draw stays refused. The count is minted on the same chain that checks the answer, so there is no gap between “who signed this” and “was this ever asked”.
It also matters what a stolen key could do in each system. A stolen Chainflip key could write any payout it liked. A stolen VRF proving key could not change any answer, because a VRF output is unique for a given key and seed. It could see answers early or decline to give them. That is a real risk, and it is why we care about confirmations and how few of them Base games actually wait for. But it is not the power to invent a result for a draw that never happened.
Where games are more like the vault than they admit
None of this makes on-chain games safe by default. The coordinator’s bookkeeping only protects a game that keeps using the coordinator. When we read the configuration of 59 Base game contracts, only 2 could not swap their oracle. For the other 57, an owner key can point the game at a different randomness source, and that owner key is a single signature with no count behind it at all. That is Chainflip’s vault in miniature: one key, checked for validity, not for whether the action was ever expected.
Satoshie’s answer is the boring one, and we think boring is the point. Raffles and coinflips draw through Chainlink VRF on Base, the coordinator records each request before it can be answered, and the winner is computed on-chain from the verified output. You do not have to trust our servers, our signers or our count. You can read the request, the commitment and the fulfilment yourself on a block explorer.
Three questions for any protocol that holds your money
- Who mints the number? If the sequence that authorises payouts or draws lives somewhere the contract cannot see, a valid signature is the only thing standing between the key and the funds.
- Does the contract check the shape of honest traffic? Chainflip’s honest nonces never strayed more than 22 from the front of the count in our sample. A rule that small would have made a 39-digit number impossible.
- What does a stolen key let someone write? Arbitrary payouts, as at Chainflip, or only early sight of answers that were already fixed, as with a VRF proving key. Those are different disasters, and a protocol should be able to tell you which one it has.
The limits of this post
We do not know how the key was exposed. Chainflip says it does, that it traced Tornado Cash funding on 11 November and a validator account registered on 20 November, and that it has closed the hole; its published message to the attacker offers a 10% bounty for the return of the rest by 18:38 UTC on 23 November. Until a full post-mortem appears, anything about the mechanism is a guess, and we have not made one. This is also Chainflip’s second loss this autumn, after about $736,000 of USDT went through a Tron refund flaw in September, which the validators later voted to repay. Our nonce sample covers 700 blocks, not three years; Bitquery’s full count is the source for the 299,677 figure. And a nonce window is a cheap hardening step, not a cure. The cure for a stolen key is not having one stolen.
The unasked half is simpler than the cryptography. A vault that remembers every number it has seen, and never asks whether a number makes sense, will pay the first stranger who arrives with the right signature and the wrong count. A fair system should know what it is waiting for.
📷 Photo by Alexandre Daoust on Unsplash


