Native Transaction Assertions: Securing Ethereum’s Future Against Blind Signing and Transaction Uncertainty

The Ethereum Foundation’s ambitious Trillion Dollar Security initiative, first unveiled in May 2025, has pinpointed "blind signing" and "transaction uncertainty" as critical user experience risks requiring immediate and robust solutions. In a significant step toward bolstering the network’s resilience, the initiative is now actively exploring the implementation of native transaction assertions. These assertions are designed to enforce a transaction’s final outcome directly on-chain, working in conjunction with other security enhancements like Clear Signing, which was announced in May 2026. This move represents a pivotal shift in Ethereum’s security paradigm, aiming to provide users with unprecedented control and transparency over their digital asset interactions.

The core problem, as articulated by the Ethereum Foundation, lies in the fundamental operational mechanics of the Ethereum Virtual Machine (EVM). While a user’s signature unequivocally authorizes a specific request, the ultimate outcome of that request is contingent upon the smart contract code and the prevailing state of the network at the exact moment of execution. This inherent disconnect between the signed intent and the executed reality has, on numerous occasions, led to substantial financial losses for users. These incidents typically fall into two categories: "intent mismatch," where users approve something fundamentally different from what they believed, and "outcome mismatch," where the intended request still yields an undesirable or economically detrimental result due to dynamic network conditions or insufficient safeguards.

Understanding the Vulnerability: The "Blind Signing" Dilemma

The Ethereum ecosystem, with its total value locked (TVL) frequently exceeding tens of billions of dollars and a market capitalization well into the hundreds of billions, presents an attractive target for malicious actors. The complexity of smart contracts and the speed of blockchain transactions often mean that users are "blindly" signing cryptographic hashes without fully comprehending the intricate details of the underlying operations. This lack of transparent, verifiable outcome guarantees has been exploited in several high-profile incidents.

A prime example of an "intent mismatch" occurred during the Bybit incident. In this scenario, compromised front-end interfaces presented users with a signing request that subtly differed from their understanding. Bybit’s signers unknowingly authorized the replacement of a Safe’s implementation contract, granting attackers control over critical infrastructure. Similarly, the BadgerDAO attack saw users granting broad token spending permissions to an attacker, again through a manipulated interface that obscured the true nature of the transaction being approved. In both cases, the valid signature committed to a malicious request, not the user’s genuine intent. The critical flaw was the absence of an on-chain mechanism to verify that the result of the transaction aligned with a predefined, trusted rule, independent of the front-end.

"Outcome mismatch" presents a different, yet equally damaging, challenge. Here, users approve the transaction as displayed, but external factors or inadequate internal checks lead to an undesirable financial outcome. The Aave and CoW collateral swap incident serves as a stark illustration. A user initiated a swap of approximately $50.4 million in aEthUSDT for aEthAAVE. However, the AAVE liquidity for such a large trade was critically thin. Compounding this, CoW’s gas ceiling mechanism rejected more complex, potentially safer, quotes during verification, leaving only one highly unfavorable quote for roughly 329 aEthAAVE. Despite an interface warning of a 99.9% price impact, the user proceeded, ultimately receiving tokens valued at a mere $36,000. This outcome, though technically "signed for," dramatically conflicted with the user’s economic goal.

In each of these incidents, a fundamental protective layer was missing: a trusted, on-chain rule governing the final state of the network, executed and enforced independently of the transaction builder or front-end. For Bybit, such a rule would have prevented any unauthorized change to the Safe implementation. For BadgerDAO, it would have restricted new token approvals to only official, published Badger contracts. For the Aave user, an assertion could have mandated a minimum acceptable output for the swap, calculated and enforced on-chain, irrespective of the quote presented by the interface. The current Ethereum architecture lacks a generalized mechanism for on-chain code to inspect the full set of net state changes and events produced by a transaction, which is precisely what native transaction assertions aim to address.

Ethereum’s Current Security Landscape and Its Limits

While the Ethereum ecosystem has evolved with various security measures, they each possess inherent limitations when confronted with the dynamic and often adversarial nature of blockchain interactions.

Clear Signing, a significant advancement, seeks to enhance transparency by explaining the requested action of the calldata in a human-readable format. It relies heavily on accurate decoding capabilities within wallets and the user’s ability to discern discrepancies between the displayed action and their actual intent. However, Clear Signing primarily addresses the "intent mismatch" at the point of signing; it cannot predict or prevent an "outcome mismatch" driven by changes in network state after the signature is provided but before execution.

Transaction Simulation offers another layer of defense, predicting a transaction’s effects based on a chosen chain state. Wallets and explorers often utilize this to show users the expected outcome. Yet, simulations are snapshots in time. The actual chain state can change dramatically between the simulation and the transaction’s inclusion in a block, especially in volatile markets or under attack vectors like sandwich attacks. Furthermore, as demonstrated in the Radiant Capital incident, malware on a user’s machine can substitute a malicious payload at the signing stage, rendering even a meticulously simulated transaction irrelevant if the signed transaction is entirely different.

Contract Checks and Wallet Guards represent on-chain, programmatic defenses. Protocols like Uniswap implement amountOutMinimum to revert swaps below a certain threshold. Safe accounts leverage checkAfterExecution hooks, allowing a guard to inspect the account’s state post-execution and revert transactions that violate predefined rules (e.g., owner changes, configuration alterations). While effective for specific, pre-defined checks, these mechanisms have two key limitations:

1. Limited Scope: They require advance knowledge of which state variables to check. A guard might verify a balance remains unchanged but cannot broadly query the EVM about everything else that changed, leaving unnoticed side effects.
2. Interface Dependency: To read another contract’s storage (e.g., a proxy’s implementation address), they depend on the contract explicitly exposing such functions. Without a specific interface, a guard cannot directly access internal storage slots.

Crucially, none of these existing defenses can inspect the full, comprehensive set of net state changes resulting from a transaction. This gap leaves users vulnerable to sophisticated attacks that manipulate state in ways not explicitly covered by existing, pre-programmed checks.

Introducing Native Transaction Assertions: A Paradigm Shift

Native transaction assertions are designed to bridge this critical security gap by empowering on-chain code to inspect the entire set of net state changes after a transaction’s actions have been executed. Conceptually, an assertion functions as a read-only logical check that compares the state before and after a transaction against a predefined rule. If this rule is violated, the entire transaction is automatically reverted.

These assertions are embedded within the transaction itself and cryptographically signed alongside the primary actions. This ensures that the assertion is an integral part of the user’s approved intent. The scope of what an assertion can cover is extensive, encompassing:

• Net changes to native ETH balances.
• Modifications to storage slots across any address.
• Deployment of new contracts and their associated code hashes.
• Emitted events.

This capability allows for highly granular and powerful protective rules. For instance, an assertion could:

• Require a minimum amount of tokens to be received in a swap.
• Cap the total amount of tokens spent or transferred.
• Block the creation of new token approvals.
• Preserve an account’s core control logic (e.g., preventing a proxy implementation upgrade without explicit assertion).
• Allow only a specified, whitelisted set of changes to occur.

The integrity of these assertions is paramount. A compromised front-end, capable of proposing a malicious transaction, could theoretically also propose a malicious assertion that permits the attack. Therefore, a truly effective assertion must originate from an independently approved source, such as a user’s self-defined standing account policy, or from immutable, protocol-level logic that cannot be altered by a compromised client-side interface. This "trusted rule" principle is fundamental to the efficacy of native transaction assertions.

EIP-7906: A Concrete Proposal for Implementation

One leading proposal for implementing native transaction assertions is EIP-7906, which leverages the "frame transactions" introduced by EIP-8141. EIP-8141, currently slated for inclusion in the forthcoming Hegotá network upgrade, defines a transaction structure comprising an ordered sequence of validation and action steps. EIP-7906 extends this by introducing a read-only POST_TX frame that executes at the very end of the transaction lifecycle. This POST_TX frame is specifically designed to inspect the transaction’s final outcome. EIP-7906 has advanced to "Considered for Inclusion," signifying its serious consideration for a future network upgrade.

The design of EIP-7906 meticulously exposes both state changes and events. State changes are reported as net differences: for instance, a storage slot that is written to five times but ultimately reverts to its original value will not appear in the diff, while one that changes will show its starting and final values. This efficient reporting mechanism includes native ETH balance changes, storage modifications, newly deployed contracts, and their code hashes.

To facilitate access to this crucial information, EIP-7906 proposes three new EVM opcodes:

1. TXTRACE: Enables the enumeration of all net state changes and emitted events, allowing an assertion to iterate through and analyze every impact of the transaction.
2. TXDIFF: Provides a targeted mechanism to retrieve the starting and final values for specific addresses and storage slots, ideal for direct comparisons.
3. EVENTDATACOPY: Allows the assertion code to copy the data of an emitted event directly into memory for inspection.

These opcodes are deliberately restricted to operate exclusively within the POST_TX frame and function as static calls. This critical design choice ensures that the assertion logic can inspect the outcome without itself altering the network state, thereby preventing reentrancy or other attack vectors within the assertion itself. If an assertion rule is violated, the entire execution body of the transaction is reverted. However, the transaction itself remains in the block, marked with a failed status, and the gas payer is charged for the gas consumed up to the point of failure. This mechanism is vital to prevent attackers from exploiting assertions to force builders to execute deliberately failing transactions for free, which could be used for denial-of-service attacks.

The Crucial Element: Ensuring Assertion Mandates

While EIP-7906 provides the technical capability for assertions, it does not inherently mandate their inclusion. This places a significant responsibility on wallets and protocols to ensure their widespread adoption and effectiveness.

For individual user transactions, wallets will play a crucial role. A compliant wallet must ensure that every frame transaction it constructs includes the necessary assertions. These rules could be dynamically generated based on a simulation run by the wallet, or they could stem from a user’s pre-configured, standing security policies that apply to all their transactions (e.g., "never allow approvals above $100" or "always ensure minimum output for DEX swaps"). This shifts the burden of security from the user’s manual vigilance to automated, on-chain enforcement.

For smart contract protocols, the integration of assertions requires a more profound architectural consideration. A protocol’s protected functions would need to verify that incoming calls originate from a frame transaction that contains the exact required assertion. This means rejecting ordinary transactions or frame transactions with missing or incorrect assertions. This approach, while powerful, presents a challenge for already deployed, immutable contracts, as they cannot be retrofitted to include this check. New deployments or upgradeable contracts would be necessary to fully leverage this capability. This necessitates a careful transition strategy and broad adoption across the ecosystem to maximize the security benefits.

Broader Implications and Future Use Cases

The introduction of native transaction assertions extends far beyond merely preventing common attack vectors. They offer a foundational primitive for a more secure, expressive, and trustworthy Ethereum ecosystem.

One significant area of impact is strengthening delegation. When users delegate authority to an agent (e.g., a multi-sig signer, an automated bot), they can already set limits on which contracts can be interacted with, spending caps, and permission durations. Assertions could add an unprecedented layer of outcome-based constraints. For instance, a user could delegate a transaction but assert that their balance of a specific token must not decrease below a certain threshold, or that no new approvals are granted without their explicit, separate assertion. This empowers users to define not just what an agent can do, but what its actions must ultimately produce.

Protocol-defined safety checks could become universal. A protocol could define a mandatory safety assertion that every caller using a frame transaction must satisfy, ensuring consistent security across all interactions. In the context of solver-based execution (common in decentralized exchanges), the protocol could specify a required outcome (e.g., a minimum received amount) while granting the solver flexibility in choosing the optimal route. This guarantees the user’s desired result regardless of the complex intermediary steps chosen by the solver. It’s important to note, however, that these guarantees apply within a single transaction on a single network, not across multiple chains.

Assertions could also revolutionize workflow validation. Complex multi-step transactions or sequences could include assertions to ensure that the entire workflow reaches its intended final state. This could include verifying that unused tokens are returned to the user, that any temporary token approvals are revoked, or that specific state changes occur as expected at the culmination of a series of operations. This moves beyond merely checking individual actions to validating the integrity of an entire process.

The "Trillion Dollar Security" Vision: A Proactive Stance

The Ethereum Foundation’s Trillion Dollar Security initiative underscores a profound commitment to safeguarding the immense value transacted and stored on the network. By proactively addressing fundamental user experience risks like blind signing and transaction uncertainty, the initiative aims to cultivate an environment of greater trust and security, which is essential for mainstream adoption and the continued growth of decentralized applications. The exploration of native transaction assertions, with EIP-7906 as a leading candidate, demonstrates a forward-thinking approach to security, moving beyond reactive patches to fundamental architectural improvements.

The ongoing design and development of these solutions are collaborative efforts. The Ethereum Foundation actively seeks input from the broader ecosystem, including wallet developers, dApp teams, and protocol architects. Engagement opportunities, such as reaching out to [email protected] or joining the EIP-7906 discussion thread on Ethereum Magicians, are crucial for shaping these vital security primitives. As Ethereum continues its evolution, these advancements promise to make the network not only more robust but fundamentally safer for billions of dollars worth of digital assets and countless user interactions.