The Bundler is the new RPC endpoint. ERC-4337's core innovation is the UserOperation mempool, but its practical gateway is the bundler. This node software aggregates and submits these operations, making its API the critical interface for wallet developers and service providers.
The Coming Standardization War for Bundler API Specifications
The promise of ERC-4337 is being undermined by competing bundler API standards. This fragmentation will force wallet developers into costly multi-integration support, stalling user adoption. We analyze the contenders and the path to resolution.
Introduction
The ERC-4337 standard for account abstraction has ignited a silent war to define the API that will connect wallets to the network.
Standardization creates network effects. A single, dominant API specification will determine which bundler implementations (like Stackup, Alchemy, or Pimlico) achieve ubiquity. This is a replay of the RPC provider wars, where Infura and Alchemy won by offering the most reliable gateway to Ethereum.
The winning API dictates wallet design. The bundler API's capabilities directly influence what smart accounts can do. Features like gas sponsorship, transaction simulation, and fee logic will be dictated by the de facto standard, locking in architectural decisions for years.
Evidence: The rapid proliferation of proprietary bundler services from major infrastructure firms, each with slight API variations, proves the land grab is already underway. The winner will control the plumbing for the next billion user interactions.
The Core Conflict: Infrastructure vs. Application Sovereignty
The fight to define the standard interface for bundlers will determine who controls the user experience and economic flow of the entire ERC-4337 ecosystem.
Bundler API standardization is the new RPC endpoint war. The interface between applications and bundlers dictates transaction flow, fee logic, and censorship resistance. Whoever controls this specification controls the user operation pipeline for millions of accounts.
Infrastructure giants like Alchemy and Blocknative push for commoditization. Their strategy is to offer a generic, unified API that makes all bundlers interchangeable. This benefits them by reducing application lock-in and solidifying their position as the default infrastructure layer, similar to their dominance in RPC services.
Application-focused teams like Safe and Rhinestone demand specialized APIs. They require custom bundler logic for batched social recovery, atomic multi-chain operations, and intent-based batching. A one-size-fits-all API from infrastructure providers constrains application-level innovation and sovereignty.
The conflict mirrors the MEV-Boost relay wars. Just as Ethereum validators chose between censorship-compliant and permissionless relays, applications will choose bundlers based on API capabilities. The winning standard will be the one that best balances developer flexibility with infrastructure reliability.
Evidence: The Pimlico and Biconomy divergence. Pimlico's bundler SDK exposes paymaster sponsorship rules and gas estimation hooks, while Biconomy's focuses on gasless transaction abstractions. This early fragmentation proves the API is not a neutral technical spec but a product differentiator.
The Fracturing Landscape: Three Emerging Camps
The bundler API is the critical interface for User Operations (UserOps) in ERC-4337. Its standardization will dictate who controls the flow of intent and fees in the account abstraction stack.
The Ethereum Foundation's ERC-4337 Reference
The minimalist, canonical specification. It defines the core eth_sendUserOperation RPC and validation logic, prioritizing security and decentralization over features.\n- Foundation-First: The baseline for all compliance and interoperability.\n- Intent-Agnostic: Purely a transaction conduit, leaving advanced logic to higher layers.\n- Slow Evolution: Changes require full EIP process, creating a vacuum for faster-moving competitors.
The Aggregator-Led Camp (e.g., Stackup, Alchemy)
Proprietary extensions built by commercial bundlers to capture value and improve UX. This camp is driving fragmentation.\n- Feature Bloat: Adds APIs for gas sponsorship, transaction simulation, and conditional UserOps.\n- Vendor Lock-in: Optimizes for their own infrastructure, creating walled gardens.\n- Revenue Capture: Enables private orderflow and bespoke fee markets outside the public mempool.
The Intent-Centric Camp (Inspired by UniswapX, Across)
A future-looking push to merge the bundler API with intent-based architectures. The bundler becomes a solver network.\n- Declarative Transactions: Users submit desired outcomes (e.g., 'swap X for Y at best rate'), not explicit calldata.\n- Cross-Domain Native: Designed for native intents that span Ethereum, L2s, and alternative chains via bridges like LayerZero.\n- Solver Competition: Creates a marketplace for execution, abstracting complexity and maximizing extractable value for users.
Bundler API Contender Matrix
Comparison of emerging specifications for the UserOperation bundling interface, the critical relay layer for ERC-4337 account abstraction.
| Core Feature / Metric | Pimlico's `pm` (RPC Spec) | Stackup's `bundler` (Geth API Spec) | Ethereum Foundation's `Rundler` (Reference Spec) |
|---|---|---|---|
Specification Type | Extended JSON-RPC Method | Geth API Extension | Canonical Reference Implementation |
Primary Endpoint | eth_sendUserOperation | eth_sendUserOperation | eth_sendUserOperation |
Simulation Endpoint | eth_estimateUserOperationGas | debug_bundler_callBundle | eth_estimateUserOperationGas |
Bundler Reputation API | eth_getUserOperationReceipt | debug_bundler_sendBundleNow | |
MEV-Share Integration | eth_sendRawTransactionConditional | ||
Paymaster Sponsorship Hooks | pm_sponsorUserOperation | eth_call (custom calldata) | Standard paymaster flow only |
Avg. Latency to Inclusion | < 2 sec | < 5 sec | N/A (Reference) |
Fee Estimation Granularity | Dynamic (network + priority) | Base fee multiplier | Static gas estimates |
Why This War Inevitably Hurts Builders
The competition to define the standard Bundler API creates a costly, fragmented development landscape that diverts resources from innovation.
Multiple competing specifications force developers to build and maintain redundant integrations. The EIP-4337 reference client is not the de facto standard, as projects like Stackup, Alchemy, and Biconomy push proprietary extensions. This creates a compatibility matrix where a dApp must test against every major bundler's API variant.
Innovation shifts to integration plumbing, not user experience. Engineering cycles burn on abstracting API differences instead of building novel account abstraction features. This is the same middleware tax that plagued early multi-chain development with bridges like LayerZero and Wormhole, where protocol logic was buried under chain-specific adapters.
The winning standard emerges from adoption, not design. The Visa vs. Mastercard or USB-C vs. Lightning battles show that market power, not technical superiority, often decides. Builders betting on the wrong API fork face costly rewrites or irrelevance, a risk that stifles early experimentation in the ERC-4337 ecosystem.
The Bear Case: What Fragmentation Unlocks
The proliferation of competing bundler API specs will create a new, winner-take-most battleground for infrastructure dominance.
The Problem: Client-Side Integration Hell
Wallet and dApp developers face a combinatorial explosion of integrations. Supporting every custom bundler API (e.g., Ethereum's ERC-4337, Solana's Jito, Starknet's native account abstraction) is untenable, forcing them to pick winners and fragmenting user access.\n- Integration cost scales with each new chain or bundler variant.\n- User experience degrades as support becomes inconsistent across wallets like MetaMask, Rabby, and Phantom.
The Solution: The Rise of Aggregation Layers
Just as 1inch aggregated DEX liquidity, a new class of Bundler Aggregators will emerge. They will abstract away the underlying API chaos by providing a single, unified interface for user operation submission and sponsorship.\n- Paymasters and dApps route through the aggregator for best execution.\n- Creates a meta-market for bundler services, commoditizing individual implementations and extracting value to the aggregation layer.
The Stakes: Control of the User Operation Flow
Whoever defines the dominant bundler API standard controls the gateway for millions of daily gasless transactions. This is a proxy war for the future of on-chain distribution. The winner sets the rules for MEV capture, fee markets, and censorship resistance.\n- Ethereum Foundation's RPC standard vs. Visa-backed rip-7212 vs. VC-backed proprietary APIs.\n- The bundler becomes the new RPC endpoint – a critical, revenue-generating choke point.
The Endgame: Vertical Integration & Bundler-as-a-Service
Major players like Coinbase, Consensys, and Alchemy will vertically integrate the stack. They will offer Bundler-as-a-Service (BaaS) bundled with their RPC, node, and wallet products, locking in developers.\n- Network effects from existing user bases are a massive moat.\n- Independent bundler networks will struggle unless they offer radical performance advantages (sub-second latency) or unique features (intent-based routing).
The Path to Resolution: Market Forces vs. Governance
The winner of the bundler API standardization war will be decided by a clash between developer adoption and formal governance.
Market forces drive initial adoption. The first specification to achieve critical mass with major wallets (e.g., Rainbow, Safe) and dApp aggregators (e.g., UniswapX, 1inch) creates a de facto standard. This network effect, similar to EIP-4337's initial rollout, locks in tooling and developer mindshare, making competing specs obsolete.
Governance bodies formalize the victor. Once a dominant API emerges, standards bodies like the Ethereum Foundation's ERC group or Risk Labs will codify it. This process, as seen with ERC-4337, sanitizes the spec for security and longevity but risks ossifying suboptimal designs favored by early adopters.
The winning API is the most composable. The specification that best enables cross-domain intent settlement and seamless integration with oracles like Chainlink and bridges like Across will win. Technical elegance matters less than the breadth of its integration surface area.
Evidence: EIP-4337 succeeded not by being perfect, but by being the first to achieve a critical mass of wallet implementations, forcing the entire ecosystem to coalesce around its entry point and paymaster interfaces.
TL;DR for Protocol Architects
The ERC-4337 bundler API is the new battleground for control over the user operation supply chain, with competing specs from major infrastructure players.
The Problem: Fragmented UserOp Supply Chains
Every bundler implementation (e.g., Stackup, Alchemy, Pimlico) built its own proprietary API, creating vendor lock-in and stifling competition. This forces wallet developers to write custom integrations for each, increasing complexity and centralizing power.
- Result: Walled gardens form around major providers.
- Risk: Single points of failure for entire account abstraction ecosystems.
The Solution: ERC-4337's `eth_sendUserOperation`
The canonical, minimal API defined in the core standard. It's the baseline for interoperability, forcing all bundlers to expose a common endpoint. This is the foundation for a permissionless, competitive bundler market.
- Enables: Wallets to broadcast to any compliant bundler.
- Limitation: Lacks advanced features like MEV protection or simulation, pushing complexity to clients.
The Contender: RIP-7212's `eth_bundler` Suite
A Stackup-led proposal extending the core spec with high-performance features. It bundles multiple RPC methods (eth_sendBundle, eth_cancelBundle) into a single spec, optimizing for professional searchers and builders.
- Goal: Standardize the advanced tooling needed for MEV capture and reliability.
- Risk: Could cement Stackup's architectural choices as the de facto standard for high-stakes use.
The Wildcard: SUAVE's Endgame Vision
A long-term existential threat to today's bundler models. If SUAVE succeeds as a decentralized block builder and encrypted mempool, the bundler's role shrinks to a simple relay. The API war becomes irrelevant.
- Implication: Bundling logic moves to the SUAVE chain.
- Timeline: 2-3 year horizon, but reshapes all incentive design today.
The Architect's Mandate: Build for the Funnel
Your protocol's user operations must survive a multi-layered competitive funnel. Design for the lowest common denominator API (eth_sendUserOperation) but plan for advanced routing via bundler intermediaries like Candide or Etherspot.
- Strategy: Abstract bundler interaction behind an aggregator SDK.
- Metrics: Track inclusion rate and latency percentiles across multiple providers.
The Stakes: Who Controls the Mempool?
This isn't just about API design; it's about controlling the flow of intent. The winning spec dictates the economic model (e.g., priority fees, MEV-sharing), the security model, and which entities (Flashbots, Blocknative, Bloxroute) capture value.
- Outcome: Determines if account abstraction is decentralized or a replay of infrastructure middlemen.
- Analogy: This is the JSON-RPC standardization war for the intent era.
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.