How the Binance Hack Happened, and How Crypto Was Stolen
In the October 2026 Binance hack, EIP-7702 delegation, a sweeper contract, and leaving 1 ETH behind stood out. I explain the flow simply.

Why was the Binance hack talked about so much?
A few days ago, a much talked about hack related to Binance came up. I also wanted to gather my notes and explain the incident in a simple way. Honestly, what stood out in this attack was not just the money leaving, but how the attack was planned.
From the sources I found online, the attacker did not make a normal transfer attack. Instead, they built a more operational setup that brought together EIP-7702 delegation, a sweeper contract, and the hot wallet logic. For me, the real important part started there.
What is EIP-7702, and why is it important?
Blockchain is a distributed database that everyone can read, but that cannot be changed retroactively. Ethereum is a system that runs on top of this structure. Concepts like account, address, transaction, and nonce are basic parts here. Normal accounts, that is EOA’lar, only execute signed commands, while smart contracts are programs that run on chain.
EIP-7702 is a feature that came in 2025. In short, with a single signed authorization, a normal account can run another contract’s code as if it were its own code. The account stays the same, but its behavior changes. This authorization can be sent to the chain as long as the signature is valid. So the attacker can direct the account’s behavior without directly stealing the account’s private key.
What did the attacker do?
According to the flow in the notes, the attacker first took over a Binance engineer’s laptop. The private key did not leak, but they were able to get the signing system to sign whatever they wanted. Then they deployed a sweeper contract on chain. This contract was written so it would loop through the tokens inside and send the balance to the attacker.
After that, they got an EIP-7702 delegation signed for Binance 14, directing the account to this sweeper. Because the account was very busy, 50 signatures were sent with 50 different nonces. One of them worked. About 3.5 minutes later, the sweeper was called and the code started running inside Binance’s account.
That is why moving about 2.5 billion dollars in a single transaction was possible. The notes also say the delegation stayed active for about 4 hours. During this time, new money sent to the account also flowed to the attacker. So the attack was not a one time drain, it worked like short term but lasting control.
Why was 1 ETH left instead of taking all the ETH?
One detail in the code stood out, to.call{value: bal - 1 ether}(""). So all the ETH in the wallet is not drained, 1 ETH is left behind. For me, this does not look like just a technical choice. It looks more like an operational behavior aimed at getting past alarm systems.
In centralized exchanges, some alarm mechanisms can be sensitive to thresholds like whether a wallet is completely empty, whether the balance has dropped to zero, or whether the wallet has become unusable. Leaving 1 ETH may have been chosen to avoid making the wallet look completely dead, to avoid triggering instant empty wallet alarms, and to make the wallet still look operational. Also, the hacker is not making Binance pay the gas fee here, they are paying the gas themselves. So the 1 ETH left behind is not required for the sweep.
The notes also say the same behavior was not done for tokens. One reason for this may be the logic of centralized exchange hot wallets keeping native token, that is ETH, for fees. Another reason may be that because the balance was not fully zeroed out, Binance could continue normal user operations. Honestly, that also shows the attacker hit the target exactly.
How was the money moved before it was frozen?
Another striking part of the attack was how quickly the funds that could be frozen were converted. The attacker had a large amount of USDT and USDC. Since these are under company control, they can be frozen. So the attacker raced to convert them into ETH. They swapped a large part of them for ETH on exchanges.
Another route was Aave. The notes say that from one wallet, 60 million dollars of USDT was deposited into Aave as collateral and about 19,762 ETH was borrowed in return. This happened about 40 minutes before the first freezes. In this way, the USDT that could be frozen stayed inside Aave, while the ETH that could not be frozen ended up in the attacker’s hands. After that, Aave closed new deposits and borrowing.
What happened after that?
The notes say the ETH that was obtained was moved across different chains with bridges and passed through mixers. A bridge moves an asset from one chain to another. A mixer mixes the money with other people’s money and makes the trail harder to follow. Tornado Cash is one of the services given as an example of this.
For me, the most instructive part of this incident is that the attack was thought through not just technically, but operationally too. When EIP-7702, the sweeper contract, the choice to leave 1 ETH behind, and the quick escape plan came together, a very planned attack emerged. When following these kinds of events, we need to look not only at what was stolen, but also at how it was designed.
In cases like this, I especially find it useful to examine delegation, nonce, and hot wallet logic separately. Because the real lesson is often hidden there.



Comments