Logo
New RPC users get 35% off their first monthView the offer
OnFinality Learn
Network & Protocol Guides11 min read

Base Transaction Lifecycle: From Submission to L1 Finality

A practical guide to how Base transactions are submitted, sequenced, confirmed, and finalized, with runnable diagnostics for verifying each stage.

TL;DR

A Base transaction is an Ethereum-format transaction submitted to Base's sequencer, which orders it into a 200ms block and returns a receipt long before the batch is posted and finalized on Ethereum L1. The practical consequence is that a transaction can be confirmed, safe, and finalized at different times, and applications that treat the first receipt as irreversible expose themselves to reorg and sequencer-failure risk. This article explains the stages, shows how to query each one with standard JSON-RPC methods, and gives a diagnostic procedure for tracking a transaction from submission to L1 finality. It also covers the failure modes that produce stuck or dropped Base transactions and the tradeoffs between speed and certainty.

What a Base transaction actually is

Base is an OP Stack optimistic rollup. A Base transaction is a standard Ethereum transaction — same fields, same signing scheme, same eth_sendRawTransaction submission path — but it is executed by Base's sequencer rather than by Ethereum mainnet validators. The transaction pays gas in ETH on Base, and its calldata and state changes are eventually committed to Ethereum L1 through the rollup's batch submission and fault-proof system.

Because the transaction format is identical to Ethereum's, any EVM toolchain works: ethers, viem, web3.py, Foundry, Hardhat. What differs is the timing and certainty model. On Ethereum mainnet, inclusion in a block and economic finality are separated by roughly two epochs. On Base, inclusion happens in a 200ms sequencer block, but that block is a soft commitment until the corresponding batch is posted to L1 and the dispute window has elapsed. Treating those two events as the same is the most common source of integration bugs.

This guide assumes you can sign and broadcast an EVM transaction and that you have an RPC endpoint for Base. If you are still choosing an endpoint, the RPC Assistant's guidance on reliable multi-chain RPC endpoints covers the selection criteria; the mechanics below apply regardless of provider.

  • Transaction format: Ethereum legacy or EIP-1559, signed with an Ethereum key.
  • Gas token: ETH on Base, not a separate token.
  • Execution: Base sequencer, with state committed to L1 in batches.
  • Receipt availability: typically within one 200ms block after sequencing.

The four confirmation stages and what each one guarantees

A Base transaction passes through four distinguishable stages. Each has a different guarantee, and each maps to a different RPC signal.

Stage 1 — Submission. The signed transaction is broadcast to a Base RPC node and enters the sequencer's transaction pool. At this point the transaction has a hash but no block. eth_getTransactionByHash returns a pending object or null depending on whether the node has seen it. No guarantee of inclusion exists yet.

Stage 2 — Sequencer inclusion (preconfirmation). The sequencer orders the transaction into a canonical block, which Base builds every 200ms. eth_getTransactionReceipt returns a receipt with a block number, status, gas used, and logs. This is the stage most applications treat as "confirmed." It is a soft commitment: the sequencer has promised ordering, but the block is not yet anchored to L1.

Stage 3 — L1 batch posting (safe). The sequencer's blocks are compressed into a batch and posted to Ethereum L1. Once the batch transaction is included in an L1 block, the Base transaction's data is available on L1 and can be challenged. This is the rollup-equivalent of "safe" head. It is the earliest point at which the transaction's inclusion is backed by L1 data availability.

Stage 4 — L1 finality. After Ethereum's own finality mechanism (two epochs under proof-of-stake) plus the rollup's dispute window, the batch is finalized. Reverting a transaction at this stage would require an L1 reorg beyond finality, which is treated as economically infeasible. This is the only stage suitable for irreversible settlement decisions such as exchange withdrawals or cross-chain bridges.

  • Pending: hash known, no block assigned.
  • Preconfirmed: receipt exists, block built by sequencer, ~200ms cadence.
  • Safe: batch posted to L1, data available, challengeable.
  • Finalized: L1 finality plus dispute window elapsed.

How transaction ordering and priority fees work on Base

Within each 200ms block, Base orders transactions by priority fee, as documented in Base's transaction ordering specification. The base fee is burned per EIP-1559; the priority fee goes to the sequencer. This means a transaction with a competitive priority fee is more likely to land in the next block, but the 200ms cadence means even a modest fee usually confirms within a few blocks under normal load.

Base also supports validity transactions, which compete for inclusion only after their predicate conditions match. A matching predicate does not reserve block space, so a validity transaction that becomes eligible during a congested period still competes on fee like any other transaction. For application design, this means you cannot assume a conditional transaction will execute at the exact moment its condition becomes true; you can only assume it becomes eligible.

The practical implication for fee estimation: query eth_maxPriorityFeePerGas and eth_gasPrice from a Base RPC endpoint, add a margin, and set a max fee that tolerates a few blocks of base-fee movement. Do not copy Ethereum mainnet fee assumptions; Base's base fee is typically orders of magnitude lower, and overpaying does not buy faster inclusion beyond the next block.

Prerequisites and assumptions for the diagnostic procedure

The procedure below assumes you have a Base RPC URL (mainnet or Sepolia), a funded account with a private key you control, and a toolchain that can sign EIP-1559 transactions. It also assumes you can reach an Ethereum L1 RPC endpoint to verify batch posting, since Base's own RPC does not expose L1 batch status directly.

Placeholders used throughout: BASE_RPC_URL, L1_RPC_URL, PRIVATE_KEY, and TO_ADDRESS. Never commit a real private key to a repository or paste it into a shared terminal history. For production systems, sign with a hardware wallet or a key management service and keep the RPC credentials in a secrets manager.

If you need a dedicated endpoint for consistent latency during the diagnostic, the dedicated node options page describes the difference between shared and dedicated capacity. Shared public endpoints are fine for a one-off check but introduce variance that can be mistaken for network behavior.

Submitting a transaction and capturing its hash

The first step is to build, sign, and broadcast a transaction, then persist the hash immediately. The hash is the only stable identifier you will use for every subsequent query. The following Python snippet uses web3.py and an EIP-1559 transaction; it prints the hash and the initial receipt status.

Run it against a testnet first. The script does not wait for confirmation; it returns as soon as the node accepts the raw transaction, which is the correct behavior for a diagnostic that will poll separately.

import os, time
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(os.environ["BASE_RPC_URL"]))
acct = w3.eth.account.from_key(os.environ["PRIVATE_KEY"])

nonce = w3.eth.get_transaction_count(acct.address)
priority = w3.eth.max_priority_fee
base_fee = w3.eth.get_block("latest")["baseFeePerGas"]

 tx = {
    "to": os.environ["TO_ADDRESS"],
    "value": w3.to_wei(0.0001, "ether"),
    "chainId": w3.eth.chain_id,
    "nonce": nonce,
    "maxPriorityFeePerGas": priority,
    "maxFeePerGas": base_fee * 2 + priority,
    "gas": 21000,
    "type": 2,
}

signed = acct.sign_transaction(tx)
hash_ = w3.eth.send_raw_transaction(signed.raw_transaction)
print("tx hash:", hash_.hex())

# Poll for the sequencer receipt
for _ in range(30):
    r = w3.eth.get_transaction_receipt(hash_)
    if r is not None:
        print("block:", r.blockNumber, "status:", r.status, "gasUsed:", r.gasUsed)
        break
    time.sleep(0.5)
else:
    print("no receipt after 15s — inspect pending pool and nonce")

Verifying each stage with JSON-RPC calls

Once you have the hash, you can verify each stage independently. The curl calls below use standard JSON-RPC methods supported by Base nodes. Replace BASE_RPC_URL with your endpoint.

Stage 1 and 2 are checked with eth_getTransactionByHash and eth_getTransactionReceipt. A null receipt with a non-null transaction object means the transaction is in the pool but not yet sequenced. A null transaction object means the node has not seen it at all — check the hash, the chain ID, and whether the transaction was broadcast to a node that peers with the sequencer.

Stage 3 and 4 require an L1 query. Base's batch inbox contract emits events when a batch is posted; you can find the batch containing your transaction by searching L1 logs for the batch submission event and matching the L2 block range. This is more involved than a single RPC call, so most teams use an indexer or the OP Stack op-node rollup RPC for optimism_syncStatus, which reports the safe and finalized L2 heads directly.

# Stage 1/2: transaction and receipt on Base
curl -s -X POST "$BASE_RPC_URL" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getTransactionByHash","params":["0xYOUR_TX_HASH"]}'

curl -s -X POST "$BASE_RPC_URL" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"eth_getTransactionReceipt","params":["0xYOUR_TX_HASH"]}'

# Stage 3/4: safe and finalized L2 heads via the rollup RPC
curl -s -X POST "$BASE_RPC_URL" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":3,"method":"optimism_syncStatus","params":[]}'

Expected verification results and how to read them

The table below describes the expected shape of each response and what it means. It is a reading guide, not a set of measured values; the actual block numbers and timestamps depend on when you run the procedure.

StageMethodExpected response shapeInterpretation
Pendingeth_getTransactionByHashObject with blockNumber: nullIn pool, not sequenced
Preconfirmedeth_getTransactionReceiptObject with blockNumber, status: 0x1Sequencer included it
Safeoptimism_syncStatussafe_l2.number ≥ your blockBatch posted to L1
Finalizedoptimism_syncStatusfinalized_l2.number ≥ your blockL1 finality reached
If the receipt exists but status is 0x0, the transaction was included and reverted. That is a contract-level failure, not a sequencing failure; inspect the revert reason with eth_call at the parent block. If the receipt never appears and the transaction object is also null, the transaction was likely dropped from the pool — usually a nonce gap or an underpriced max fee.

A useful sanity check is to compare eth_blockNumber before and after submission. Because Base builds blocks every 200ms, the block number should advance by roughly five per second. If it does not, you are likely hitting a lagging or rate-limited endpoint rather than a network stall.

Troubleshooting stuck, dropped, and replaced transactions

Stuck pending with a nonce gap. If a previous transaction from the same account is still pending, the sequencer will not include a later nonce. Query eth_getTransactionCount(address, "pending") and compare with "latest". A difference indicates unconfirmed transactions ahead of yours. Resolve by waiting, or by replacing the earlier transaction with a higher fee at the same nonce.

Dropped from the pool. Base's transaction pool has a finite size and evicts the lowest-fee transactions under pressure. A transaction that was pending and then disappears from eth_getTransactionByHash was evicted. Resubmit with a higher priority fee; the nonce is unchanged.

Replaced. If you resubmitted at the same nonce with a higher fee, the original hash will return null and the replacement hash will carry the receipt. Track both hashes during the replacement window.

Confirmed but not safe for a long time. This usually means the sequencer is producing blocks but batch posting to L1 is delayed. Check the L1 gas market and the batch submitter's balance. During L1 congestion, batch posting can lag, which extends the time to safe and finalized without affecting preconfirmation speed.

Receipt exists but logs are missing. Some RPC providers return receipts without full log decoding. Query eth_getLogs with the block range and address filter to retrieve raw logs, and decode them client-side.

  • Nonce gap: compare pending vs latest transaction count.
  • Eviction: hash disappears from the pool, resubmit with higher fee.
  • Replacement: original hash null, replacement hash carries receipt.
  • Batch lag: preconfirmed but not safe; check L1 gas and submitter balance.

Limitations and tradeoffs of relying on preconfirmation

Preconfirmation is fast and cheap, but it is a promise from a centralized sequencer, not a cryptographic guarantee. If the sequencer fails or is censored, preconfirmed transactions can be reordered or dropped before the batch reaches L1. Base's decentralization roadmap addresses this over time, but any application that moves value based on a preconfirmed receipt should treat that receipt as a credit decision, not a settlement.

The tradeoff is latency versus certainty. Waiting for L1 finality adds minutes to every operation and is unnecessary for most user-facing flows, where a preconfirmed receipt plus a confirmation-depth heuristic (for example, waiting N Base blocks) is adequate. For bridges, exchange deposits, and any flow where reversal would be catastrophic, wait for the finalized L2 head reported by optimism_syncStatus.

A second tradeoff is RPC dependency. Preconfirmation status is only as fresh as your endpoint. A lagging node can report a transaction as pending after it has already been sequenced. Use a provider with documented freshness guarantees, or cross-check against a second endpoint before concluding a transaction is stuck. The RPC endpoint guide explains how to evaluate freshness and rate limits, and the API service overview describes the operational model behind managed endpoints.

Next steps: instrumenting the lifecycle in your application

The most robust pattern is to model the four stages explicitly in your application state machine rather than collapsing them into a boolean confirmed. Store the transaction hash, the preconfirmed block number, the safe head at the time of confirmation, and the finalized head when it arrives. Emit distinct events for each transition so downstream consumers can choose their own certainty threshold.

For a production deployment, pair the diagnostic above with monitoring on the safe and finalized heads. A sudden divergence between preconfirmed block production and safe-head advancement is an early warning of batch-posting problems. If you are selecting an endpoint for this workload, the RPC Assistant's comparison of Base-compatible RPC providers covers the criteria that matter for lifecycle tracking, and the RPC pricing page explains how request volume maps to cost when you poll multiple stages per transaction.

Finally, test the failure paths deliberately on Base Sepolia: submit with an intentionally low fee, create a nonce gap, and observe how each stage reports the condition. The behavior you see on testnet is the behavior you must handle in production, and the 200ms block cadence makes these experiments fast to run.

Never Worry about Infrastructure Again

OnFinality takes away the heavy lifting of DevOps so you can build smarter and faster.

Get Started