On 29 October 2026, at 20:04 UTC, the first outflow left Binance's hot wallet on the XRP Ledger. Within about 20 minutes, money was leaving 17 hot wallets across nine chains; the last Ethereum outflow came at 23:56. TRM Labs puts the total loss at $6.36 billion. It is the largest crypto theft on record, and according to Elliptic's chief scientist, probably the largest theft of any kind.

I have spent four years on the security side of crypto exchanges. Like the Liquid Network case, this incident doesn't fit the usual patterns: according to Binance, no wallet private key was leaked. The attacker didn't steal the key. They got the system that uses the key to sign their requests. In this piece I try to work through the technical side of the incident, step by step, using public information and my own on-chain queries.

An important caveat: Binance has not yet published its official incident report, and the initial access vector has not been disclosed. I have tried to keep verified facts separate from inference below, and I mark the places where I am inferring.

I. The incident in numbers

According to Bitquery's on-chain analysis, at prices at the time of the theft:

ChainAssets outValue
Ethereum200,630 ETH + 1.6B USDT + 62 tokens$3.77B
Bitcoin18,270 BTC, in a single block$1.48B
TRON613M USDT$628M
XRP Ledger233.5M XRP$300M
SolanaSOL and tokens$96M
Arbitrum, Polygon, Optimism, Basevarious~$49M
Total (TRM Labs)$6.36B

The main Ethereum outflow was a single transaction: at 20:24, 167,464 ETH, 1.6 billion USDT and 62 different tokens moved in one go. That one transaction was worth more than $2.5 billion.

II. Timeline

First outflow, XRP Ledger
Solana outflows begin
TRON and Bitcoin outflows; on Ethereum, the EIP-7702 authorizations for the "Binance 14" hot wallet land on-chain
Main Ethereum drain: 167,464 ETH, 1.6B USDT and 62 tokens in one transaction
Arbitrum outflow
Tether makes its first freeze
Circle freezes 823M USDC
Polygon outflow
Last Ethereum outflow
Binance revokes the EIP-7702 delegation (30 October)

In other words, the "Binance 14" wallet kept running the attacker's code for about four hours after the first drain. According to sources compiled on Wikipedia, the attackers likely began preparing at least 36 hours in advance.

III. The attack chain

Putting together Binance's preliminary findings and CEO Richard Teng's statements, this is the chain as we know it today:

  1. Initial access: a DevOps laptop. According to Binance's preliminary findings, the attack started on a DevOps engineer's computer. How it was compromised has not been disclosed. Binance statement
  2. Foothold: a service container that can submit withdrawal requests. From the laptop, the attacker reached a service container able to create withdrawal requests. Teng said further points of compromise beyond the laptop were found and the full chain is not yet clear. Binance statement
  3. Abuse of the signing service. The attacker obtained signatures the signing system should never have produced. According to Binance no private key leaked; the keys stayed where they were, but the system using them signed the attacker's requests. Binance statement
  4. Taking over the wallet on Ethereum with EIP-7702. A single transaction carried 50 authorizations signed for 50 different nonces. One of them matched and delegated the "Binance 14" wallet to the attacker's "sweeper" contract. Other chains saw ordinary signed transfers. Binance statement
  5. Bypassing approvals. Per Teng, the EIP-7702 delegation let the attacker take control of a hot wallet without going through normal approval procedures. Binance statement
  6. Covering tracks. Teng said a self-destruct mechanism wiped the attacker's tools and traces. Whether this was on-chain or server-side was not disclosed. Binance statement
Threat model. Every arrow is a trust boundary, and at every boundary a control was missing. The "missing control" notes are my assessment.

What is EIP-7702, and how was it used here?

Some reports described EIP-7702 as a "multisig protocol"; it isn't. EIP-7702 shipped with Ethereum's Pectra upgrade in May 2025. It lets a normal wallet (an EOA) "borrow" a smart contract's code while keeping its own address, running that code as if it were its own. The goal is to give ordinary wallets smart-wallet features such as batching and gas sponsorship.

To do that, the wallet owner signs an authorization that goes inside a new "type-4" transaction:

authorization = sign(wallet_key, {
  chain_id,   // which chain
  address,    // whose contract code will run
  nonce       // the wallet's current nonce
})

// If the authorization is valid, the wallet's code becomes:
code(wallet) = 0xef0100 || address

From then on, every call to the wallet runs the code at address with the wallet's authority. If that contract is a sweeper that says "send everything to this address", all ETH and tokens in the wallet can leave with one call. The single 64-transfer transaction at 20:24 looks exactly like that.

The 50 nonces matter too. An authorization is only valid if it matches the wallet's nonce at that moment. On an exchange hot wallet that transacts constantly, it is hard to know in advance what the nonce will be. So the attacker appears to have obtained signatures for a whole nonce range and made sure one of them would land. In EIP-7702 an invalid authorization doesn't revert the transaction; it is simply skipped. The 49 misses cost the attacker nothing.

Inference: according to Phoenix Security's analysis, this batch pre-signing suggests the attacker had access not to the key but to a time-limited interface for requesting signatures. The signing service may have verified who sent the request without evaluating what the request did. This is an assessment; Binance has not confirmed it.

IV. On-chain evidence

I pulled the data in this section by querying a public Ethereum RPC node directly. I located the block matching 29 October 20:18 UTC (26,300,739), then scanned every type-4 transaction in the blocks that followed. The transaction targeting "Binance 14" sits in block 26,300,753.

1. The authorization transaction

Transaction
0xad99264d5532ae0dd04b2004eebda05f25657e70dacb764f7ac8d4ccd051298b
Block / time
26,300,753 · 29 Oct 2026, 20:20:59 UTC
Type
0x4 (EIP-7702 set-code)
From
0x7c8601d4645b93cea45f71e118a729332e6b5ca0, the attacker's own address
To
0x28c6c06298d514db089934071355e5743bf21d60 ("Binance 14")
Data / value
0x · 0 ETH. Its only job is to install the delegation.
Authorizations
50, all chainId = 1, all to the same address
Delegate code
0x63e842b054bd624a465454d533c33f573e9c6fae
Nonce range
18,914,775 – 18,914,824 (50 values)
Gas
limit 1,550,000 · used 1,258,562 · status: success · logs: 0

Two things stand out.

First, Binance didn't send this transaction. In EIP-7702 the party that signs the authorization and the party that submits the transaction can differ. All the attacker needed from the signing service was a bundle of 50 signed authorizations. They paid the gas from their own address and put them on-chain themselves. This transaction never appeared in Binance's normal withdrawal flow.

Second, the gas figure says exactly one authorization landed. The arithmetic:

base transaction                              21,000
50 auths × 25,000 (PER_EMPTY_ACCOUNT_COST)  1,250,000
                                            ---------
                                            1,271,000
valid auth, account already exists → refund  −12,500
                                            ---------
expected                                    1,258,500
measured on-chain                           1,258,562

EIP-7702 refunds 12,500 gas for each valid authorization whose account already exists. Invalid authorizations get no refund. Setting aside a 62-gas difference, the refund matches exactly one authorization. One of the 50 signatures matched the wallet's nonce at that moment; the other 49 were skipped.

2. The sweeper contract

The code at 0x63e842b0…6fae is 1,674 bytes. That is tiny for a full smart wallet and about right for a single-purpose tool. I scanned the bytecode for 4-byte values pushed with PUSH4:

SelectorMeaning
0x70a08231balanceOf(address): read a token balance
0xa9059cbbtransfer(address,uint256): send tokens
0x4e487b71Panic(uint256): Solidity's standard error, added by the compiler
0x01e33667, 0x043ff9d2, 0x4782f779, 0x8a179be4, 0x97dc97cb and 9 moreNo match in public signature databases; contract-specific functions

The readable part fits the skeleton of a sweeper: for each token, read the balance and transfer all of it to one address. Some of the unknown selectors are contract-specific entry points; others may just be data in the bytecode that happens to look like a PUSH4.

Limitation: I did not decompile the bytecode. The selector list is a static scan; the functions' exact behaviour needs proper reverse engineering.

3. The drain

From the moment the delegation landed, every call to "Binance 14" ran the sweeper's code. According to Bitquery's trace, the main drain came three minutes later, at 20:24, in a single transaction: 64 transfers carrying 167,464 ETH, 1.6 billion USDT and 62 different tokens. The wallet was swept six more times over the next roughly 3.5 hours, because Binance's own systems kept sending funds to the address.

4. The delegation today

Today eth_getCode returns 0x for "Binance 14", so the wallet is a plain EOA again. Binance revoked the delegation at 00:10 UTC on 30 October. Under EIP-7702 that is done by the wallet signing a new authorization to the zero address (0x0000…0000). Reading the historical code during the attack (0xef0100 + 63e842b0…) needs an archive node; the free node I used doesn't serve that.

5. The Bitcoin side

Bitcoin has nothing like EIP-7702. The outflow there was an ordinary signed transaction: 18,270 BTC left the hot wallet in a single block and was split across 19 addresses. According to Elliptic, those 19 addresses haven't moved since. So the attacker got a valid signature for Bitcoin from the signing service as well. That shows the problem wasn't specific to EIP-7702; it was in the signing service itself.

V. Why couldn't it be stopped?

To me this is the most instructive part. On paper everything was in place: the keys weren't stolen, the signing system worked, approval processes existed. The problem was that three things were true at once:

  • There was a standing path from a developer machine to production. A laptop could reach a service that can create withdrawal requests.
  • The signing service signed non-standard requests. EIP-7702 authorizations for 50 different nonces is a request an exchange would never see in normal operations. It was signed anyway.
  • Speed and multi-chain concurrency. Outflows starting on nine chains within 20 minutes left no time for human approval or manual intervention. The EIP-7702 revocation came about four hours after the first outflow.

I wrote something similar in the Liquid Network piece: an attacker usually breaks the process, not the cryptography. Here too the keys were sound; the weak link was a system that didn't question what it was signing.

VI. Where is the money now?

Short answer: most of the money still sits in addresses the attacker controls, but very little has been cashed out. What has happened over the past 17 days is not cash-out but conversion: turning freezable assets into unfreezable ones, meaning ETH and BTC. Per Elliptic's update of 13 November:

Frozen or seized Converted, dispersed, in laundering channels (approx.) In attacker addresses, mostly untouched
Total $6.43 billion (Elliptic). The middle slice is the difference between the other two, not a precise figure.

Status by asset

AssetStolenStatus today
BTC18,270 BTCIn 19 addresses, never moved. On top of that, about 4,100 BTC ($285M) from laundering has accumulated in new addresses.
ETH$1.16BOnly about $3M has moved. The nine largest addresses, holding 89% of the ETH, have been silent since 30 October.
USDT / USDC$3.46BMostly frozen. About $786M was swapped into ETH and TRX before the freezes landed.
XRP233M XRPAbout 8.5M XRP ($9M) left. The rest went to BTC via THORChain.
TRX~$210MLess than $10M left. The rest was bridged to ETH.
SOL~$90MAll swapped, bridged or mixed. About 430 SOL remains.
NEAR$41MAbout $2M has moved in small batches.

Frozen and seized

  • Total: per Elliptic, about $2.85 billion has been frozen or seized, 44% of the haul. In the Bybit case that figure was only around 3%.
  • US Department of Justice (12 November): obtained court authorization to seize or restrain more than $1.2 billion of the stolen assets. That is part of the frozen total, not on top of it. Which assets it covers has not been disclosed.
  • Tether: 1.76B USDT in 11 freezes on Ethereum and TRON; six of them hit wallets that were already empty.
  • Circle: 823M USDC, frozen before any of it moved.
  • Others: about $132M from World Liberty Financial (USD1), Paxos, Ripple and First Digital. Binance blacklisted about $75M of its own wBETH token.
  • Arbitrum Security Council: moved the attacker's ARB and ETH on Arbitrum into a locked wallet.

How are they moving it? Phase by phase

By Elliptic's count, the first two weeks involved nearly 27,000 wallets, 16 blockchains, at least 36 services and more than 83,000 transactions. That speed and scale point to a largely automated operation.

The freeze race. Stablecoins are swapped on DEXs into ETH and TRX before issuers can freeze them; about $786M gets out. Circle freezes all 823M USDC before it moves.
TRON becomes the main route. A distribution wallet splits 684.6M TRX across about 7,700 addresses. Six bridges first see test-sized transfers, then the real batches. At least $147M leaves TRON, mostly paid out as ETH.
New routes. A shift into USDD, a stablecoin marketed as freeze-free, and a JustLend vault (128M TRX deposited from one address, withdrawn to 16). THORChain halts swaps on most chains; the attacker moves to other bridges.
TRON stops, others start. Last TRON transfer at 05:33. NEAR, ETH and SOL start moving. Wasabi-style coinjoins begin on Bitcoin.
XRP and SOL into BTC. 233M XRP moves to six new addresses. SOL goes to USDC, is bridged to Ethereum, swapped to ETH, then to BTC via THORChain. On 4 November, 725,000 SOL is spread to 77 wallets in 204 transfers. The Aave loan is partly liquidated.
Mixers. XRP moves in batches to BTC via THORChain. From 8 November, about 11,000 ETH goes into Tornado Cash. Self-minted meme tokens and liquidity pools are used on TRON, NEAR and Solana.
Slowdown. The last XRP address empties on 11 November. Activity has slowed since.

The techniques

USDT (TRON) → TRX → 7,700 addresses → bridges → ETH → THORChain → BTCThe main pipeline. Every hop means moving further from an issuer with freezing power. By 1 November alone, THORChain had processed about $48.3M across 2,697 deposits. $42.7M reached the attacker, so about 12% went to fees and slippage.
A self-minted token and a single poolSpotted by TRM Labs: a token only its creator can mint, paired in a single TRON DEX pool with a lending protocol's receipt token. Fresh "buyer" wallets fill the pool with the attacker's own money. The attacker mints tokens for free, sells them into the pool, withdraws the receipt token and redeems it for USDT. On-chain it looks like ordinary trading, and it breaks the trail.
Breaking the trail with a lending receiptWallet A deposits USDT into a lending pool and sends the receipt token to wallet B. B redeems it for USDT and sends it to a bridge. An analysis that only follows USDT sees no link between A and B.
Chained bridgesOne bridge's output goes straight into a second bridge's deposit address. Some batches crossed four chains within a few hours.
Coinjoin and privacy poolsBy 10 November about 150 BTC ($11M) had gone through coinjoins. About $6.7M entered Privacy Cash on Solana, which paused deposits on 4 November. About 11,000 ETH has gone into Tornado Cash since 8 November.
Cashing out: OTC networksChainalysis found a small amount (hundreds of thousands of dollars) reaching China-based OTC and underground banking networks. That shows the attacker is attempting to cash out. Per Elliptic, the amount cashed out so far is "negligible".

One more detail: about $16 million went to addresses that also hold proceeds from the September 2026 Bitget hack. That suggests the two incidents share laundering infrastructure.

What comes next?

The Bybit case is the guide. Elliptic expects the dormant ETH to be converted to BTC in small transactions and cashed out through OTC brokers over months. Freezing gets much harder at that stage. BTC and ETH have no issuer; the only brake left is where this money meets cash: exchanges, brokers and payment processors. That is why adding the 600-plus addresses the FBI published to block lists is a must for every exchange.

VII. Who did it?

TRM Labs assessed with high confidence that the attack belongs to North Korea's TraderTraitor group (under the Lazarus umbrella). Chainalysis independently reached the same conclusion. Two days after the incident, the FBI, Secret Service and IRS-CI formally attributed it to TraderTraitor, published the attacker's addresses and urged the industry to block transactions from them.

TraderTraitor is a familiar name: the FBI linked the same group to the $1.5 billion Bybit hack in February 2025 and to the DMM Bitcoin case in May 2024. At Bybit, signers approved a malicious transaction because of a manipulated interface; at DMM, an employee of a vendor was targeted with a fake job offer. The common theme: the target isn't the key, it is the people and systems standing next to it.

Inference: TraderTraitor has historically targeted developers with fake job offers and trojanised tooling. It is plausible the Binance laptop was compromised the same way, but this has not been confirmed.

MITRE ATT&CK mapping

I mapped the incident to ATT&CK techniques. known marks steps disclosed by Binance or law enforcement; inferred marks my assessments based on TraderTraitor's past cases and the shape of the attack.

TacticTechniqueIn this incident
Initial accessT1566 Phishing / T1204 User ExecutionThe DevOps engineer's laptop. TraderTraitor's known method is fake job offers and trojanised tools.inferred
Credential accessT1552 Unsecured CredentialsKubeconfig, cloud tokens or SSH keys on the laptop used to reach production.inferred
Lateral movementT1021 Remote Services / T1609 Container Administration CommandAccess to the service container that can create withdrawal requests.known technique inferred
Defense evasionT1078 Valid AccountsRequests to the signing service that looked like a legitimate internal service.inferred
ImpactT1657 Financial Theft$6.3 billion out across nine chains.known
Indicator removalT1070 Indicator RemovalThe mechanism Teng described that wiped tools and traces.known

VIII. Lessons for an exchange security team

This section combines recommendations from public analyses with my own experience.

1. The developer laptop is part of the security boundary

  • Developer and DevOps machines should have no standing access to production. Access should be approval-based and time-boxed ("just-in-time"), through a hardened jump host.
  • When a machine is suspected, every credential and token that machine ever touched should be rotated.

2. The signer must ask "what was requested", not only "who asked"

  • Put a policy engine in front of the signing service. Reject EIP-7702 authorizations by default; reject batch requests that span a nonce range.
  • Enforce rate and amount limits per chain and per wallet. Any request that doesn't fit a standard withdrawal template goes to an independent human approval.
  • Split signing authority across chains and wallet tiers. No single service should be able to sign on nine chains at once.

The core of such a policy engine could look roughly like this. The key idea: the signer doesn't trust what the caller says; it looks at the data it is about to sign and re-verifies the withdrawal against its own independent record.

def evaluate(request):
    tx = decode(request.payload)             # what exactly are we signing?

    # 1. Treasury wallets never need EIP-7702
    if tx.type == 4 or request.kind == "eip7702_auth":
        return DENY("7702 forbidden on treasury wallets")

    # 2. Pre-signing future nonces = attack signature
    if len(request.nonces) > 1 or tx.nonce != chain.nonce(request.wallet):
        return DENY("nonce range / unexpected nonce")

    # 3. No ledger entry, no signature
    w = ledger.get(request.withdrawal_id)     # separate DB, separate team
    if not w or w.to != tx.to or w.amount != tx.amount:
        return DENY("does not match ledger")

    # 4. Anything off-template goes to humans
    if not standard_template(tx):
        return ESCALATE(approvers=2, reason="off-template")

    # 5. Sliding-window limits
    if window_sum(request.wallet, "10m") + tx.usd > limit[request.wallet]:
        return ESCALATE(approvers=2, reason="amount limit")

    return ALLOW

3. Detect in minutes, stop in seconds

Three detections I would put in place. First, any interactive access to signer pods. On the runtime side, with Falco:

- rule: Exec into custody signer pod
  desc: Interactive process spawned inside a signing-service container
  condition: >
    spawned_process and container
    and k8s.ns.name = "custody-signer"
    and proc.name in (sh, bash, ash, zsh, python, python3, node, curl, wget, nc)
  output: >
    Exec in signer pod (user=%user.name cmd=%proc.cmdline
    pod=%k8s.pod.name image=%container.image.repository)
  priority: CRITICAL
  tags: [custody, mitre_t1609]

And on the control-plane side, the same thing in the Kubernetes audit log, as a Sigma rule:

title: Exec or attach into custody signer pod
logsource:
  product: kubernetes
  service: audit
detection:
  selection:
    verb: create
    objectRef.resource: pods
    objectRef.subresource: [exec, attach, portforward]
    objectRef.namespace: custody-signer
  condition: selection
level: critical
tags: [attack.execution, attack.t1609]

Second, a circuit breaker for multi-chain signing bursts. On this day nine chains started signing within 20 minutes; under normal operations that never happens:

# Sliding 5-minute window over the signing-service log
w = signatures.last("5m")
chains = distinct(w.chain)
drain_ratio = sum(w.usd) / hot_balance_usd(chains)

if len(chains) >= 3 and drain_ratio > 0.10:
    breaker.trip(scope="all_hot_wallets")   # stop signing, require humans
    page(oncall, sev=1)

Third, continuous EIP-7702 monitoring on treasury wallets. Checking eth_getCode alone tells you after the fact; recovering the signer of every authorization in every type-4 transaction tells you the moment the delegation hits the chain. With viem:

import { createPublicClient, webSocket, recoverAuthorizationAddress } from "viem";
import { mainnet } from "viem/chains";

const HOT = new Set(["0x28c6c06298d514db089934071355e5743bf21d60" /* , ... */]);
const client = createPublicClient({ chain: mainnet, transport: webSocket(WS_URL) });

client.watchBlocks({
  includeTransactions: true,
  onBlock: async (block) => {
    // 1. Was a 7702 authorization signed by one of our wallets in this block?
    for (const tx of block.transactions) {
      if (tx.type !== "eip7702") continue;
      for (const auth of tx.authorizationList) {
        const authority = (await recoverAuthorizationAddress({ authorization: auth })).toLowerCase();
        if (HOT.has(authority)) {
          alarm("7702 authorization on-chain", { authority, delegate: auth.address, tx: tx.hash, nonce: auth.nonce });
        }
      }
    }
    // 2. Does any of our wallets currently carry a delegation designator?
    for (const w of HOT) {
      const code = await client.getCode({ address: w });
      if (code?.toLowerCase().startsWith("0xef0100")) {
        alarm("wallet delegated", { wallet: w, delegate: "0x" + code.slice(8, 48) });
      }
    }
  },
});
  • Have a pre-approved procedure to take back a delegated wallet: an authorization to the zero address, ready to sign within minutes. At Binance that revocation took about four hours.

4. Keep only what you need in the hot wallet

  • Hot-wallet balances should be capped at what the next withdrawal window needs. That 18,270 BTC could leave in a single Bitcoin block shows how much value was sitting hot.

IX. Conclusion

The day after the incident, Binance announced it would cover all losses. Within days it said it had replenished about 98% of the affected tokens from its SAFU fund, futures insurance fund, Bitcoin reserve and corporate treasury, reopened withdrawals from 1 November and published a proof-of-reserves snapshot. For users, the story closed relatively fast. For the industry, it is only starting.

What this incident shows: protecting private keys very well is no longer enough. Every system that uses the key, every machine that can reach that system and every person using that machine is part of the security boundary. Attackers aren't looking for the key; they're looking for the chain that decides what the key signs.