RPCs are the new bottleneck. The L2 scaling thesis succeeded by moving execution off-chain, but this created a new problem: every application now depends on a centralized RPC provider like Alchemy or Infura for its core data feed.
layer-2-wars-arbitrum-optimism-base-and-beyond
Blog
The Future of L2 RPC Infrastructure: Who Serves the Data?
The L2 boom is exposing the fragility of generic RPC endpoints. This analysis maps the coming specialization in RPC infrastructure, where providers will compete on state access speed, simulation accuracy, and data composability for networks like Arbitrum, Optimism, and Base.
introduction
THE DATA
Introduction: The RPC is the New Bottleneck
The shift to modular L2s has transformed the RPC from a simple query endpoint into the critical, overloaded gateway for all application data.
The data demand is asymmetric. While L2s batch transactions to L1 for security, applications require real-time, granular data about mempool state, transaction receipts, and event logs that the L1 cannot provide.
This creates a single point of failure. A degraded RPC endpoint cripples every dApp on that chain, as seen during outages for networks like Arbitrum and Polygon, where user activity halts.
Evidence: The average L2 RPC handles over 100 billion requests per month, a load that traditional JSON-RPC architecture was not designed to sustain, leading to latency spikes and reliability issues.
key-trends
THE DATA DELIVERY FRONTIER
Three Trends Breaking the Generic RPC Model
The monolithic RPC endpoint is dying. As L2s fragment liquidity and intent-based architectures demand richer data, a new infrastructure layer is emerging to serve the next generation of dApps.
01
The Problem: The Multi-RPC Headache
DApps now need to query dozens of L2s and rollups. Managing endpoints for Arbitrum, Optimism, Base, and zkSync is an operational nightmare. Generic RPCs fail at providing consistent, high-performance access across this fragmented landscape.\n- Operational Overhead: Manually managing 20+ RPC endpoints.\n- Inconsistent SLAs: Variable latency and reliability per chain.\n- Data Silos: No unified view of cross-chain state.
20+
Endpoints
~500ms
Latency Delta
02
The Solution: Specialized Data Aggregators (e.g., Covalent, The Graph)
These protocols index and structure raw chain data into queryable APIs, moving computation off the critical path of the RPC. They serve enriched data—like historical token balances or NFT traits—that a vanilla RPC cannot.\n- Rich Data APIs: Historical states, decoded logs, token metadata.\n- Compute Offload: Complex queries handled by the indexer, not the node.\n- Unified Schema: Single interface across Ethereum, Polygon, Avalanche.
100B+
Events Indexed
1s
Query Time
03
The Problem: Intents Demand Predictive Data
Architectures like UniswapX and CowSwap don't just execute a trade; they solve for optimal outcome. This requires real-time access to liquidity, gas prices, and MEV conditions across multiple chains—data a standard RPC doesn't provide.\n- Reactive vs. Predictive: Generic RPCs answer "what happened," not "what will be best."\n- Cross-Chain State: Intent solvers need a live view of Across, LayerZero, and Chainlink CCIP liquidity.\n- Latency is Cost: Slower data means worse prices for users.
$10B+
TVL in Intents
~200ms
Price Impact
04
The Solution: MEV-Aware RPCs (e.g., Flashbots Protect, bloXroute)
These services bundle data delivery with transaction routing, providing real-time insights into mempool dynamics and builder markets. They protect users from frontrunning and ensure optimal execution, which is now a core data service.\n- Mempool Privacy: Submit transactions without exposing intent.\n- Builder Market Data: Real-time access to MEV-Boost and PBS auctions.\n- Guaranteed Execution: Data on inclusion likelihood and cost.
-90%
Sandwich Risk
99.9%
Inclusion Rate
05
The Problem: Verifying L2 State is Opaque
Users and dApps must trust the sequencer's RPC. Proving that the data received is correct and corresponds to the canonical L2 state requires verifying validity proofs or fraud proofs—a task far beyond a simple eth_getBalance.\n- Trusted Data Source: Reliance on a single sequencer's RPC.\n- Proof Verification: No built-in way to verify zk-proofs or fraud proofs via RPC.\n- Data Availability: Is the L2 state published and retrievable on L1?
7 Days
Challenge Window
1-of-N
Trust Assumption
06
The Solution: Light Client RPCs & Proof Aggregation
Emerging infrastructure uses light client protocols (like Helios) or proof aggregation services to cryptographically verify the state received from an RPC. This shifts the trust from the operator to the consensus layer.\n- Trust Minimization: Verify state against L1 headers or validity proofs.\n- Data Availability Sampling: Integrate with EigenDA and Celestia for DA checks.\n- Universal Verification: A single client for Optimistic and ZK Rollups.
~2s
Proof Verify
Trustless
Security Model
WHO SERVES THE DATA?
The L2 RPC Fragmentation Matrix
A comparison of infrastructure models for accessing L2 blockchain data, based on technical architecture, performance, and decentralization trade-offs.
| Feature / Metric | Centralized RPC Providers (Alchemy, Infura) | Decentralized RPC Networks (POKT, Ankr) | Self-Hosted Node |
|---|---|---|---|
Architecture Model | Centralized API Gateway | Decentralized Node Marketplace | Direct Peer-to-Peer |
Uptime SLA Guarantee |
|
| User-dependent |
Typical Latency (p95) | < 100 ms | 100-300 ms | < 50 ms (local) |
Primary Cost Model | Tiered Subscriptions / Metered Calls | Pay-per-request (POKT token) | Hardware & Bandwidth Capex |
Supports Historical Data (Archive Nodes) | |||
Supports Trace APIs (debug_traceCall) | |||
Censorship Resistance | |||
Max Requests/Second (Tier 1) |
| ~ 5,000 RPS per gateway | Limited by hardware |
deep-dive
THE DATA
The Specialization Thesis: Beyond `eth_call`
The monolithic RPC is fragmenting into specialized data services, creating new infrastructure markets.
General-purpose RPCs are obsolete. The eth_call abstraction fails for L2s, which require custom endpoints for precompiles, gas estimation, and proving systems. This creates a market for specialized data providers like Alchemy's Supernode and QuickNode's L2 suites.
Indexing becomes a core service. Applications need subgraphs for L2 state, but The Graph's latency is prohibitive. Dedicated real-time indexers like Goldsky and SubQuery now offer sub-second data feeds for protocols like Aave and Uniswap.
Provers need their own APIs. Zero-knowledge rollups like zkSync and Starknet require separate services for proof generation and verification status. This ZK proving infrastructure is a distinct layer from standard RPC data delivery.
Evidence: Alchemy's Supernode handles 10x more debug_traceCall requests for Arbitrum than for Ethereum mainnet, proving the demand for L2-specific debugging data.
counter-argument
THE INCENTIVE MISMATCH
Counterpoint: Will L2s Just Build Their Own?
The economic and technical logic for L2s to outsource RPC infrastructure is stronger than the case for building it themselves.
L2s are execution specialists. Their core competency is scaling transaction throughput and reducing gas costs. Building and maintaining a globally distributed, high-availability RPC network is a distinct operational burden that dilutes engineering focus from their primary product.
The cost-benefit analysis fails. The capital expenditure for global node deployment and the operational cost of 24/7 SRE teams is immense. For a project like Arbitrum or Optimism, this is a negative-ROI distraction compared to paying a usage-based fee to Alchemy or Infura.
Commoditization is inevitable. RPC endpoints are becoming a standardized utility. Just as AWS won by offering compute-as-a-service, providers like QuickNode and Chainstack win by offering blockchain data-as-a-service. L2s will not compete in a commoditized market.
Evidence: No major L1 or L2 operates its own public RPC service at scale. Ethereum relies on Infura; Polygon partners with Alchemy; Solana uses QuickNode. This precedent establishes the outsourcing model as the industry standard.
protocol-spotlight
THE DATA LAYER WAR
Contenders in the New RPC Stack
The RPC is no longer just a dumb pipe; it's a competitive data layer where performance, reliability, and value-add services define the winners.
01
Alchemy's Supernode: The Enterprise Juggernaut
The Problem: Building at scale requires deep data indexing and reliability that generic nodes can't provide.\nThe Solution: A proprietary, globally distributed node infrastructure with enhanced APIs for transaction simulation, gas optimization, and real-time alerts.\n- Key Benefit: 99.9%+ SLA and proprietary Transact API for complex bundle building.\n- Key Benefit: Deep historical data access and Webhook systems for ~500ms alerting.
99.9%
Uptime SLA
10k+
Supported Chains
02
QuickNode's Performance Edge
The Problem: Latency kills dApp UX, especially for high-frequency trading and gaming on chains like Solana and Sui.\nThe Solution: Hyper-optimized, dedicated node hardware with global low-latency routing and a focus on emerging L1/L2 ecosystems.\n- Key Benefit: Sub-100ms global latency guarantees via proprietary network routing.\n- Key Benefit: One-click deployment for dedicated, customizable RPC endpoints across 30+ chains.
<100ms
Global Latency
30+
Chain Ecosystems
03
BlastAPI: The Cost-Efficient Aggregator
The Problem: Paying premium prices for RPC access to dozens of chains is unsustainable for scaling projects.\nThe Solution: A multi-chain RPC and data aggregator that provides a single endpoint, load balancing, and failover across providers like Chainstack, GetBlock, and own nodes.\n- Key Benefit: Up to 50% cost reduction via intelligent provider routing and aggregation.\n- Key Benefit: Unified API for 50+ networks, simplifying developer integration and reducing vendor lock-in.
-50%
Cost vs. Premium
50+
Networks Unified
04
Chainstack 3.0: The Decentralized Hybrid
The Problem: Pure decentralization is slow; pure centralization is a single point of failure.\nThe Solution: A hybrid architecture combining managed node services with decentralized protocols like The Graph for indexing and Pocket Network for relay redundancy.\n- Key Benefit: Censorship-resistant reads via decentralized fallbacks, maintaining >99.5% reliability.\n- Key Benefit: Sub-second indexing and GraphQL APIs for complex queries without running a full indexer.
>99.5%
Hybrid Uptime
Sub-second
Query Speed
05
The L2 Native: Blockdaemon's Appchain Focus
The Problem: Appchains and sovereign rollups (e.g., using Caldera, AltLayer) need specialized, white-glove RPC and validator services from day one.\nThe Solution: Deep infrastructure partnerships with L2 stack providers, offering tailored node orchestration, cross-chain messaging relays, and dedicated sequencer setups.\n- Key Benefit: Turnkey RPC+Sequencer bundles for launch, reducing time-to-market from months to weeks.\n- Key Benefit: Institutional-grade security and monitoring for chains managing $1B+ TVL.
Weeks
Launch Time
$1B+
TVL Managed
06
Pimlico's Bundler-as-RPC
The Problem: ERC-4337 Account Abstraction requires new infrastructure (Bundlers, Paymasters) that traditional RPCs don't provide.\nThe Solution: An RPC endpoint that natively understands UserOperations, bundling them efficiently and sponsoring gas via integrated paymaster services.\n- Key Benefit: Native AA support eliminates the need for developers to manage separate bundler infrastructure.\n- Key Benefit: Sponsored transaction economics baked into the API, abstracting gas for end-users.
ERC-4337
Native
0-gas
User Experience
risk-analysis
THE L2 DATA PIPELINE
The Centralization & Fragmentation Trap
The explosive growth of L2s has created a critical bottleneck: who reliably serves the foundational data for applications?
01
The Alchemy/Infura Monopoly Problem
Relying on a single centralized RPC provider for L2s reintroduces the single points of failure we built blockchains to avoid. This creates systemic risk for $10B+ in TVL and exposes apps to censorship.
- Single Point of Failure: An outage at the provider can black out entire ecosystems.
- Censorship Vector: Centralized endpoints can filter or block transactions.
- Data Sovereignty: Developers cede control over their application's most critical dependency.
>60%
Market Share
1
Failure Point
02
The Multi-RPC Fragmentation Tax
Every new L2 forces developers to integrate and manage a new, often unreliable, RPC endpoint. This operational overhead stifles innovation and degrades UX.
- Exponential Complexity: Supporting 10+ L2s means managing 10+ unique RPC configurations and SLAs.
- Inconsistent Performance: Latency and reliability vary wildly between chains (~100ms to 2s+).
- Siloed Data: Aggregating cross-chain state requires stitching together disparate APIs.
10x
Ops Complexity
2s+
Worst Latency
03
The Solution: Decentralized RPC Networks (e.g., Pocket Network, Lava Network)
A decentralized network of independent node operators serves RPC requests, eliminating single points of failure and creating a competitive market for data service.
- Censorship Resistance: Requests are distributed across a global network of nodes.
- Redundancy & Uptime: No single operator can take down the service.
- Economic Alignment: Node operators are incentivized via protocol tokens for reliable service.
10k+
Node Operators
99.99%
Target Uptime
04
The Solution: Unified Aggregation Layer (e.g., Chainscore, Gateway.fm)
An intelligent aggregator sits between applications and the fragmented RPC landscape, providing a single endpoint, automatic failover, and performance optimization across all major L2s.
- Single API Endpoint: Developers integrate once to access all supported chains.
- Performance Optimization: Routes requests to the fastest/most reliable provider for each chain.
- Real-Time Analytics: Provides unified metrics on latency, errors, and costs across the stack.
1
Integration
-50%
Mean Latency
05
The Endgame: Intent-Based & AI-Optimized Routing
The future RPC layer won't just fetch data; it will fulfill developer intents (e.g., "get the fastest finality") using AI to dynamically route requests based on cost, speed, and data freshness.
- Intent-Centric: API abstracts away chain specifics, focusing on desired outcome.
- ML-Powered Routing: Predicts node performance and network congestion for optimal routing.
- Unified State View: Aggregates and indexes data across rollups to serve complex cross-chain queries.
AI
Routing
Intent
Primitive
06
The Stakes: Who Controls the Data Pipe Controls the Economy
The infrastructure layer that serves blockchain data will capture immense value and influence. The winners will be those who provide reliability at scale, not just raw access.
- Infra as a Moat: The most reliable data layer becomes the default for institutional adoption.
- Protocol Revenue: Decentralized networks can capture fees from every query served.
- Standard Setting: The dominant aggregator will de facto define the API standards for the multi-chain world.
$B+
Revenue Pool
Default
Becomes Standard
future-outlook
THE DATA
Outlook: The Intent-Aware RPC
The next evolution of RPCs will shift from passive data retrieval to proactive, intent-aware execution orchestration.
RPCs become execution orchestrators. Today's RPCs are dumb pipes; they fetch data. Tomorrow's RPCs will interpret user intent, simulate optimal execution paths across L2s and L3s, and route transactions accordingly. This mirrors the evolution from simple DEX aggregators to intent-based systems like UniswapX and CowSwap.
The battleground is simulation fidelity. The winning provider will offer the most accurate, high-throughput transaction simulation. This requires deep integration with rollup sequencers, MEV searchers, and bridging protocols like Across and LayerZero to guarantee cross-chain settlement. Providers like Alchemy and Infura will compete on simulation, not uptime.
Data becomes a commodity, execution is the product. Raw blockchain data access is a race to zero. The premium service is guaranteeing the outcome. An RPC will not just send your swap; it will ensure the best price across five L2s with a single signature, abstracting the underlying fragmented liquidity.
Evidence: The demand is already visible. Anoma's intent-centric architecture and UniswapX's fill-or-kill orders demonstrate the market shift. RPC providers that fail to build this execution layer intelligence will be relegated to low-margin infrastructure.
takeaways
THE FUTURE OF L2 RPC INFRASTRUCTURE
TL;DR for Infrastructure Builders
The monolithic RPC endpoint is dead. Here's how the stack fragments to serve specialized data demands.
01
The Problem: RPC as a Commodity Bottleneck
Public RPC endpoints are rate-limited, unreliable, and blind to application logic. Serving 10k+ TPS across 50+ L2s requires more than a simple JSON gateway. The generic 'eth_getBlockByNumber' call can't differentiate between a DeFi frontend and an NFT indexer, leading to wasted bandwidth and latency spikes.
50+
L2s to Serve
~500ms
Spike Latency
02
The Solution: Specialized Data Verticals
Infrastructure will split into purpose-built layers: Execution, Indexing, and State Verification. Think The Graph for complex queries, EigenLayer AVS for verified state proofs, and ultra-low-latency nodes for trading. The single endpoint is replaced by a router that directs requests to the optimal provider.
3x
Specialized Layers
-70%
Waste Bandwidth
03
The Architecture: Decentralized RPC Networks
Monolithic providers like Alchemy and Infura will be unbundled by decentralized networks like POKT Network and Lava Network. These use cryptoeconomic incentives to coordinate a global fleet of node operators, offering geographic redundancy, censorship resistance, and pay-per-request pricing. The network becomes the endpoint.
10k+
Global Nodes
Pay-per-Call
Pricing Model
04
The Edge: Intent-Based Routing & MEV
Future RPCs will understand user intent. A swap request via UniswapX or CowSwap is routed to a searcher network for MEV protection and optimal routing. The RPC layer becomes an active participant in transaction lifecycle, not a passive pipe. This requires deep integration with Flashbots SUAVE, Across, and layerzero.
Intent-Aware
Routing
MEV-Protected
Tx Flow
05
The Metric: Time-to-Finality, Not Latency
Optimistic and ZK rollups have redefined the data finality clock. The key metric shifts from simple JSON-RPC latency to guaranteed time-to-finality. Providers must offer pre-confirmations (like Arbitrum's BOLD) and ZK validity proofs, bundling L1 settlement assurance into the API response. This is a fundamental shift in SLA design.
TTF
Key SLA
ZK Proofs
In API
06
The Business Model: Data as a Derivative
Raw blockchain data is free. The value is in the derivative: enriched, verified, and structured data feeds. The winning infrastructure will sell real-time event streams, wallet portfolios, and risk scores, not API calls. Look at Goldsky and Covalent as precursors. The RPC is just the ingestion layer for a data refinery.
Data Feeds
Product
Enriched API
Value-Add
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall