Why Intent-Centric Design is Killing Transaction Sheets

Transaction sheets force users to specify low-level execution details (gas, slippage, routes), a job for solvers, not humans. This creates a massive UX barrier and limits composability.

• Key Benefit 1: Declarative interfaces like UniswapX and CowSwap let users state what they want, not how to get it.
• Key Benefit 2: Eliminates failed transactions and MEV leakage from poor parameter estimation, improving user outcomes by 5-20%.

A competitive network of specialized solvers (e.g., Across, Anoma) optimizes for execution quality, not just inclusion. This commoditizes block space and turns latency into a solved problem.

• Key Benefit 1: Solvers compete on cost and speed, driving down prices for end-users. Latency drops from minutes to ~500ms.
• Key Benefit 2: Enables cross-domain atomicity that users cannot manually construct, unlocking new DeFi primitives.

In a fragmented multi-chain and multi-VM world (Ethereum L2s, Solana, Cosmos), intents provide a unified abstraction layer. Protocols like LayerZero and Chainlink CCIP are becoming intent fulfillment layers.

• Key Benefit 1: Developers build against a single intent standard, agnostic to the underlying execution environment.
• Key Benefit 2: Shifts the burden of interoperability from the application layer to the infrastructure layer, reducing integration complexity by 10x.

Intent-based systems like UniswapX and CowSwap outsource execution to competitive solvers. This creates a new centralization vector where a dominant solver can censor, front-run, or extract maximal value (MEV) from user intents.

• Risk: A single solver controlling >50% of flow becomes a de facto sequencer.
• Example: Solver cartels can collude to offer non-competitive prices, negating the core benefit of the auction model.
• Mitigation: Requires robust, permissionless solver networks with verifiable execution proofs.

Intents that span multiple chains (via LayerZero, Axelar, Across) introduce a verification nightmare. The fulfilling party must prove the entire intent path was satisfied, not just a single transaction on one chain.

• Attack: A malicious solver can partially fulfill an intent, stealing funds on a secondary chain where verification is weak.
• Complexity: Security reduces to the weakest link in the cross-chain messaging protocol's security assumptions.
• Requirement: Needs atomic, cross-chain settlement guarantees, which today are approximated, not proven.

To fulfill complex intents, solvers require access to sensitive user data—balance, portfolio, preferred routes. This creates a massive, centralized data lake of actionable financial intelligence ripe for exploitation.

• Leak: Solvers and aggregators see the complete demand landscape, enabling sophisticated MEV extraction.
• Consequence: The "wallet of the future" becomes a data oracle for the very entities it's competing against.
• Emerging Fix: Fully homomorphic encryption (FHE) or TEE-based private computation, but at a significant latency/cost penalty.

The architectural answer is to treat intents not as private orders but as public, verifiable claims about desired state changes. Execution becomes a proof-of-fulfillment game, similar to optimistic or zk-rollup models.

• Mechanism: Solvers post bonds and cryptographic proofs that a bundle of intents was fulfilled optimally.
• Audit: A decentralized network of verifiers can challenge suboptimal execution, slashing the bond.
• Example: This moves the system from "trust this solver" to "trust the economic and cryptographic game."

Breaking the monolithic solver into specialized, replaceable components limits blast radius. A routing engine, liquidity aggregator, and cross-chain messenger can be sourced from different, competing providers.

• Benefit: No single entity controls the full stack. Failure or malice in one module can be isolated.
• Composability: Enables innovation at each layer (e.g., better FHE for privacy, faster prover for ZK).
• Trend: Seen in the separation of UniswapX (intent standard) from its solver network.

Intent-centric systems must prioritize economic finality—the cryptographic guarantee that a fulfilled intent is settled—over pure speed. This aligns with Ethereum's bedrock security model.

• Method: Use settled layer-1 blocks as the root of trust for cross-chain intent fulfillment, not fast-but-weak middleware.
• Trade-off: Users accept slightly slower settlement (~2-5 min) for strong, portable guarantees.
• Result: The attack surface shrinks to the underlying L1 security, which is battle-tested and decentralized.

Users no longer pay for failed MEV or inefficient routing. Solvers compete to fulfill intents, absorbing gas and slippage risk. This creates a zero-slippage guarantee for users and turns execution into a commodity.

• User pays for outcome, not execution steps.
• Solvers internalize MEV, returning value via better prices.
• Protocols like UniswapX and CowSwap already demonstrate ~20% better prices.

An intent to "swap X for Y" can be fulfilled via a direct AMM, a cross-chain bridge like Across or LayerZero, and a private OTC pool in a single atomic bundle. This breaks down liquidity silos.

• Solvers stitch together protocols for optimal fulfillment.
• Enables cross-domain intents (e.g., swap on Arbitrum, deposit on Base) in one signature.
• Unlocks $10B+ in fragmented liquidity across L2s and app-chains.

Execution becomes a decentralized marketplace. High-frequency solvers (e.g., professional market makers) compete on speed and capital efficiency, while users get the best result. This is a new infrastructure layer with its own staking, slashing, and governance.

• New revenue stream for searchers and block builders.
• **Requires robust cryptoeconomic security and fraud proofs (see SUAVE).
• Creates a ~$500M+ annual fee market for execution services.

The winning stack won't be the fastest chain, but the one that makes chains invisible. Intents are the final piece, abstracting gas, slippage, and chain selection. Wallets and dApps that master this will capture the next billion users.

• Gas sponsorship and fee abstraction become trivial.
• **Enables intent-based account abstraction (e.g., "pay fees in any token").
• The UX gap between Web2 and Web3 finally closes.