Ethereum’s Trillion Dollar Security Initiative Explores Native Transaction Assertions to Combat Blind Signing and Transaction Uncertainty.

The Ethereum Foundation, spearheading its ambitious Trillion Dollar Security initiative, has identified two critical vulnerabilities—blind signing and transaction uncertainty—as significant risks to user experience and asset security within the sprawling decentralized ecosystem. In response, the Foundation is actively exploring the implementation of native transaction assertions as a fundamental next step to guarantee the final outcome of transactions, complementing existing efforts like Clear Signing. This pivotal development aims to imbue users with greater control and predictability over their on-chain interactions, directly addressing scenarios where a valid signature does not inherently assure the desired transaction result.

The core challenge stems from Ethereum’s deterministic execution model: the Ethereum Virtual Machine (EVM) meticulously carries out authorized requests without inherent judgment on the user’s ultimate intent. A digital signature commits to a specific request, yet its actual outcome is contingent upon the smart contract code and the prevailing state of the network at the moment of execution. This inherent characteristic has, unfortunately, led to substantial financial losses for users, often occurring in two primary forms: an "intent mismatch," where users unwittingly approve an action different from their belief, or an "outcome mismatch," where the intended request, despite being accurately signed, produces an undesirable or economically detrimental result due to unforeseen state changes or external factors.

Understanding the Vulnerability: Blind Signing and Transaction Uncertainty

Blind signing, a prominent vector for intent mismatch, occurs when users sign a transaction without a full and verifiable understanding of its true implications. Wallets often display only a hexadecimal hash of the transaction data, forcing users to "blindly" trust that the front-end interface accurately represents the underlying operation. This trust is easily exploited by compromised front-ends or malicious third parties who can inject entirely different, harmful payloads that users then unwittingly sign.

Transaction uncertainty, on the other hand, characterizes the outcome mismatch. Even when a user fully understands and intends to sign a specific transaction, the dynamic nature of the blockchain can lead to an undesirable outcome. The state of contracts can change between signing and execution, or transaction ordering (e.g., front-running, sandwich attacks) can manipulate market conditions, leading to slippage, liquidation, or other adverse effects that conflict with the user’s economic goals or pre-defined safety policies. The lack of a robust, on-chain mechanism to enforce user-defined post-execution conditions has left a significant security gap.

High-Profile Incidents: A Stark Reminder

The urgency for native transaction assertions is underscored by several high-profile incidents that have resulted in millions of dollars in losses. These events serve as potent case studies demonstrating the limitations of current security paradigms:

• Bybit Incident (2025): While specific details remain under wraps due to ongoing investigations, the Bybit incident reportedly involved a compromised front-end that tricked users into signing transactions that replaced a Safe contract’s implementation. This exploit highlights a severe intent mismatch, where signers believed they were performing routine operations but were, in fact, authorizing critical infrastructure changes. The attacker leveraged the blind signing vulnerability to alter the very foundational logic of a multi-signature wallet.
• BadgerDAO Attack (December 2021): This devastating attack saw hackers drain approximately $120 million from BadgerDAO users. A malicious script injected into the website’s front-end prompted users to approve transactions that granted the attacker permission to spend their deposited tokens. Users, seeing what appeared to be legitimate prompts, unknowingly authorized the theft of their funds. A trusted rule, requiring new token approvals only for verified Badger contracts, enforced during execution, could have prevented this catastrophic outcome.
• Aave and CoW Collateral Swap (May 2023): This incident exemplifies an outcome mismatch. A user initiated a swap of roughly $50.4 million worth of aEthUSDT for aEthAAVE. However, the AAVE liquidity was critically thin for such a large trade. Compounding the issue, CoW Swap’s gas ceiling rejected more complex, potentially safer, quotes during verification, leaving only one verified quote for a mere 329 aEthAAVE. Despite a clear 99.9% price impact warning on the interface, the user proceeded, receiving tokens valued at only about $36,000. Here, a native assertion setting a minimum acceptable output, calculated independently of the interface’s quote, would have reverted the transaction, safeguarding the user’s assets.

In each of these scenarios, a crucial element was missing: a reliable, on-chain rule governing the resulting state, defined independently of the transaction builder and rigorously enforced during execution. Ethereum currently lacks a general mechanism for on-chain code to comprehensively inspect the full set of net state changes and events generated by a transaction.

The Ethereum Foundation’s Trillion Dollar Security Mandate

The Trillion Dollar Security initiative, launched by the Ethereum Foundation, recognizes that the sheer volume of value locked on Ethereum, exceeding hundreds of billions and potentially reaching trillions, necessitates a new paradigm for user protection. This initiative is a concerted effort to fortify the network’s resilience against sophisticated attacks and common user errors. It goes beyond reactive measures, focusing on proactive architectural enhancements that fundamentally improve the security posture for all participants. The initiative’s overarching goal is to ensure that as Ethereum continues to scale and integrate into global finance, its foundational security mechanisms are robust enough to protect vast amounts of digital wealth.

Current Defenses and Their Limitations

Several defensive mechanisms are already deployed to mitigate transaction risks, but each possesses inherent limitations that native transaction assertions aim to overcome:

• Clear Signing: This technique endeavors to explain the requested action to the user by decoding the transaction’s calldata into a human-readable format. While a significant improvement over raw hexadecimal data, its effectiveness hinges on accurate decoding and the user’s ability to discern discrepancies between the displayed action and their actual intent. It cannot, however, predict or prevent adverse outcomes due to changing on-chain state or malicious contract code.
• Simulation: Wallets and third-party services often simulate transactions against a selected chain state to predict their effects. This provides a crucial pre-execution preview. However, simulations are merely predictions. The actual chain state can change between the simulation and the transaction’s inclusion in a block. Furthermore, as seen in the Radiant Capital incident (January 2024), malware on a signer’s machine can substitute a malicious payload at the moment of signing, rendering even an accurate simulation irrelevant. In Radiant Capital’s case, a compromised library allowed an attacker to drain funds by manipulating the withdrawal process. While both the wallet interface and the simulation showed the intended transaction, a malicious payload was swapped in during signing, bypassing these defenses.
• Contract Checks and Wallet Guards: Smart contracts themselves can incorporate internal checks, such as Uniswap reverting a swap if the output falls below a predefined amountOutMinimum. Similarly, multi-signature wallets like Gnosis Safe utilize checkAfterExecution hooks, allowing a guard contract to inspect the account’s state post-execution and revert transactions that violate specific rules for owners or configuration. While valuable, these approaches require defining the state to be checked in advance and are limited by the functions a contract exposes. For instance, a guard can verify a token balance via balanceOf, but without an explicit function, it cannot directly read a proxy contract’s implementation address, leaving critical control logic vulnerable to unmonitored changes. Crucially, these existing checks cannot inspect the full set of net state changes produced by a transaction. They can confirm that a particular balance remains unchanged, but they cannot query the EVM about everything else that might have been altered, allowing unforeseen effects to slip through unnoticed.

Introducing Native Transaction Assertions: A Paradigm Shift

Native transaction assertions represent a fundamental shift in how Ethereum transactions can be secured. This innovative mechanism would enable on-chain code to meticulously inspect the complete set of net state changes after a transaction’s primary actions have been executed. An assertion functions as a read-only logic gate, comparing the initial state values against their final values according to a predefined rule. Should this rule fail, the entire sequence of actions within the transaction is automatically reverted, preventing the undesirable outcome.

Crucially, the assertion rule is embedded within the transaction itself and signed alongside its primary actions. This ensures that the user’s intent regarding the outcome is cryptographically bound to the transaction. These rules can be incredibly versatile, encompassing:

• Financial Safeguards: Requiring a minimum amount received in a swap, capping spending limits, or blocking new token approvals for unauthorized contracts.
• Control Logic Preservation: Ensuring that an account’s control logic (e.g., the implementation address of a proxy contract) remains unchanged or adheres to specific, approved versions.
• Targeted Changes: Allowing only a specified, narrow set of changes to occur, thereby preventing unexpected modifications.

The efficacy of an assertion hinges not just on the check itself, but critically on the source of the rule. A compromised front-end could easily inject a malicious assertion that permits an attack. Therefore, a truly useful rule must originate from independently approved user intent, a standing account policy defined by the user or their wallet, or robust protocol logic that cannot be tampered with by a compromised component. This separation of concerns ensures that the assertion acts as an immutable guardian of the user’s ultimate economic or security objective.

EIP-7906: A Concrete Proposal for Implementation

One leading candidate for implementing native transaction assertions is EIP-7906 (Transaction Assertions via State Diff Opcode). This Ethereum Improvement Proposal builds upon the concept of "frame transactions" introduced in EIP-8141. EIP-8141 defines a new transaction type that encapsulates an ordered sequence of validation and action steps, offering greater flexibility and expressiveness in transaction construction. EIP-7906 then augments this by adding a special, read-only POST_TX frame at the very end of this sequence, specifically designed to scrutinize the transaction’s final outcome.

EIP-8141 is currently scheduled for inclusion in the upcoming Hegotác network upgrade, indicating a clear path for foundational support. EIP-7906, having advanced to "Considered for Inclusion," is a strong contender for future upgrades, demonstrating significant developer interest and alignment with the Foundation’s security goals.

The design of EIP-7906 is comprehensive, exposing both state changes and events. 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 if a storage slot is written to multiple times but ultimately reverts to its original value, it will not appear in the reported changes, simplifying the assertion logic.

To provide access to this critical information, EIP-7906 introduces three new EVM opcodes (low-level instructions):

• TXTRACE: This opcode allows for the enumeration of all net state changes and emitted events, providing a comprehensive overview of the transaction’s impact.
• TXDIFF: This opcode enables targeted retrieval of starting and final values for specific addresses and storage slots, facilitating precise checks.
• EVENTDATACOPY: This opcode allows assertion code to copy an event’s data into memory for detailed inspection.

These powerful opcodes are specifically restricted to operate only within the POST_TX frame. This frame executes at the conclusion of the main transaction as a static call, meaning it can read the state but cannot modify it. This read-only nature is crucial for security, preventing the assertion logic itself from being exploited to alter the chain state. If an assertion rule is violated, the entire execution body of the transaction is reverted. However, the transaction itself remains in the block with a failed status, and the gas payer is still charged for the consumed gas. This mechanism is vital to prevent attackers from repeatedly submitting deliberately failing transactions for free, which could otherwise be used as a denial-of-service vector.

Ensuring Efficacy: The Requirement for Assertions

While EIP-7906 provides the technical scaffolding for native transaction assertions, its ultimate effectiveness hinges on its widespread adoption and, critically, the requirement for its use. EIP-7906, in its current form, does not mandate the inclusion of an assertion in every transaction. This implies that transaction builders could, potentially, omit assertions, leaving users vulnerable.

To address this, two key areas of development and enforcement are necessary:

• Wallet Integration: For user-initiated transactions, wallets must evolve to ensure that every frame transaction they construct includes a robust, user-approved assertion. This rule could be dynamically generated based on a simulation run by the wallet, or it could be derived from a standing security policy that the user has configured for all their transactions. Wallet providers will play a critical role in abstracting the complexity of assertions for the average user, making them a default and intuitive safety feature.
• Protocol Enforcement: Decentralized protocols that manage significant user assets must also adapt. A protocol’s protected functions would need to verify that incoming calls originate from a frame transaction that contains the exact required assertion. Such protocols would reject ordinary transactions or frame transactions with missing or incorrect assertions. This would compel callers and integrating applications to utilize compatible frame transactions with appropriate assertions, thereby creating a secure "assertion-gated" ecosystem. A significant challenge here lies in retrofitting already deployed, immutable smart contracts, which cannot be updated to add this check. This highlights the need for forward-thinking design in new protocol deployments.

Broader Implications and Future Use Cases

Beyond the immediate security benefits for individual users and protocols, native transaction assertions unlock a spectrum of innovative use cases that can enhance the functionality and trustworthiness of the Ethereum ecosystem:

• Strengthening Delegation: When users delegate authority to an agent (e.g., a bot, a smart contract, or another wallet) to act on their behalf, assertions can provide granular control over outcomes. While existing delegation mechanisms might limit which contracts an agent can interact with, how much it can spend, or the duration of its permissions, assertions can add powerful, post-execution rules. For example, a user could delegate trading authority but assert that their total ETH balance must not drop below a certain threshold, or that a specific token approval must not exceed a predefined amount.
• Protocol-Defined Safety Checks: Protocols could define and enforce their own universal safety checks for every caller utilizing a frame transaction. This ensures a consistent level of security and adherence to protocol rules, regardless of the user interface or specific client initiating the transaction.
• Enhanced Solver Execution: In complex DeFi scenarios involving solver-based execution (e.g., intent-based architectures like CoW Swap), assertions could empower protocols to specify the required outcome of a transaction while granting solvers the flexibility to choose the most optimal execution route. This guarantees the user’s desired result without dictating the precise path, fostering innovation while maintaining security. It’s important to note, however, that this guarantee would typically apply only within a single transaction on a single network, not covering routes spanning multiple chains.
• Workflow Verification: Assertions could be used to verify that multi-step workflows reach their intended final state. This might include checks to ensure that unused tokens are returned to the user, that temporary token approvals are revoked after use, or that specific state variables are updated correctly across a series of operations.

The Path Forward: Community Collaboration

The development and refinement of native transaction assertions are an ongoing and collaborative effort within the Ethereum Foundation’s Trillion Dollar Security initiative. This is not merely a technical upgrade but a community-driven evolution of how security is perceived and implemented on Ethereum. The Foundation is actively seeking input from the diverse ecosystem, particularly from wallet developers and protocol teams who would be the primary implementers and beneficiaries of these new capabilities.

Engaging with the community is paramount to ensuring that the proposed solutions are practical, effective, and widely adopted. Interested parties are encouraged to reach out directly to the Ethereum Foundation at [email protected] to explore specific use cases, provide feedback, and help shape the research and design process. Furthermore, technical discussions surrounding EIP-7906 are openly conducted on the Ethereum Magicians forum, specifically in the EIP-7906 discussion thread, inviting broad participation from developers and researchers.

This initiative represents a significant commitment to enhancing user trust and securing the vast economic activity flourishing on Ethereum. By empowering users with verifiable control over transaction outcomes, native transaction assertions are poised to become a cornerstone of Ethereum’s future security architecture, safeguarding its continued growth and impact on the global digital economy. Further information on risk controls and priority work can be found at trilliondollarsecurity.org.