Modular specialization fragments UX. Separating execution, settlement, and data availability layers like Celestia and EigenDA forces users to manage assets and sign transactions across incompatible environments.
Why the Modular Stack Demands a Native AA Standard
ERC-4337 solved AA for monolithic chains. The modular stack—with separate execution, settlement, and data layers—breaks its model. We argue for a new, protocol-native standard to unify user experience across the fragmented landscape.
Introduction
The modular stack's specialization has fragmented user experience, creating an urgent need for a native account abstraction standard.
Smart accounts are not enough. Solutions like Safe wallets or ERC-4337 are application-layer patches; they lack the native protocol integration required for seamless cross-domain operations.
The standard must be chain-native. A native AA standard, embedded in the protocol like zkSync's native account abstraction, eliminates the need for bridging gas tokens or managing separate signers per chain.
Evidence: Over 60% of Arbitrum users interact with at least one other L2, yet 90% report UX friction as a primary barrier to further exploration.
The Core Argument: AA Must Move to the Protocol Layer
The modular blockchain stack's fragmentation makes application-layer account abstraction unsustainable, demanding a native protocol standard.
Application-layer AA is a dead end for the modular future. Wallets like Safe and Biconomy must re-implement logic for every new rollup, L2, and appchain, creating unsustainable fragmentation and security debt.
The protocol layer owns user identity. Just as TCP/IP defines packet routing, a base-layer AA primitive must define the universal transaction object. This separates the intent from the execution environment*.
Rollups cannot standardize this alone. While Arbitrum and Optimism have native AA support, a rollup-specific standard just moves the fragmentation up one layer. The solution requires a shared settlement layer primitive, like what Ethereum's EIP-4337 attempted but for a modular world.
Evidence: The cross-chain intent ecosystem—UniswapX, Across, Socket—proves the demand for user-centric execution. These systems already abstract complexity away from users; a protocol-layer AA standard is the logical endpoint for this trend, turning every chain into a feature, not a barrier.
The Modular Reality: Three Trends Breaking ERC-4337
ERC-4337's monolithic bundler design is fundamentally misaligned with the modular execution, settlement, and data availability layers now dominating blockchain architecture.
The Problem: Monolithic Bundlers in a Modular World
ERC-4337's bundler is a single-threaded, in-memory actor that must handle validation, simulation, and transaction ordering. This creates a bottleneck incompatible with parallel execution environments like Solana Virtual Machine (SVM) or Fuel's UTXO model.\n- Architectural Mismatch: Cannot leverage specialized sequencers from EigenLayer, Espresso, or Astria.\n- Performance Ceiling: Limits throughput to ~100-200 TPS, while modular stacks target 10,000+ TPS.
The Solution: Native AA as a Protocol Primitive
Embedding account abstraction into the chain's protocol layer, like Solana and Monad are doing, eliminates the bundler middleman. User operations become native transactions.\n- Direct Integration: Smart accounts interact directly with the execution client and mempool, bypassing ERC-4337's relayer network.\n- Full Composability: Enables seamless integration with intent-based systems (UniswapX, CowSwap) and cross-chain messaging (LayerZero, Axelar) at the VM level.
The Trend: Specialized Execution Layers Demand Specialized AA
Modular chains like Ethereum L2s (Optimism, Arbitrum), Celestia rollups, and Fuel optimize for specific use cases (DeFi, gaming, social). A one-size-fits-all AA standard cannot optimize for all.\n- Custom Opcodes: Chains need AA primitives tailored to their VM, like zkSync's native account abstraction or Starknet's account contracts.\n- Sovereign Security: Reliance on Ethereum for ERC-4337's security (via the EntryPoint) contradicts the sovereignty of rollups-as-a-service platforms (AltLayer, Caldera).
The Fragmentation Problem: A Comparative View
Comparing the user and developer experience of different account abstraction implementations across a fragmented modular stack.
| Feature / Metric | Smart Contract Wallets (SCWs) via EIP-4337 | Application-Specific AA (e.g., dApp Wallets) | Native AA Standard (e.g., EIP-7702, EIP-3074) |
|---|---|---|---|
Account Control Plane | Off-chain Bundler network | dApp-controlled relayers | Native protocol (Validator/Sequencer) |
Gas Sponsorship Model | Paymaster dependency (centralized risk) | dApp subsidization (captive users) | Direct fee delegation via opcode |
Cross-Rollup Session Keys | Custom SCW logic per L2; no native sync | Per-dApp implementation; siloed | Native signature type; portable across L2s |
State Sync Overhead | Heavy: Full SCW deployment on each new chain | Moderate: Relay infrastructure per chain | Minimal: EOAs are upgraded in-place |
Transaction Latency |
| < 5 sec (Prioritized relayer) | < 1 sec (Native mempool inclusion) |
Protocol-Level Security | Bundler censorship risk, Paymaster trust | Relayer centralization, dApp admin keys | Inherits L1/L2 validator security |
Developer Integration | Complex: UserOp SDK, bundler RPC endpoints | Simple but captive: dApp-specific SDK | Simple: Use existing RPC ( |
Architecting a Native AA Standard
A native Account Abstraction standard is the only viable interoperability layer for a modular blockchain ecosystem.
Modular fragmentation breaks UX. Rollups, L2s, and appchains each implement custom AA, forcing users to manage incompatible smart accounts per chain.
A native standard is middleware. It creates a portable user identity that works across any execution environment, from Arbitrum to Celestia-based rollups.
ERC-4337 is insufficient. It's an EVM-specific contract standard, not a protocol-layer primitive for cross-domain state and message passing.
Evidence: Without a native standard, projects like Polygon AggLayer and Optimism's Superchain must build bespoke AA bridges, increasing complexity and risk.
Counterpoint: Isn't This Just a Bridge Problem?
Bridges solve asset transfer, but a modular stack requires a standard for user intent across execution environments.
Bridges are asset-centric. Protocols like Across and LayerZero optimize for moving tokens, not for composing actions like a cross-chain swap into a lending position. This leaves the user intent fragmented.
Modularity fragments state. With separate execution layers like Arbitrum and Base, a user's session (e.g., wallet session keys, subscriptions) is trapped. A bridge cannot port this stateful context.
Native AA standardizes intent. An account abstraction standard like ERC-4337 or EIP-7702 defines a portable user operation. This creates a universal transaction layer that bridges and rollups can natively understand.
Evidence: Without this, cross-chain UX relies on middleware like Socket or Squid to simulate intent, adding latency and trust assumptions a native standard eliminates.
Who's Building the Primitives?
Modular fragmentation creates a UX nightmare; native account abstraction is the only viable escape hatch.
ERC-4337: The Baseline, Not the Destination
The Ethereum standard provides a common language but is a higher-layer overlay on the EVM. In a modular world, this creates critical inefficiencies:\n- ~200k gas overhead per user operation on L1\n- No native multi-chain state; requires complex bundler infra per chain\n- Relayer dependency introduces centralization and fee market risks
The Modular Mandate: AA in the Execution Layer
True native AA requires protocol-level integration, moving logic from smart contracts into the client. This is the only path for seamless cross-rollup UX.\n- Zero-overhead validation: Signature and nonce logic handled natively\n- Atomic multi-chain ops: Single signature executes across Optimism, Arbitrum, zkSync\n- Sovereign fee payment: Gas abstraction without third-party relayers
The StarkWare / zkSync Model: Proving Native Superiority
These L2 pioneers bake AA directly into their state transition functions, proving the performance case.\n- StarkNet's Account Contracts are native system calls, not deployed contracts\n- zkSync's LLVM-based AA enables social recovery and batch transactions at the VM level\n- ~10x cheaper user ops versus ERC-4337 simulation on equivalent L2
The Interop Challenge: Enter LayerZero & CCIP
Native AA is useless if you're locked to one chain. Cross-chain messaging layers become the critical plumbing for a unified account state.\n- LayerZero's DVN network can attest to AA session keys across chains\n- Chainlink CCIP enables secure off-chain computation for intent resolution\n- Enables Across Protocol-style intents where the user's 'account' is the cross-chain state itself
The Bundler Evolution: From Service to Protocol
Projects like Stackup and Alchemy currently operate as centralized bundler services. The endgame is a decentralized bundler network (like The Graph for queries).\n- PBS (Proposer-Builder Separation) for UserOps: Decouples ordering from execution\n- MEV capture redirection: Value flows to users via sponsored transactions or fee rebates\n- Intent-based routing: Automatically finds optimal path across UniswapX, CowSwap, 1inch Fusion
The Wallet Dilemma: Smart vs. Embedded
The final primitive is the client. Smart wallets (Safe, Argent) are heavy. The future is embedded wallets where the dApp is the interface.\n- Privy, Dynamic, RainbowKit abstract key management entirely\n- MPC-based signers offer cloud-like recovery, shifting trust from seed phrases to social logins\n- Paymaster integration becomes invisible: Gas fees are just a line item in the business logic
The Bear Case: Why This Might Not Happen
The modular thesis is compelling, but a universal AA standard faces significant, entrenched opposition.
The Wallet Cartel's Moats
Established wallet providers (e.g., MetaMask, Trust Wallet) have zero incentive to cede control. Their business models are built on custody, key management, and transaction fee revenue.\n- Network Effects: Billions in assets and millions of users are locked into existing UX flows.\n- Economic Capture: Fee abstraction directly threatens a $1B+ annual revenue stream from gas sponsorship and swap fees.
The L1 Sovereignty Problem
Major Layer 1s (e.g., Solana, Bitcoin L2s) view AA as a competitive threat to their native security and fee markets.\n- Vendor Lock-in Risk: A cross-chain AA standard could reduce chains to commoditized execution layers.\n- Security Fragmentation: Native account abstraction (like Solana's) is optimized for its VM, creating ~50% faster UX but incompatible with EVM-centric standards like ERC-4337.
The Interoperability Nightmare
Modularity's strength—sovereignty—is its weakness for standardization. Each rollup, L2, and appchain will prioritize custom AA for competitive advantage.\n- Fragmented Liquidity: User intents and session keys become siloed, breaking composability across chains like Arbitrum, Optimism, and zkSync.\n- Bundler Wars: A standard requires a unified mempool; competing bundler networks (e.g., Stackup, Alchemy) will fragment before they unify.
The Regulatory Ambiguity
Account abstraction blurs legal lines between wallets, smart contracts, and financial services. Regulators (SEC, MiCA) may classify programmable accounts as regulated entities.\n- KYC/AML on-chain: Social recovery and batch transactions could mandate identity checks, killing permissionless innovation.\n- Liability Shift: Who is liable for a malicious intent? The user, the dApp, the solver, or the standard?
The 24-Month Outlook
A native AA standard is the only viable path to user-centric interoperability across the modular stack.
Native AA standard is inevitable. The current fragmentation of account abstraction (AA) implementations across EIP-4337, StarkWare, and zkSync creates a user experience dead-end. Without a shared primitive, users face locked liquidity and fractured identities across rollups and appchains.
Intent-based interoperability demands it. The next wave of UX, powered by UniswapX and Across, routes user intents across chains. These systems require a universal account layer to atomically settle actions and manage gas across heterogeneous execution environments.
The alternative is fragmentation. Without a standard, each modular component—be it an OP Stack rollup or an Avail data availability layer—will bake in proprietary AA, creating permanent silos. This defeats the core promise of a modular ecosystem.
Evidence: EIP-4337 Bundler adoption is already creating de facto standards, with 4337-aligned wallets like Safe{Wallet} and Biconomy becoming the default for new rollups. The network effect for a single user session format is unstoppable.
TL;DR for Busy Builders
Modular blockchains fragment user experience. Native account abstraction is the required glue.
The Problem: Modular UX is a Frankenstein
Users juggle multiple wallets, gas tokens, and signatures across execution, settlement, and data layers. This kills adoption.
- User Drop-off: ~40%+ fail at bridging or funding gas.
- Security Risk: Private keys are exposed on every new chain.
- Friction: No cross-rollup session keys or batched ops.
The Solution: AA as a Native Primitive
Bake smart accounts into the protocol layer, not as an afterthought via smart contracts. This enables system-level optimizations.
- Protocol Gas Sponsorship: Rollups can subsidize fees natively.
- Atomic Compositions: Secure cross-rollup actions in one signature.
- Standardized Bundler Layer: Creates a $1B+ market for relayers, akin to searchers in MEV.
The Standard: ERC-4337 Isn't Enough
ERC-4337 is an EVM patch, not a modular foundation. It adds overhead and can't leverage chain-specific features.
- Inefficient: Adds ~~42k gas overhead per user operation.
- Fragmented: Each rollup implements its own singleton contracts.
- Missed Optimizations: No native integration with DA layers like Celestia or EigenDA for signature compression.
The Blueprint: Look at Fuel & Movement
Next-gen modular stacks like Fuel (UTXO-based) and Movement (Move-based) are designing AA in from day one.
- Parallelizable: Native AA enables ~10,000 TPS via strict nonce rules.
- State Minimization: Accounts are not stored in global state.
- Developer Clarity: A single account model for the entire ecosystem.
The Incentive: Capturing the Intent Economy
Native AA is the gateway for UniswapX-style intent architectures. The modular stack that solves UX will capture the flow.
- Solver Networks: Become the default settlement layer for Across, CowSwap.
- Fee Abstraction: Users pay in any token; rollup captures swap fees.
- Sticky Users: Social recovery & smart wallets increase retention >3x.
The Risk: Getting Outpaced by L1s
If modular chains don't standardize, monolithic L1s with native AA (e.g., TON, Sui) will offer a superior UX and win developers.
- Time-to-Market: Monolithic chains can ship AA features faster.
- Cohesive Stack: Single security and execution model simplifies everything.
- Existential Threat: Modular's value proposition is flexibility; failing on UX negates it.
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.