BOB RPC: A Developer's Guide (Chain ID 60808)

BOB ("Build on Bitcoin") is an Ethereum rollup built for Bitcoin assets. Its contracts hold wrapped and staked BTC, and its BOB Gateway moves BTC in and out. On the RPC side, though, it is an ordinary OP Stack chain. Gas is paid in ETH, data is posted to Ethereum, and standard Ethereum tooling works. The differences from other OP Stack chains are in the details: how quickly blocks become safe, how far back eth_getLogs reaches, and whether you can trace.

This guide is measured against the live chain on October 11, 2026, through the same endpoint SwiftNodes customers use.

The endpoint

https://rpc.swiftnodes.io/rpc/bob?key=YOUR_API_KEY
wss://rpc.swiftnodes.io/ws/bob?key=YOUR_API_KEY

With viem:

import { createPublicClient, defineChain, http } from "viem";

const bob = defineChain({
  id: 60808,
  name: "BOB",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.swiftnodes.io/rpc/bob?key=YOUR_API_KEY"] } },
});

const client = createPublicClient({ chain: bob, transport: http() });

What we measured

Fees: the L1 fee is the bill

Blocks are nearly empty: the busiest block in a 1,024-block eth_feeHistory window was 1.9% full. The base fee sits at 252 wei. The block header's fee parameters (denominator 250, elasticity 6, no minimum base fee) are the OP Stack defaults, so the fee would rise normally if demand appeared. The median tip in the same window was 0, even though eth_maxPriorityFeePerGas suggests 0.001 gwei.

Execution is almost free: 21,000 × 1,000,252 wei ≈ 0.000000021 ETH. The L1 data fee is the rest. We asked BOB's fee oracle at 0x420000000000000000000000000000000000000F to price a signed transfer with getL1Fee, and it returned 253,788,768,959 wei, about 0.000000254 ETH:

The oracle's baseFeeScalar is 2,000,000 and its blobBaseFeeScalar is 611,590, so the L1 fee follows both Ethereum's execution base fee and its blob fee. Estimate it before you send:

const l1Fee = await client.readContract({
  address: "0x420000000000000000000000000000000000000F",
  abi: [{ name: "getL1Fee", type: "function", stateMutability: "view",
          inputs: [{ type: "bytes" }], outputs: [{ type: "uint256" }] }],
  functionName: "getL1Fee",
  args: [serializedTx],
});

Wallets that show only gasUsed × effectiveGasPrice will understate a BOB transaction's cost by more than ten times. Receipts carry the real charge in l1Fee.

Bitcoin on an Ethereum rollup

BOB's BTC is ERC-20 tokens, each with its own bridge and decimals. totalSupply on BOB for the main ones on October 11:

Two practical points follow. First, decimals differ: WBTC and uniBTC use 8, like satoshis, while SolvBTC and tBTC use 18, like ETH. Code that sums "BTC" across tokens has to normalize each one. Second, none of these is native BTC. Each carries its own issuer and bridge risk, so treat them as separate assets in pricing and risk logic.

Activity

BOB is quiet on-chain. In 300 consecutive blocks (10 minutes) there were 10 user transactions alongside the per-block deposit transactions, about one a minute. In our halt survey across 110 chains, BOB had no gap of 10 minutes or more between August 25 and October 6.

safe and finalized move together

On most OP Stack chains safe trails the head by a few minutes at most and finalized by about 20 minutes. On BOB the two tags pointed at the same block every time we checked. The lag changed between readings: 873 blocks (29 minutes) in our first, and 1,620 to 1,642 blocks (54 to 55 minutes) in three readings later the same day, growing by one block every two seconds. That pattern fits batches being posted to Ethereum infrequently: nothing becomes safe until a batch lands, and by the time we looked, the batch was already in a finalized Ethereum block.

The practical effect is that safe is not a quick confirmation on BOB. If your app waits for safe before crediting a deposit, expect waits of up to an hour, not a minute. Use latest plus your own confirmation count for low-value actions, and finalized where you need Ethereum's guarantee. BOB's proof system has also changed over time: according to L2BEAT it returned to a permissioned dispute game in September 2026. That affects withdrawals to Ethereum, not the RPC tags. For the general picture, see soft vs hard finality on L2s.

Logs

eth_getLogs accepts up to 2,000 blocks per request through our endpoint. A 2,001-block range returns:

-32602 eth_getLogs block range 2001 exceeds maximum of 2000; narrow fromBlock–toBlock or filter by address/topics

Because the chain is quiet, a full 2,000-block window (about 67 minutes) returned only 123 logs (192 KB) in 1.1 to 1.6 seconds. The same window filtered to WBTC returned 11 logs in about half a second. Page in 2,000-block steps and filter by address when you can. Other public endpoints differ: one capped at 1,000 blocks, another at 10,000 on its free plan. See our getLogs range cap survey for other chains.

History and tracing

State reads work at any depth: eth_getBalance at block 1 answered.

Tracing is the gap. debug_traceTransaction, debug_traceBlockByNumber and trace_block are not available through our endpoint, which answers the method is not available on this endpoint. We checked BOB's public RPCs directly, and none served traces either. BOB's own rpc.gobob.xyz answers authenticated API key required for method, another returns Invalid method, and a third returns a temporary internal error. If you need call traces on BOB, plan to run your own node with debug APIs enabled, or use a provider that sells authenticated access.

Summary

• OP Stack chain, chain ID 60808, ETH for gas, 2-second blocks.
• Base fee 252 wei; a transfer costs about 0.000000275 ETH, 92% of it the L1 data fee, priced off Ethereum's execution and blob fees.
• BTC is several ERC-20s with different decimals and bridges; normalize before summing.
• safe and finalized move together, 29 to 55 minutes behind the head in our readings.
• eth_getLogs is capped at 2,000 blocks; tracing is not available publicly.

BOB endpoints and status are on our BOB RPC page, alongside the rest of the 128 chains on one key. SwiftNodes has a free tier to try it.