Kava RPC: A Developer's Guide (Chain ID 2222)

Kava is two chains in one. A Cosmos SDK chain handles staking, governance and IBC; next to it runs an Ethereum-compatible EVM co-chain with chain ID 2222, where Solidity contracts, MetaMask and the usual eth_* tooling live. Both share one validator set and one consensus engine (CometBFT), and KAVA pays for gas on both sides.

If you're building on the EVM side, most of Ethereum carries over. The parts that don't come from that Cosmos foundation: instant finality, no EIP-1559 base fee, a hard eth_getLogs limit, and nodes that keep only a few minutes of state by default. Everything below was measured through our endpoint on 2026-10-02.

The essentials

Finality: one block and you're done

CometBFT finalizes each block when it's committed, so there are no reorgs and no confirmation count to wait for. safe and finalized both returned the newest block. A deposit is final as soon as its receipt exists, about 6 seconds after submission. Kava is in the instant group of our finalized-tag measurements across 62 chains; code written for Ethereum's 13-minute finality is just waiting for nothing here.

Fees: a flat gas price, no base fee

Kava blocks have no baseFeePerGas, and eth_gasPrice returned exactly 1 gwei. eth_feeHistory answers, but its baseFeePerGas array contains null entries, so fee logic that does arithmetic on it will throw. The practical rules:

• Price transactions with eth_gasPrice (or a legacy gasPrice field). Don't build maxFeePerGas from a base fee that isn't there.
• Expect a slightly padded estimate. eth_estimateGas for a plain transfer returned 21,060, against Ethereum's 21,000.

import { createPublicClient, http } from "viem";
import { kava } from "viem/chains";

const client = createPublicClient({
  chain: kava,
  transport: http("https://rpc.swiftnodes.io/rpc/kava?key=YOUR_API_KEY"),
});

const gasPrice = await client.getGasPrice(); // 1 gwei; there is no base fee to add a tip to

The 10,000-block log limit

A 100,000-block eth_getLogs request came back with an explicit error:

maximum [from, to] blocks distance: 10000

At 5.7 seconds per block, 10,000 blocks is about 16 hours of chain, so a one-week backfill is about 11 requests and a month about 46. The message states the number, so a client can read it and adapt. The general pattern is in eth_getLogs range caps.

History: minutes by default, everything with archive=1

Kava full nodes prune old state aggressively. Through our default route, eth_getBalance worked 100 blocks back and failed at 127 blocks and beyond with:

rpc error: code = Unknown desc = codespace sdk code 18: invalid request: failed to load state at height ...

That is about 10 minutes of state. Deeper requests on another node returned height 21836513 is not available, lowest height is 21836516, which names the pruning floor directly. Both errors come from the Cosmos SDK layer, which is why they don't look like Ethereum's usual missing trie node.

For older state, add archive=1 to the URL. Our endpoint then routes the request to archive nodes only, and eth_getBalance answered 1,000, 100,000 and 5,000,000 blocks back, and at block 1:

https://rpc.swiftnodes.io/rpc/kava?key=YOUR_API_KEY&archive=1

Use it for backfills and historical eth_calls; keep the default route for live traffic. Full node vs archive node covers when you need which.

Tracing

debug_traceBlockByNumber with callTracer works on the default route, so internal calls are available for recent blocks (what tracing costs). The Parity-style trace_* methods are not available, on either route. eth_getBlockReceipts did not answer reliably in our tests (timeouts and retryable errors), so fetch receipts per transaction on Kava.

The Cosmos side

Everything above is the EVM co-chain. The Cosmos SDK side has its own APIs (CometBFT RPC, REST and gRPC), its own kava1… bech32 addresses, and its own modules for staking, governance and IBC transfers. If you only deploy Solidity contracts and read EVM state, you never need the Cosmos APIs; if you index staking or IBC flows, you do. Our Cosmos RPC explainer covers how those three interfaces fit together.

The short version

• Chain ID 2222, KAVA for gas, an EVM co-chain next to a Cosmos SDK chain.
• Final in one block (~6 s); safe and finalized equal latest.
• No base fee: price with eth_gasPrice (1 gwei); eth_feeHistory has null base fees.
• eth_getLogs is capped at 10,000 blocks (about 16 hours).
• Default nodes keep ~100 blocks of state; add archive=1 for full history.
• debug_* tracing works; trace_* doesn't.

Kava HTTP and WebSocket endpoints, with live block height and WebSocket status, are on our Kava RPC page. The same key covers 83 chains, and SwiftNodes has a free tier to try it.