Layla Zulfa
The Ethereum Foundation’s "Trillion Dollar Security initiative," launched on May 14, 2025, has identified blind signing and transaction uncertainty as critical user experience risks within the decentralized ecosystem. In response, the initiative is actively exploring the implementation of native transaction assertions as a crucial next step to enforce a transaction’s final outcome, working in tandem with the previously announced Clear Signing protocol on May 12, 2026. This development marks a significant push towards bolstering the integrity and predictability of on-chain operations, aiming to protect users from a range of exploits that leverage the inherent complexities of Ethereum’s transaction model.
At the heart of the problem lies a fundamental characteristic of how Ethereum processes transactions: it executes precisely what is authorized by a signature, without inherent judgment on whether the resulting outcome aligns with the user’s initial intent. A valid digital signature merely commits to a request; the ultimate outcome is dynamically determined by the smart contract code and the prevailing blockchain state at the moment of execution. This disjunction creates a vulnerability where users can suffer substantial financial losses, either by inadvertently approving an action different from what they believed they were signing, or by executing an intended request that nonetheless yields an undesirable or unexpected result due to changing network conditions or malicious actors.
The Peril of Unintended Outcomes: Intent and Outcome Mismatches
The issue of unintended transaction outcomes manifests primarily in two forms: intent mismatch and outcome mismatch. Both scenarios have historically led to devastating financial losses for users and have underscored the urgent need for more robust on-chain safeguards.
An intent mismatch occurs when a user signs a transaction believing it to perform one action, but the underlying data or a compromised interface has manipulated it to perform another. This type of attack often exploits user trust in front-end applications. Notable incidents illustrate this vulnerability vividly. In the Bybit incident, attackers managed to compromise a front-end, supplying a signing request that differed significantly from what users believed they were approving. Specifically, signers inadvertently authorized the replacement of a Safe’s implementation contract, granting attackers control over critical infrastructure. Similarly, the BadgerDAO attack saw compromised front-ends trick users into granting attackers broad permissions to spend their tokens, leading to substantial theft. In both cases, the users’ signatures were technically valid, but they committed to actions far removed from their actual intent.
An outcome mismatch, conversely, arises when a user signs a transaction with a clear understanding of the requested action, but the execution context—such as network state, liquidity conditions, or transaction ordering—leads to an outcome that conflicts with their economic goals or established safety policies. A stark example of this is the Aave and CoW collateral swap incident. A user initiated a swap to exchange approximately $50.4 million worth of aEthUSDT for aEthAAVE. However, the AAVE liquidity was severely insufficient for a trade of that magnitude. Complicating matters, CoW’s gas ceiling mechanisms rejected more complex, potentially safer quotes during verification, leaving only one highly unfavorable verified quote of roughly 329 aEthAAVE. Despite the interface prominently displaying a 99.9% price impact warning and requiring explicit confirmation of potential total value loss, the user proceeded with the signature, ultimately receiving tokens valued at a mere $36,000—a catastrophic loss of over 99.9% of their initial capital.
In each of these scenarios, a critical missing element was a trusted, on-chain rule that could assert and enforce a desired final state, independently defined from the transaction builder and rigorously enforced during execution. For instance, in the Bybit case, a rule could have dictated that the approved Safe implementation contract must remain unchanged. A BadgerDAO user’s rule could have restricted new token approvals exclusively to officially published Badger contracts. For the Aave user, a rule could have set a minimum acceptable output for the swap, calculated independently of the front-end’s quoted value. The current Ethereum Virtual Machine (EVM) lacks a general, native mechanism for smart contracts to inspect the full suite of net state changes and events produced by a transaction, making such outcome-based assurances impossible.
The Limitations of Current Security Measures
Existing security measures, while valuable, often fall short in addressing the multifaceted risks posed by blind signing and transaction uncertainty.
Clear Signing, a significant advancement announced in May 2026, aims to improve transparency by decoding transaction calldata and presenting the user with a human-readable explanation of the action being requested. While this helps users verify their intent, its effectiveness relies on accurate decoding and the user’s ability to discern discrepancies between the displayed action and their actual intention. It does not, however, prevent changes in the underlying smart contract code or the blockchain state from altering the transaction’s outcome post-signature.
Transaction Simulation offers another layer of defense by predicting a transaction’s effects against a chosen chain state. Wallets and interfaces commonly use simulations to provide users with an estimate of what will happen. However, the chain state can change between the moment of simulation and the transaction’s actual inclusion in a block. Furthermore, sophisticated malware, as seen in the Radiant Capital case, can substitute a malicious payload at the signing stage, even if both the wallet interface and the simulation initially showed the intended transaction. This "what you see is not what you sign" problem bypasses pre-execution simulations entirely.
Contract Checks and Wallet Guards represent on-chain mechanisms designed to enforce specific rules during EVM execution. For example, Uniswap automatically reverts a swap if the output falls below a user-defined amountOutMinimum. Safe (formerly Gnosis Safe) employs a checkAfterExecution hook, allowing a guard contract to inspect the account’s state post-execution and revert transactions that violate predefined rules for owners or configuration. While effective for specific, pre-defined checks, these approaches require advance knowledge of which state variables to inspect. They depend on the target contract exposing functions to read its storage (e.g., a token’s balanceOf). Crucially, these checks cannot inspect the full set of net state changes. A guard can verify that a particular balance remains unchanged, but it cannot query the EVM about everything else that changed, leaving unnoticed any unintended side effects it wasn’t explicitly programmed to monitor. For instance, a proxy contract might not expose its implementation address through a function, preventing a guard from directly verifying its code.
Native Transaction Assertions: A Paradigm Shift in Security
Native transaction assertions propose a fundamental shift by empowering on-chain code to inspect the entire set of net state changes after a transaction’s actions have been executed. An assertion, integrated directly into the transaction, uses read-only logic to compare the initial and final values of state variables against a predefined rule. If this rule is violated, the entire transaction is reverted, preventing unintended or malicious outcomes from persisting on the blockchain.
The assertion rule is included in the transaction and cryptographically signed alongside its intended actions. This rule can be highly flexible, encompassing net changes to native ETH balances, contract storage, deployed code, and emitted events. It can enforce crucial safety parameters such as requiring a minimum amount of tokens received in a swap, capping spending limits, blocking unauthorized new token approvals, preserving an account’s control logic (e.g., ensuring a Safe’s implementation contract remains unchanged), or permitting only a specified, whitelisted set of changes.
Crucially, the source of the assertion rule is paramount. A compromised front-end, capable of manipulating the transaction’s primary actions, could equally write an assertion that permits the very attack it’s meant to prevent. Therefore, a truly effective rule must originate from an independently approved source of user intent, a standing account policy, or robust protocol logic that cannot be tampered with by a compromised component. This independent validation ensures the integrity of the safety net.
EIP-7906: A Concrete Proposal for Transaction Assertions
The development of native transaction assertions is a core component of the Ethereum Foundation’s "Trillion Dollar Security initiative," and EIP-7906 (Transaction Assertions via State Diff Opcode) stands out as a leading candidate for implementation. EIP-7906 builds upon the "frame transactions" concept introduced in EIP-8141, which is scheduled for the upcoming Hegotác upgrade. While EIP-7906 has advanced to "Considered for Inclusion," its confirmation for the upgrade is still pending.
EIP-8141 introduces a new transaction type, the "frame transaction," which allows for an ordered sequence of validation and action steps. EIP-7906 extends this by adding a special, read-only POST_TX frame that executes at the very end of the transaction. This POST_TX frame is specifically designed to check the transaction’s outcome without introducing any new state changes itself, effectively acting as a final integrity check.
The design of EIP-7906 exposes comprehensive information about the transaction’s execution. State changes are reported as net differences in native ETH balances and storage slots, alongside newly deployed contracts and their corresponding code hashes. A key optimization is that storage slots written multiple times will only appear as a single entry with their starting and final values. If a slot ultimately reverts to its original value, it will not appear in the diff at all, minimizing data overhead.
To access this critical information, EIP-7906 proposes three new EVM opcodes (instructions):
TXTRACE: This opcode enables enumeration of all net state changes and emitted events, providing a holistic view of the transaction’s impact.TXDIFF: This allows for retrieving the starting and final values for specific addresses and storage slots, facilitating targeted checks.EVENTDATACOPY: This opcode copies an event’s data into memory, enabling assertions to react to specific events emitted during execution.
These opcodes are strictly confined to the POST_TX frame, which executes as a static call. This read-only nature ensures that assertions cannot inadvertently modify state or introduce new vulnerabilities. If an assertion rule within POST_TX is violated, the entire preceding execution body of the transaction is reverted. However, the transaction itself still remains in the block with a failed status, and the gas payer is charged for the gas consumed. This design choice is crucial: it prevents attackers from submitting deliberately failing transactions for free, which could otherwise be used as a denial-of-service vector against network builders.
Challenges and the Imperative of Required Assertions
While EIP-7906 offers a powerful security primitive, its effectiveness hinges on widespread adoption and enforcement. The current design of EIP-7906 does not mandate that transactions include an assertion; transaction builders retain the discretion to omit them.
For user-initiated transactions, this places the onus on wallet providers. Wallets must evolve to ensure that every frame transaction they construct includes the necessary assertions. These rules could be dynamically generated based on a simulation run by the wallet (e.g., "confirm output is at least X") or derived from a standing security policy that applies to all transactions originating from that account (e.g., "never approve new token spending for unknown contracts").
For protocols, the challenge is different. A protected function within a smart contract would need to explicitly verify that any incoming call originates from a frame transaction that contains the exact required assertion. It would need to reject both ordinary transactions and frame transactions with missing or incorrect assertions. This implies that callers and integrations would be required to use compatible frame transactions, necessitating a coordinated ecosystem-wide upgrade. A significant limitation is that already deployed, immutable contracts could not retroactively add this check, highlighting the importance of integrating such features into new deployments or upgradeable contract architectures.
Broader Implications and Future Potential
Beyond the immediate security benefits for individual users and protocols, native transaction assertions hold significant promise for transforming various aspects of the Ethereum ecosystem:
- Strengthening Delegation: Assertions can revolutionize how users delegate permissions. When granting an agent the ability to act on one’s behalf, users can currently limit the contracts the agent interacts with, the spending amount, and the duration of permissions. Assertions would add a powerful new dimension by allowing users to constrain the outcome of each delegated transaction, ensuring that both the agent’s actions and their results align with the delegator’s intent.
- Protocol-Defined Safety Checks: Protocols could define universal safety rules, requiring all callers using frame transactions to adhere to the same checks. In solver-based execution models, this could enable a protocol to specify a required outcome (e.g., minimum swap amount) while allowing solvers the flexibility to choose the most efficient execution route, knowing the outcome is guaranteed. However, this guarantee would be limited to a single transaction on a single network, not extending to multi-chain operations.
- Workflow Verification: Assertions could ensure that complex workflows reach their intended final state, for example, verifying that unused tokens are returned to the user, and any temporary token approvals are revoked post-execution.
- Enhanced Trust and Adoption: By providing verifiable, on-chain guarantees about transaction outcomes, native assertions can significantly enhance user trust in decentralized applications and the broader Ethereum ecosystem. This increased confidence is vital for driving mainstream adoption and attracting institutional participation, especially given the "Trillion Dollar Security" mandate. The current total value locked (TVL) in DeFi protocols, often exceeding tens of billions of dollars, underscores the massive financial stakes and the necessity of such advanced security measures.
The journey towards fully realized native transaction assertions is an evolving one. Solutions are actively being designed as part of the Ethereum Foundation’s "Trillion Dollar Security initiative." The Foundation emphasizes the critical need for collaboration from wallet providers, protocol teams, and the wider developer community to refine these designs and ensure their effective implementation. Stakeholders are encouraged to contribute to the research by reaching out to [email protected] or by joining the active discussion thread for EIP-7906 on Ethereum Magicians. This collaborative approach is essential to shaping a more secure, predictable, and trustworthy future for Ethereum. Further details on risk controls and priority work can be found at trilliondollarsecurity.org.
