Binance and EIP-7702: what a delegation reveals and what it does not
Lazy Read
An EIP-7702 delegation lets an account authorize code that can act with its identity. The transactions examined help reconstruct what happened, but do not establish whether a private key was stolen or a signing service was abused. The article explains that distinction, which permissions deserve review, and why freezing funds does not mean they have been recovered.
- What a delegation permits
- What remains unproven
- Frozen and recovered funds
Related links
The movements detected on October 29 from accounts labelled as Binance wallets raise a question more useful than the headline figure: what authorization allowed code to execute under a hot wallet’s identity?
The reconstruction points to EIP-7702, a legitimate Ethereum feature. Observing a delegation does not reveal how its signature was obtained or establish a protocol flaw. On-chain observations and explanations that still need evidence should remain separate.
Analysis reviewed on October 30, 2026, focused on the October 29 transactions. This is not an internal forensic report or a final accounting of losses.
What can be checked: delegation, then sweeping
In the delegation transaction, Etherscan shows a type-4 operation at 20:20:59 UTC, addressed to the account labelled Binance 14. The code destination is 0x63e842B054Bd624a465454D533C33F573e9c6fAe.
Its table contains 50 authorizations with consecutive nonces, from 18,914,775 to 18,914,824; it marks nonce 18,914,809 as valid. This is an explorer observation, not an independent recovery of every signature. Providing several authorizations can cover different nonce states; it does not identify their producer or prove a lack of knowledge about the account state.
At 20:24:23 UTC, another transaction interacts with Binance 14 from an external address and shows approximately 167,464 ETH leaving, alongside token transfers. The gap is three minutes and twenty-four seconds.
Explorer labels help track the case, but do not independently establish who controlled a key or whether an organization authorized an operation.
What EIP-7702 changes
The specification allows an externally owned account (EOA) to authorize a destination whose code will execute in that account’s context. Its address and cryptographic authority remain; delegated code adds an execution path.
Three roles matter:
- Authorizing account: its signature permits the delegation.
- Transaction sender or relayer: submits the transaction and pays gas; it may be a different address.
- Code operator: if the implementation defines that role, it can trigger the functions it permits.
Once authorized, the code can make calls under the EOA’s identity according to its logic. Delegation persists until replaced or cleared. It should therefore be treated as a sensitive control change, even if the initial authorization transfers nothing.
Ethereum.org documents implementation, initialization and upgrade precautions. A valid signature alone is not enough: the behavior it authorizes matters.
Why delegate if direct transfers were possible?
Was the private key compromised, or was a signing service with permission to authorize EIP-7702 delegations abused?
One hypothesis deserves investigation: an intruder might have obtained delegation signatures without extracting the private key or gaining access to an unrestricted signer.
A custody service may keep keys isolated while letting a backend request specific operations. If its policies rejected arbitrary transfers but accepted delegation to a manipulable destination, the authorized code could ultimately do what the transfer API prevented.
This would be an indirect authorization failure: checking an immediate effect while overlooking the capabilities granted for later use. An HSM or MPC system can protect secret material without preventing a harmful signature requested through an incorrectly authorized workflow.
The evidence here does not establish that Binance used such a design. A stolen key, a deceived approver or previously leaked signatures could also fit. A relayer does not distinguish between them: even with the full key, it can help batch operations and separate execution from gas payment.
The speed of sweeping does not identify the initial cause either. Moving assets before defenders respond is consistent with several scenarios.
The 780 million USDC movement: do not assume an allowance
Another transaction interacts with Binance 14 and records 780 million USDC moving from the account labelled Hot Wallet 34 to the same recipient.
Decoding its input reveals two addresses, a zero value and embedded call data containing:
Outer selector: 0x043ff9d2
Addresses in the arguments:
0xee7ae85f2fe2239e27d9c1e23fffe168d63b4055
0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 (USDC)
Call encoded inside the data:
0xa9059cbb = transfer(address,uint256)
recipient: 0x5227f603c1ee34ce3c06efe6477003bdfccb2f8c
amount: 780000000000000 base units = 780 million USDC
This is not a complete execution trace, but it rules out presenting an assumed transferFrom as an already verified explanation. The ERC-20 standard distinguishes transferring one’s own tokens from authorized spending of another account’s tokens through transferFrom.
Establishing the actual route requires internal calls, code and permissions at the movement’s block. A contract may recognize executors, modules or roles; not every relationship between wallets is a token allowance.
The useful conclusion is to investigate the compromised account’s external capabilities, rather than infer a specific permission from a Transfer event.
What a selector can establish
Computing Keccak-256 confirms that execute(address,uint256,bytes) produces selector 0xb61d27f6. Those four bytes do not reconstruct the full declaration: they do not identify parameter names, visibility, payable, return values or access controls. Signature collisions also exist. The Solidity ABI specification defines what enters that calculation. Identifying a candidate signature helps read a decompilation; establishing behavior requires checking bytecode and actual calls.
Frozen does not mean recovered
Early estimates mix networks, observation times and valuation methods. Unchained breaks down approximately $3.5 billion in Ethereum outflows and cites higher multichain estimates that its team does not present as independently verified. It also documents announcements of USDT and USDC freezes. These figures are not a final net-loss accounting.
What does freezing mean? Circle explains that it can prevent an address from sending or receiving USDC. Blocklisting does not reverse a transfer or automatically return a balance to its previous owner.
Any recovery requires additional action and depends on implementation, issuer powers and the applicable process. It should not be assumed that both issuers will burn and reissue all blocked funds. Native ETH and BTC have no equivalent blocklist controlled by Tether or Circle. Nor does every non-stablecoin token lack administrative controls: each asset needs checking.
What to review in signing infrastructure
The case supports concrete controls without inventing its root cause:
- Approve capabilities, not only amounts. Review the authorized code, chain and upgrade paths. Separate proposal from approval.
- Constrain the signer. Avoid blind signing or arbitrary hashes when only defined operations are needed. Protect policies and implementation allowlists too.
- Map trust relationships. Inventory allowances, roles, modules and executors that recognize each sensitive account’s identity.
- Correlate records. Connect signing requests and approvals with delegation changes, internal calls and asset movements.
- Rehearse containment. Clearing delegation does not repair a compromised signer, return assets or cancel external permissions. Those require separate actions.
The unresolved question is not only who had the key. It is what enabled a valid authorization, what capability it granted and which other systems trusted that account. Transactions help reconstruct effects; explaining initial access also requires evidence from the signing process.