Binance Hack: How EIP-7702 May Have Amplified Losses
The reported Binance hack points to compromised signing systems, not an EIP-7702 flaw alone. Learn how delegation may affect losses and which controls matter.

What the Binance Hack Reveals About EIP-7702 and Wallet Security
Big crypto thefts almost never trace back to one checkbox or one mistake. In the reported $6.3 billion Binance hack, investigators were still mapping how the break-in unfolded after Binance initially pointed to a compromised engineer laptop. Security experts then highlighted the role of compromised signing systems, and Ethereum's EIP-7702 also entered the conversation - largely because it can change how withdrawals and other actions get bundled and executed.
That doesn't mean EIP-7702 caused the breach. The key point for anyone running a crypto service is this: a protocol feature can affect how quickly an attacker can act, without being the way they first gained access. Even a transaction that's "correct" from a cryptographic standpoint - signed by a secure signer - can still be malicious if the request is misleading or the surrounding approvals and checks are weak.
This article sticks to what's been reported and what still isn't clear. It explains what EIP-7702 changes, how a signing-system compromise can turn into an on-chain loss, and which safeguards are worth reviewing whether delegation is in use or not. The goal isn't to crown one upgrade as "the" story. It's to figure out which parts of the security chain actually deserve attention.
What do we know about the Binance hack?
Binance confirmed a reported $6.3 billion hack and said it would cover the losses. The exchange first suspected an engineer's laptop had been compromised, then said its investigation uncovered additional points of breach. That kind of moving target is common early in incidents: the first device or account identified can be an entry point, but it rarely tells the full story of how assets were reached and authorized.
Binance CEO Richard Teng said investigators found no evidence that wallet private keys leaked. That doesn't rule out other compromises - like the systems or processes that authorize transactions. Private-key exposure is one route to theft, but an attacker can also go after transaction signing workflows, developer environments, or mechanisms that assemble and propose transactions for approval.
Blockaid co-founder and CEO Ido Ben-Natan said attackers may have used a compromised developer computer to reach wallet-signing infrastructure. In his account, the attacker reached a position where they could propose transactions to a signer holding custody of a hot wallet. He also said the signer approved a transaction it should not have approved. Those are informed assessments shared during the investigation, not a complete, public technical postmortem.
And that distinction matters. A signer can do its job at the cryptographic level: it can produce a valid signature. But the security process around it still has to determine whether the transaction being requested makes sense - whether the request is legitimate, whether the destination is appropriate, and whether the operator's intent is actually reflected in the submitted action.
What remains uncertain
The information released so far doesn't spell out exactly how attackers entered the environment, which controls they bypassed, or where EIP-7702 fits into the specific transaction path used in the theft. Ben-Natan suggested the upgrade could have let attackers act in a more efficient "sweep" and potentially bypass certain checks. Ivo Georgiev, co-founder of wallet provider Ambire, argued that if attackers already had the ability to authorize transactions, EIP-7702 wouldn't change much.
Both of those views can be true, depending on which part of the incident you're looking at. An attacker can have enough authority to steal funds, while the transaction format makes that theft faster or easier to carry out. Until a detailed incident report clarifies the sequence, it's safer to treat EIP-7702 as a possible accelerant - not as the proven root cause.
What does EIP-7702 change?
EIP-7702 was introduced as part of Ethereum's Pectra upgrade in May 2025. It lets ordinary externally owned accounts - wallets typically controlled directly by private keys - use certain smart-contract capabilities. Among the features discussed are bundled actions and sponsored gas fees. In practice, that means a wallet can support more flexible behavior than a strict "one action per transaction" pattern.
There are legitimate reasons for that. Bundling can reduce how many approvals a user has to make, and sponsored fees can make certain applications usable for people who don't already hold the network's native token. In a well-designed flow, fewer manual steps can mean less friction and fewer chances for a user to misclick or misunderstand what's being approved.
Those same properties change the risk model. Delegation allows a contract to act on behalf of a wallet after a user or operator authorizes it. If that authorization points to something malicious - or if an attacker can induce or exploit the authorization - delegated permissions can provide a more direct route to moving assets. Bundled operations also mean multiple actions can land in one transaction, which can make the real effect harder to spot for anyone reviewing only the high-level request.
Why EIP-7702 is not a root-cause explanation
EIP-7702 by itself doesn't explain how an attacker got into an exchange's internal systems or how a signing process ended up approving something dangerous. As Georgiev noted, if an attacker can already make a signer authorize transactions, other paths may exist to move funds. EIP-7702 may change the mechanics - how many transactions appear, what checks are encountered, or how the request is structured - but it doesn't remove the need to understand the initial compromise and the approval chain.
Malicious delegations were already a concern before the Binance incident. In May 2025, trading firm Wintermute reported that some early EIP-7702 delegations it observed appeared to target malicious contracts aimed at draining compromised wallets. In September 2025, some World Liberty Financial token holders reported losses connected to malicious delegations. Taken together, those reports point to the bigger issue: users and operators need to treat granted authority as something that can outlive the interface and the moment of approval.
A more useful way to assess the feature is to separate three questions: Who can authorize a delegation? What can the delegated code do? How does the system detect and revoke authority when it's no longer trusted? If you treat those as one blended question, reviews get sloppy. Treating them separately makes the security review more concrete - because the feature might enable real product flows, but the permission model and controls around it still have to be explicit.
How can a signing-system compromise become a loss?
Exchange custody is a chain: people, software, permissions, and cryptographic controls. A typical workflow can include transaction preparation, policy checks, and a signer authorizing the final result before it reaches the blockchain. Even if the private key never leaves a secure device, an attacker who compromises upstream systems can still influence what the signer is asked to approve.
That's why "the keys were not leaked" isn't the whole story. The key may remain protected while the attacker gains leverage over transaction construction, destination selection, the approval context, or the software that presents the request to the operator. If the signer receives a request that fits its rules, it can generate a technically valid signature for a transaction that's harmful.
The failure may be in the request, not the cryptography
Think of the signer as a high-stakes boundary. Its job is to authorize a transaction according to defined rules, not to verify whether the engineer requesting it is under coercion, whether the build pipeline was tampered with, or whether the destination belongs anywhere near the operator's real intent. Cryptography can prevent certain kinds of unauthorized signing, but it can't independently tell whether an authorized request is actually safe.
So an attacker can aim at multiple layers: a developer workstation, credentials used to access transaction tooling, a service that prepares transactions, or the human review step. What's been publicly shared doesn't confirm which of these happened at Binance. But those are exactly the boundaries an investigation has to examine if it wants to explain what went wrong.
EIP-7702 can matter at the execution layer. If delegation lets several actions happen within one sweep, an attacker may need fewer separate transactions. That can break assumptions baked into controls designed around older transaction patterns. Ben-Natan described this as a plausible way checks might have been bypassed - but a "bypass" only makes sense if some control was incomplete, misconfigured, or built on assumptions that no longer match what's being executed.
Why fewer transactions can change the impact
Fewer steps can shrink the time defenders have to notice and interrupt an attack. It can also make review harder if transaction simulation or approval screens don't translate the underlying effects into something clear and legible for the operator. None of this means batching is inherently unsafe. It means systems have to evaluate the actual effects of the proposed operation, not just count transactions or rely on a superficial label.
The operational lesson is to review the full path from request to settlement. Who can initiate transactions? What exact data does the signer see? Which policy checks run before approval? And how quickly can an unusual transfer be stopped? The right answer shouldn't depend on one person recognizing something suspicious under time pressure. Durable security comes from controls that stay effective even when one device, account, or workflow is compromised.
Which controls matter after an EIP-7702 incident?
The most helpful response isn't to ban new wallet capabilities or assume hardware custody automatically solves everything. Instead, test whether the authorization controls still hold when an attacker can influence upstream systems and when the transaction includes delegated or bundled actions. The right design depends on the exchange's custody model, transaction volume, and recovery requirements, but the review should cover both access paths and the meaning of transactions - not just the key storage.
Make the signer evaluate intent
A signing service should apply explicit policy to the transactions it authorizes. That can include destination allowlists (where practical), transfer limits, asset-specific rules, separation of duties, and stronger review for unusual combinations of amounts, destinations, and contract interactions. These choices come with trade-offs: allowlists can slow down legitimate operations, while broader policies are easier to run but offer less protection if an account or workflow is compromised.
For EIP-7702 and other complex transaction types, simulation can help show expected state changes before approval. Ben-Natan called out simulation specifically as a way to catch malicious requests. Simulation isn't magic - it depends on accurate inputs, a trustworthy execution environment, and reviewers who can interpret the results. It tends to work best when it's embedded in a defined approval workflow, rather than treated as an optional dashboard people check only if something "looks off."
Treat delegations as continuing permissions
A security review should inventory active delegations and document who can create, modify, and revoke them. Recovery plans also need to assume that systems might come back online while a malicious delegation remains active. Georgiev warned that engineers may overlook revocation after regaining control. In practice, incident checklists should explicitly confirm which delegated permissions are still in force and verify that revocation has actually taken effect.
This logic doesn't stop at EIP-7702. Recovery isn't finished just because a compromised machine has been removed. Teams need to think about credentials, sessions, API permissions, signing policies, pending transactions, and any authority that might persist after the first breach. When you keep a clear inventory, you can revoke capabilities based on evidence - not memory - during an incident.
Test the whole process, not just the key store
Run a hostile tabletop exercise: start with a compromised developer environment generating a proposed transaction, then walk through the signer, monitoring, and incident response. Test whether a single person or service can initiate and approve a high-value transfer. Test whether alerts arrive before settlement. And test whether responders know how to pause activity and preserve evidence. Then repeat the exercise with bundled actions and unfamiliar contract interactions.
Key takeaways
- A private key can stay protected while a compromised workflow still influences what gets signed.
- EIP-7702 may change how quickly or how cleanly an attacker can carry out an action, without being the original root cause.
- Simulate and review transaction effects - not only labels or transaction counts.
- Track delegated permissions and make revocation part of incident recovery.
- Build controls for the reality that one device, account, or team member can be compromised.
Conclusion
The reported Binance incident highlights a distinction that matters in crypto custody: protecting a private key is not the same thing as ensuring every transaction the key authorizes is legitimate. EIP-7702 may have changed the mechanics or pace of the reported attack, but the public accounts still point to signing-system integrity and authorization controls as the central questions - not to a single protocol feature acting alone.
For exchange operators, the practical response is to review the full transaction path, test controls against compromised upstream systems, simulate complex operations, and treat delegation revocation as part of incident recovery. For users and builders, the rule is simpler: understand what authority a wallet grants, and verify what a transaction will actually do before approving it. Security holds when the system catches a bad request even after one layer has already failed.