Base

Base is an EVM-equivalent L2 on the OP Stack, sequenced by Coinbase. This page covers the things you'll need to know to write software against it — the RPCs, the predeploys, the cost model, the test harness, the failure modes — and ignores the "should I pick Base" question.

What it is

• Chain ID 8453 mainnet, 84532 Sepolia testnet. Block time ~2s.
• OP Stack rollup — same execution surface as Optimism Mainnet, Mode, Zora, etc. EVM-equivalent; Solidity contracts deploy unchanged. Settles to Ethereum L1.
• Coinbase-sequenced — Coinbase runs the only sequencer today. Future plan is to decentralize via the OP Stack's fault-proof + multi-sequencer roadmap, but as of this writing it is a single-sequencer chain. Treat that as a real risk in any threat model: Coinbase can censor, pause, or reorder. They have not, but they can.
• Cheap — typical swap costs ~$0.01–$0.05. Cheap enough that consumer-app on-chain UX is real (which is the whole point of being on an L2).

At a glance

RPC providers

Default pick: Coinbase Developer Platform (CDP) — free mainnet RPC, same account as the rest of the CDP infra (wallets, paymaster, onramp). Lowest-friction pick if you're already on CDP for anything else.

Alternates worth knowing:

• Alchemy — strongest dev-tools side (Composer, gas manager, webhooks). Generous free tier.
• QuickNode — best multi-region latency, paid faster.
• Public RPC (https://mainnet.base.org) — exists, rate-limited, do not use for production.
• Self-hosted op-node + op-geth — the right answer for anything that needs archival or low-latency event subscriptions at scale. Non-trivial to operate.

Bridges

• Base Bridge (bridge.base.org) — the canonical OP Stack bridge. ETH and USDC across L1↔L2. 7-day withdrawal challenge period to L1, instant deposit to L2.
• Across, Stargate, LayerZero, Hop — fast bridges. Take a fee, give you minutes-to-seconds rather than 7 days, but introduce bridge-protocol risk. Default to the canonical bridge for any treasury movement; use fast bridges only for user-facing UX.
• Coinbase direct deposit/withdraw — for end users, the cheapest "bridge" is a Coinbase account, because Coinbase moves funds in/out of Base natively at no L1 gas cost. This is the under-discussed UX advantage of Base.

Explorers

• BaseScan (basescan.org) — Etherscan-branded, default.
• Blockscout (base.blockscout.com) — open-source alternative, better for tools that want HTML scraping or open APIs.
• Tenderly — debugger + simulator. Worth a paid seat the first time you hit a state-corruption bug.

Stablecoins on Base

• USDC (native) — Circle issues native USDC directly on Base. Use this. Address: 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913.
• USDbC (bridged) — legacy bridged USDC from the pre-native era. Being phased out. Do not pick this for new integrations; some old pools still trade against it.
• DAI, USDT — present, less liquid than USDC on Base. Don't make them the primary route.

Liquidity / DEX layer

Aerodrome is the liquidity layer of Base. See Aerodrome for the full breakdown. If you need USDC/ETH or USDC/AERO liquidity, you route through Aerodrome. Uniswap v3 is also deployed and has share, but the depth on the high-volume pairs lives on Aerodrome.

Other ecosystem pieces worth naming:

• Morpho — lending markets, Base is one of its largest deployments.
• Moonwell — Compound-style lending.
• Virtuals Protocol — AI agent token launchpad. Relevant to GL because it touches the agent-app thesis.
• Farcaster + Warpcast — social/distribution layer that runs natively on Base. Frames + Mini Apps are the "share-link → on-chain action" surface; if you ship something with viral mechanics on Base, Frames are the lever.

OP Stack predeploys you'll actually use

Base inherits the standard OP Stack predeploys at fixed addresses on every OP Stack chain. The ones you'll touch from app code:

Predeploy	Address	What it's for
L2ToL1MessagePasser	0x4200000000000000000000000000000000000016	Initiate withdrawals from L2 back to L1. Called by the standard bridge.
L2StandardBridge	0x4200000000000000000000000000000000000010	L1↔L2 token bridge. withdraw / withdrawTo for outflows.
L1Block	0x4200000000000000000000000000000000000015	Read the most recent L1 block info from L2 (number, timestamp, basefee, hash). Use this if your contract needs L1-time awareness.
GasPriceOracle	0x420000000000000000000000000000000000000F	Estimate L1-data-fee component of a tx. Critical for any tx-cost UI — the L2 gas price alone undercounts the true cost.
WETH9	0x4200000000000000000000000000000000000006	Canonical wrapped ETH on L2.
L2CrossDomainMessenger	0x4200000000000000000000000000000000000007	Lower-level cross-domain message passing. The bridge uses this under the hood; you generally don't call it directly.

Treat these as stable; they don't change across hard forks unless OP Stack ships a coordinated upgrade.

Multicall3 lives at the standard EVM address 0xcA11bde05977b3631167028862bE2a173976CA11 (same on every chain that has deployed it).

How to integrate

Calldata cost model — the thing that bites you

Base's per-tx cost is not just L2 gas. It is L2 execution gas plus the L1 data-fee to post your tx calldata to Ethereum L1. The L1 component dominates for any tx with non-trivial calldata (i.e., almost every contract call).

• L2 execution fee = L2 gas used × L2 base fee (cheap, sub-cent typically)
• L1 data fee = compressed_calldata_bytes × L1 base fee × scalar (the expensive part)

Implications:

• Calldata is the budget. Packed structs, bytes32 over string, and avoiding redundant arguments saves real money. A 32-byte savings is ~$0.001–$0.01 depending on L1 conditions.
• Multicall is your friend. One tx with 30 reads (via Multicall3) is far cheaper than 30 separate txs because the per-tx L1 overhead is fixed.
• GasPriceOracle.getL1Fee(data) lets you estimate the L1 component on-chain. Surface this in any "how much will this cost" UI; the wallet's gas estimate alone undercounts.

Event subscription

• Block time is ~2s. Polling at eth_blockNumber every second is fine; every 100ms is wasted requests.
• eth_subscribe on newHeads works on most providers (CDP, Alchemy, QuickNode). Public RPC does not support WebSocket subscriptions.

Forking Base mainnet for tests

# Anvil
anvil --fork-url $BASE_RPC_URL --fork-block-number $(cast block-number --rpc-url $BASE_RPC_URL)

# Hardhat
networks: {
  hardhat: {
    forking: { url: process.env.BASE_RPC_URL, blockNumber: 12345678 }
  }
}

State at the forked block is live mainnet state — you can anvil_impersonateAccount any address, mint tokens by reaching into storage with anvil_setStorageAt, or use cast rpc anvil_setBalance. Skip time with evm_increaseTime + evm_mine to test epoch-rollover logic locally.

Gotchas

• L1 gas spikes feed through. ETH L1 spiking to 100 gwei makes Base txs 10× more expensive for a few hours. Time-sensitive flows (claims, liquidations) should detect this and degrade gracefully.
• Reorgs are rare but real. Base is a single-sequencer chain today, so reorgs from sequencer-side issues are nearly zero. Reorgs from L1 reorgs can happen during the 10-minute soft-finality window before your tx is L1-finalized. If your product can't tolerate a reorg, wait 64+ L1 blocks (13 min) before treating an L2 tx as final.
• eth_getLogs page limits. Free RPC tiers cap to ~10k logs per range. For backfilling Aerodrome's Voted events across a year, you'll page or use a subgraph.
• Wallet gas estimate undercounts. Always add the L1 fee component (GasPriceOracle.getL1Fee(data)) to your "how much will this cost" UI — the wallet alone shows L2 gas only.
• Free-tier anvil rate-limiting. Free RPC tiers will rate-limit anvil's repeated eth_calls during state hydration. Point at a paid endpoint or run a local op-geth.
• Pin the fork block. Pinning to a specific block number is required for deterministic tests; without it, "latest" can change between CI runs.

Risks

• Single sequencer. Coinbase can pause Base. Decentralization roadmap exists, hasn't shipped. Anything custodial should plan for a forced L1 withdrawal path (the 7-day escape hatch).
• Coinbase regulatory surface. Base inherits Coinbase's regulatory exposure. Not "USDC depegs" risk so much as "Coinbase has to gate access to a region" risk.
• Sequencer downtime. Has happened (rare, brief). If your app is time-sensitive (e.g., a liquidator), have a degraded mode.
• L1 gas spike feed-through. Base's per-tx cost is dominated by the L1 calldata posting cost. ETH L1 gas spikes show up as 10× Base fees for a few hours. Budget for it.

Related

• Aerodrome — the liquidity layer of Base. ve(3,3) DEX, gauge/bribe market, where most volume + fees live.
• Coinbase Developer Platform — default RPC + wallet + paymaster + onramp stack for Base apps.