Sei EVM JSON-RPC API Reference

Sei fully supports the standard Ethereum JSON-RPC API, so existing EVM tooling (ethers.js, viem, Hardhat, Foundry, etc.) works out of the box. Use the explorer below to browse every method Sei exposes, inspect parameters, run requests against a live endpoint, and copy ready-to-use snippets in a range of popular languages. The authoritative prose for the request format, the deprecated sei_*/sei2_* extensions, and address resolution follows underneath.

By default the explorer lists only the available, current methods. Each is labelled with one of three statuses:

Supported — registered with a full implementation and standard Ethereum behavior.
Limited — callable, but returns a static value or has a Sei-specific caveat (shown in the method’s Sei-specific behavior note). Examples: eth_coinbase returns the fee-collector address and eth_getProof returns an IAVL proof.
Unavailable — not registered, explicitly errors, or not applicable to Sei’s architecture. This includes blob methods (eth_blobBaseFee), proof-of-work and uncle methods, and the admin/miner/clique/engine/les/personal namespaces.

The deprecated sei_*/sei2_* extensions and the unavailable methods are hidden by default — enable Show deprecated & unavailable methods to browse them. The deprecated extensions are also documented under Sei custom endpoints.

Overview

Sei supports the Ethereum JSON-RPC API with some Sei-specific extensions to support cross-VM operations, synthetic transactions, and other advanced features. Because Sei has instant finality, the safe, finalized, and latest block tags all resolve to the same (latest committed) block. All endpoints follow the standard JSON-RPC format:

JSON-RPC Request/Response Format

Request Format

HTTP method: always “POST”
Header: accept: application/json
Header: content-type: application/json
Body (JSON):
- id: an arbitrary string identifier
- jsonrpc: always “2.0”
- method: endpoint name (e.g. “eth_sendRawTransaction”)
- params: an array that differs from endpoint to endpoint

Response Format

Body (JSON):
- id: the same identifier in request
- jsonrpc: always “2.0”
- result: an object that differs from endpoint to endpoint
- error (if applicable): error details

Network endpoints

Network	Chain ID	HTTP endpoint	WebSocket endpoint
Pacific-1 (mainnet)	`1329` (`0x531`)	`https://evm-rpc.sei-apis.com`	`wss://evm-ws.sei-apis.com`
Atlantic-2 (testnet)	`1328` (`0x530`)	`https://evm-rpc-testnet.sei-apis.com`	`wss://evm-ws-testnet.sei-apis.com`

For additional public and commercial endpoints, see RPC providers and Chains & endpoints.

Tendermint `/status` endpoint

Alongside the EVM JSON-RPC surface, Sei nodes expose the underlying Tendermint/CometBFT RPC, including the /status endpoint. Its SyncInfo object reports a last_committed_block_height field: the height of the last block finalized by consensus.

curl -s $SEI_TENDERMINT_RPC/status | jq '.result.sync_info.last_committed_block_height'

The field is JSON-serialized as a string (last_committed_block_height), matching the other height fields in SyncInfo.

Field	JSON	Description
`last_committed_block_height`	string	Height of the last block finalized by consensus.

Consensus-engine behavior:

Under CometBFT — commit and app-apply happen in a single step, so last_committed_block_height is guaranteed to equal latest_block_height.
Under Autobahn — the value is derived from the latest CommitQC. Because consensus finalizes a block before the app executes it, the invariant is last_committed_block_height >= latest_block_height; the two can briefly differ while the app catches up.

validator_info shape. The /status response’s validator_info object always includes both a pub_key and an address field. On nodes that are not validators, pub_key is a zero (empty) public key with address derived from it and voting_power is 0, rather than the fields being omitted — a stable response shape so clients like CosmJS can parse /status without special-casing non-validator nodes. On validator nodes, pub_key and voting_power carry the real values.

Under Autobahn (AutobahnConfigFile set) the CometBFT block store is not populated, so /status derives latest_block_height and latest_app_hash from the app layer (ABCIInfo) instead of the block store. Several other SyncInfo fields (block hash/time, earliest-block metadata, catching_up, and peer-height fields) remain unpopulated in this mode.

Tendermint block and validator endpoints under Autobahn

Under Autobahn (AutobahnConfigFile set) the CometBFT BlockStore and StateStore are not populated. Rather than returning empty or failing responses, the /block and /block_by_hash Tendermint RPC endpoints route through the GigaRouter’s in-memory state (the finalized global blocks retained by the Autobahn data layer), while /block_results and /validators synthesize their responses (an empty result set and the genesis committee, respectively). This keeps downstream consumers — including evmrpc, block explorers, and monitoring tooling — working without individually branching on the consensus engine. For /block and /block_by_hash, responses are served only for heights still inside Autobahn’s retained window (heights pruned per RetainHeight are no longer available); /block_results and /validators do not read the retained block data and respond for any height up to the current ABCI head. Requests are validated against the current ABCI head, so heights above it return the same ErrHeightExceedsChainHead-class errors as the CometBFT path, and pruned heights on /block return ErrHeightNotAvailable.

Endpoint	Autobahn behavior
`/block`	Returns the fully-populated translated block at the requested height: `BlockID.Hash` (the Autobahn header hash), the header (`ChainID`, `Height`, `Time`), and `Data.Txs`. Other header fields (`AppHash`, `ProposerAddress`, `LastCommit`, …) stay at zero values.
`/block_by_hash`	Resolves the block by its Autobahn header hash via an in-memory hash index. An unknown or wrong-size hash returns `{Block: nil}` with no error, matching CometBFT semantics for a missing block.
`/block_results`	Returns a valid-but-empty `ResultBlockResults` at the requested height. `ConsensusParamUpdates.Block.MaxGas` is populated from the producer config; `TxsResults` (per-tx `ExecTxResult` details) is intentionally empty because `FinalizeBlock` responses are not persisted under Autobahn.
`/validators`	Returns the genesis committee for any height up to the current ABCI head — the committee is fixed at genesis under Autobahn (no validator-updates path), and the endpoint does not read the retained block data, so pruned heights still answer. `block_height` matches the requested height, and pagination (`page`/`per_page`) behaves the same as the CometBFT path.

Because FinalizeBlock responses are not stored on disk under Autobahn, /block_results cannot surface per-transaction execution results (TxsResults is empty). For per-transaction EVM data, use the EVM JSON-RPC methods (eth_getTransactionReceipt, eth_getBlockReceipts) instead.

Filter and subscription limits

Log filters (eth_getLogs, eth_getFilterLogs) are subject to the following limits by default:

Open-ended block range: up to 10,000 logs in one response
Close-ended block range: up to 2,000 blocks to query over

Real-time subscriptions (eth_subscribe for newHeads and logs) are available over WebSocket only. See WebSocket connections for transport details.

Standard Ethereum endpoints

Every method below is also browsable interactively in the explorer above; this section is the static, copy-friendly reference. Methods are grouped by purpose and labelled with their Sei support status. Block parameters accept a hex number or one of the tags latest, earliest, pending, safe, or finalized — on Sei, safe, finalized, and latest all resolve to the latest committed block due to instant finality. The deprecated sei_*/sei2_* extensions are documented separately under Sei custom endpoints.

Send transactions

`eth_sendRawTransaction`

Supported. Submits a signed, RLP-encoded raw EVM transaction to the network and returns its hash.Sei-specific behavior: Decodes to an ethtypes.Transaction, wraps it in a Cosmos MsgEVMTransaction, and broadcasts via CometBFT (CheckTx-level BroadcastTx, i.e. broadcast_tx_sync, by default; slow mode uses BroadcastTxCommit). Non-zero CheckTx codes surface as ABCI errors, not geth mempool errors. Legacy (non-1559) txs must set gasPrice at or above the governance minimum (currently 50 gwei on mainnet); blob (EIP-4844) txs are not enabled. Supports per-sender EvmProxy forwarding.Under Autobahn (AutobahnConfigFile set): transaction broadcast routes through Autobahn’s producer-backed mempool instead of CometBFT’s TxMempool. This mempool admits EVM transactions strictly in sequential per-sender nonce order: a transaction whose nonce does not match the sender’s next expected nonce is rejected with a bad-nonce error, so senders must submit nonces contiguously. The default CheckTx-synchronous broadcast (broadcast_tx_sync, the same path named above) blocks while the mempool is full and only returns once capacity is available — meaning a default eth_sendRawTransaction under Autobahn can stall for as long as the mempool stays full — whereas the async path (broadcast_tx_async) may silently drop the transaction instead. The unsafe_flush_mempool Tendermint RPC endpoint is not supported under Autobahn and returns unsafe_flush_mempool is not supported with autobahn mempool.Parameters:

#	Name	Type	Description
1	`data`	DATA	Signed, RLP-encoded transaction bytes (0x-prefixed).

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sendRawTransaction",
  "params": [
    "0x02f8b101808459682f00..."
  ]
}

`eth_sendTransaction`

Limited. Signs (with a node-hosted key) and submits a transaction in one call.Sei-specific behavior: Requires the ‘from’ address’s private key in the node’s local test keyring; production/public RPC nodes hold no hosted keys, so this returns ‘from address does not have hosted key’. Always signs as LegacyTxType. Sign client-side and use eth_sendRawTransaction instead.Parameters:

#	Name	Type	Description
1	`args`	object	Transaction object (from, to, value, data, gas, nonce, etc.).

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sendTransaction",
  "params": [
    {
      "from": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55",
      "to": "0x7507454444fa193d39f1392076bc784b77a7a8ff",
      "value": "0x1"
    }
  ]
}

`eth_signTransaction`

Limited. Signs a transaction with a node-hosted key and returns the signed payload without broadcasting.Sei-specific behavior: Requires a node-hosted key for the from address; not usable on public RPC nodes that hold no keys. Returns both the raw RLP bytes and the decoded tx.Parameters:

#	Name	Type	Description
1	`args`	object	SendTxArgs transaction object to sign (from, to, gas, gasPrice, value, nonce, data).

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_signTransaction",
  "params": [
    {
      "from": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55",
      "to": "0x7507454444fa193d39f1392076bc784b77a7a8ff",
      "value": "0x1",
      "nonce": "0x0",
      "gas": "0x5208",
      "gasPrice": "0x3b9aca00"
    }
  ]
}

`eth_sign`

Limited. Signs an EIP-191 personal message with a node-hosted key for the given address.Sei-specific behavior: Only works for addresses in the node’s local test keyring; production/public RPC nodes hold no hosted keys, so this returns ‘address does not have hosted key’. Applies the EIP-191 personal-message TextHash before signing.Parameters:

#	Name	Type	Description
1	`address`	DATA, 20 bytes	Address whose hosted key signs the data.
2	`data`	DATA	Message bytes to sign.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_sign",
  "params": [
    "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55",
    "0xdeadbeef"
  ]
}

Transaction lookup

`eth_getTransactionByHash`

Supported. Returns the EVM transaction matching the given hash, or null if not found.Sei-specific behavior: Sees EVM transactions only; if the hash resolves to a non-EVM Cosmos tx it errors. Pending lookups resolve the transaction directly from the CometBFT mempool via an EVM-hash index (rather than a geth txpool), so a pending EVM tx is found by its hash without scanning through unconfirmed-transaction pages. Use the legacy sei_getTransactionByHash to also surface Cosmos txs with synthetic representations.Parameters:

#	Name	Type	Description
1	`hash`	DATA, 32 bytes	Transaction hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionByHash",
  "params": [
    "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
  ]
}

`eth_getTransactionReceipt`

Supported. Returns the receipt of a transaction by hash, or null if not found.Sei-specific behavior: Receipt is reconstructed from keeper.GetReceipt + CometBFT block data rather than from a native MPT receipt trie; status/logs are standard Ethereum format. Under the Giga executor, an EVM transaction that bumps the sender’s nonce but then fails during state transition now returns a status=0 failed-tx receipt, rather than returning null indefinitely and hanging clients that poll for it. The known natural case is an EIP-7623 floor-data-gas shortfall (post-Pectra), which fails inside go-ethereum’s Execute() before any opcode runs. The receipt is a synthetic one written at EndBlock, with gasUsed and effectiveGasPrice of 0. The VmError reason is not part of the eth_getTransactionReceipt response; retrieve it with the non-standard eth_getVMError method. If a receipt exists but its block height is above the safe-latest watermark (for example when Tendermint status momentarily lags the receipt store), the method returns JSON null rather than an error — the Ethereum JSON-RPC ‘not yet mined’ signal — so clients simply poll again, matching eth_getBlockByNumber behavior.Parameters:

#	Name	Type	Description
1	`hash`	DATA, 32 bytes	Transaction hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionReceipt",
  "params": [
    "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
  ]
}

`eth_getTransactionByBlockNumberAndIndex`

Supported. Returns the EVM transaction at the given index within the block at the specified number.Sei-specific behavior: Index maps over EVM transactions only; an out-of-range index yields a null result rather than an error.Parameters:

#	Name	Type	Description
1	`blockNr`	BLOCKNUMBER	Block number or tag.
2	`index`	QUANTITY	Transaction index within the block.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionByBlockNumberAndIndex",
  "params": [
    "latest",
    "0x0"
  ]
}

`eth_getTransactionByBlockHashAndIndex`

Supported. Returns the EVM transaction at the given index within the block identified by hash.Sei-specific behavior: Index maps over EVM transactions only; same null-on-overflow semantics as the block-number variant.Parameters:

#	Name	Type	Description
1	`blockHash`	DATA, 32 bytes	Block hash.
2	`index`	QUANTITY	Transaction index within the block.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionByBlockHashAndIndex",
  "params": [
    "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864",
    "0x0"
  ]
}

`eth_getTransactionCount`

Supported. Returns the number of transactions sent from an address (nonce) at a given block.Sei-specific behavior: For the ‘pending’ tag Sei returns EvmNextPendingNonce from the CometBFT mempool (or redirects to an EvmProxy if the sender is sharded there). safe/finalized/latest are equivalent due to instant finality.Parameters:

#	Name	Type	Description
1	`address`	DATA, 20 bytes	Account address.
2	`blockNrOrHash`	BLOCKNUMBER or DATA	Block number, tag, or hash; ‘pending’ returns the next pending nonce.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionCount",
  "params": [
    "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55",
    "latest"
  ]
}

`eth_getNonce`

Limited. Sei-specific helper that returns the current EVM nonce for an address (latest state only).Sei-specific behavior: Non-standard Sei extension exposed as eth_getNonce, implemented as StateAPI.GetNonce in state.go (NOT on TransactionAPI). Unlike eth_getTransactionCount it takes no block tag (latest-only via ctxProvider(LatestCtxHeight)) and returns a bare uint64 with no block-tag argument. Prefer eth_getTransactionCount for standard nonce queries.Parameters:

#	Name	Type	Description
1	`address`	DATA, 20 bytes	Account address.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getNonce",
  "params": [
    "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55"
  ]
}

`eth_getTransactionErrorByHash`

Limited. Sei extension that returns the recorded VM error string for a transaction by hash (empty string if it succeeded or is not found).Sei-specific behavior: Non-standard Sei extension registered under the eth namespace. Unlike eth_getVMError, a not-found lookup returns an empty string and no error.Parameters:

#	Name	Type	Description
1	`hash`	DATA, 32 bytes	Transaction hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getTransactionErrorByHash",
  "params": [
    "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
  ]
}

`eth_getVMError`

Limited. Sei extension that returns the EVM VM error string recorded in a transaction’s receipt by hash.Sei-specific behavior: Non-standard Sei extension registered under the eth namespace. Returns the receipt’s VmError field and propagates a not-found error (unlike eth_getTransactionErrorByHash, which returns an empty string on not-found).Parameters:

#	Name	Type	Description
1	`hash`	DATA, 32 bytes	Transaction hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getVMError",
  "params": [
    "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
  ]
}

Account information

`eth_getBalance`

Supported. Returns the wei balance of an account at a given block.Sei-specific behavior: Balance reflects the account’s SEI bank balance (18-decimal wei representation) and can change from both EVM and non-EVM (Cosmos bank send / wasm) transactions. Height is resolved via the watermark manager with a state-version guard.Parameters:

#	Name	Type	Description
1	`address`	DATA, 20 bytes	Account address.
2	`blockNrOrHash`	BLOCKNUMBER or DATA	Block number, tag (latest/earliest/pending/safe/finalized), or hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBalance",
  "params": [
    "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55",
    "latest"
  ]
}

`eth_getCode`

Supported. Returns the contract bytecode at an address for a given block.Parameters:

#	Name	Type	Description
1	`address`	DATA, 20 bytes	Contract address.
2	`blockNrOrHash`	BLOCKNUMBER or DATA	Block number, tag, or hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getCode",
  "params": [
    "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
    "latest"
  ]
}

`eth_getStorageAt`

Supported. Returns the value stored at a storage slot of an address at a given block.Sei-specific behavior: Reads the EVM keeper’s slot value directly rather than from an MPT trie. The slot key must decode to at most 32 bytes.Parameters:

#	Name	Type	Description
1	`address`	DATA, 20 bytes	Contract address.
2	`key`	DATA, 32 bytes	Storage slot key (hex, up to 32 bytes).
3	`blockNrOrHash`	BLOCKNUMBER or DATA	Block number, tag, or hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getStorageAt",
  "params": [
    "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
    "0x0",
    "latest"
  ]
}

`eth_getProof`

Limited. Returns a Merkle proof for an account and the requested storage slots.Sei-specific behavior: Sei stores state in an IAVL-style tree, not an Ethereum Merkle-Patricia trie. The handler unwraps the EVM store through any intervening wrappers (cache, tracing, Giga cache, prefix stores) until it reaches an underlying proof-capable queryable store — classic IAVL, a store/v2 memiavl commitment, or any other proof-capable root — so proofs work across these backends rather than only classic IAVL. If no proof-capable queryable store can be reached it returns cannot find a proof-capable queryable KV store. The result is a Sei-specific ProofResult{address, hexValues, storageProof} where storageProof entries are CometBFT/IAVL crypto.ProofOps, NOT eth-style MPT proof nodes. There is no accountProof, balance, codeHash, nonce, or storageHash field (Sei has no per-account state root); standard eth_getProof verifiers will not work.Parameters:

#	Name	Type	Description
1	`address`	DATA, 20 bytes	Account address.
2	`storageKeys`	array of DATA, 32 bytes	Storage slot keys to prove (bounded by MaxStorageKeysPerProof).
3	`blockNrOrHash`	BLOCKNUMBER or DATA	Block number, tag, or hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getProof",
  "params": [
    "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
    [
      "0x0"
    ],
    "latest"
  ]
}

`eth_accounts`

Limited. Returns the list of addresses for which the node holds hosted keys.Sei-specific behavior: Sourced from the node’s local test keyring only; production/public RPC nodes hold no hosted keys, so this returns an empty list. Sign client-side and use eth_sendRawTransaction.Parameters: none.

Block information

`eth_getBlockByNumber`

Supported. Returns block information by number or tag, with full transactions when fullTx is true.Sei-specific behavior: Under the eth namespace only EVM transactions are indexed (synthetic/bank-transfer txs excluded). Block number 0 returns a synthetic genesis block (for The Graph compatibility); future/non-existent numeric blocks return null. Uncle/PoW header fields (sha3Uncles, nonce, mixHash, difficulty) are placeholders and the uncles array is always empty (CometBFT consensus). safe/finalized/latest are equivalent due to instant finality.Parameters:

#	Name	Type	Description
1	`number`	BLOCKNUMBER	Block number (hex) or tag (latest/safe/finalized/pending/earliest).
2	`fullTx`	boolean	If true include full transaction objects, else only hashes.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockByNumber",
  "params": [
    "latest",
    true
  ]
}

`eth_getBlockByHash`

Supported. Returns block information by block hash, with full transactions when fullTx is true.Sei-specific behavior: Block hashes are CometBFT block hashes (computed from the Tendermint header), so they differ from Ethereum block hashes and are not interchangeable across chains. Under the eth namespace synthetic txs and bank transfers are excluded. The genesis block hash (0xF9D3845DF25B43B1C6926F3CEDA6845C17F5624E12212FD8847D0BA01DA1AB9E, a synthetic constant identical on every Sei network, returned by the node in this uppercase form; lookups are case-insensitive) is recognized and returns the encoded genesis block directly, keeping hash-based lookups consistent with eth_getBlockByNumber("0x0"); other unknown/zero hashes return null. Uncles array is always empty.Parameters:

#	Name	Type	Description
1	`blockHash`	DATA, 32 bytes	Block hash.
2	`fullTx`	boolean	If true include full transaction objects, else only hashes.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockByHash",
  "params": [
    "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864",
    false
  ]
}

`eth_getBlockTransactionCountByNumber`

Supported. Returns the number of EVM transactions in a block by number, as a hex quantity.Sei-specific behavior: Counts the same transactions that appear in eth_getBlockByNumber’s transaction list: EVM transactions are counted only when a receipt exists for them, and synthetic (wasm MsgExecuteContract) and bank-transfer (MsgSend) txs remain excluded under the eth namespace — they are only included in the sei_/sei2_ count variants. Genesis returns 0x0; non-existent/future blocks return null. Because the receipt store can be configured with a smaller KeepRecent than the block/state stores, this method now verifies that the requested block’s receipts have not been pruned before counting: if they have, it returns an error of the form requested height N receipts have been pruned; earliest available is M rather than a count. This means the call can fail for older blocks even when the block data itself is still available.Parameters:

#	Name	Type	Description
1	`number`	BLOCKNUMBER	Block number or tag.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockTransactionCountByNumber",
  "params": [
    "latest"
  ]
}

`eth_getBlockTransactionCountByHash`

Supported. Returns the number of EVM transactions in a block by hash, as a hex quantity.Sei-specific behavior: Counts EVM transactions only; synthetic/bank-transfer txs are excluded. Genesis hash returns 0x0; unknown hash returns null. Like eth_getBlockTransactionCountByNumber, returns a “receipts have been pruned” error when the requested block’s receipts have been pruned from the receipt store.Parameters:

#	Name	Type	Description
1	`blockHash`	DATA, 32 bytes	Block hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockTransactionCountByHash",
  "params": [
    "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
  ]
}

`eth_getBlockReceipts`

Supported. Returns all EVM transaction receipts for a given block.Sei-specific behavior: Under the eth namespace synthetic/shell receipts are excluded (includeShellReceipts=false). Genesis returns an empty array. An empty (zero) or non-existent/unknown block hash returns result: null rather than an error, matching the Ethereum RPC spec. transactionIndex is recomputed sequentially over the compacted receipt list.Parameters:

#	Name	Type	Description
1	`blockNrOrHash`	BLOCKNUMBER or DATA	Block number, tag, or hash.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getBlockReceipts",
  "params": [
    "latest"
  ]
}

Blockchain information

`eth_blockNumber`

Supported. Returns the number of the most recent committed EVM block as a hex uint64.Sei-specific behavior: Block height comes from CometBFT latest height; the latest committed block is already final on Sei (instant finality, so latest == safe == finalized).Parameters: none.

`eth_chainId`

Supported. Returns the EVM chain ID as a hex big int.Sei-specific behavior: Sourced from the x/evm keeper. Mainnet (pacific-1) = 1329 (0x531); testnet (atlantic-2) = 1328 (0x530).Parameters: none.

`eth_coinbase`

Limited. Returns the block reward beneficiary (coinbase) address.Sei-specific behavior: Sei has no miner; this returns the Cosmos fee-collector module address (GetFeeCollectorAddress), not a validator/miner address. The COINBASE opcode returns the same value.Parameters: none.

`eth_gasPrice`

Limited. Returns a suggested gas price in wei (hex).Sei-specific behavior: Sei-specific congestion heuristic, not a raw mempool oracle. InfoAPI.GasPrice/GasPriceHelper (info.go): when uncongested it returns baseFee * 110/100 (base fee +10%); when congested it returns medianRewardPrevBlock + baseFee (50th-percentile priority-fee reward from the previous block added to base fee). The base fee comes from the x/evm keeper (GetNextBaseFeePerGas), which is itself floored at the governance-set minimum base fee; the RPC handler applies no additional explicit lower-bound clamp. The mainnet minimum gas price (~50 gwei) is enforced for transaction acceptance at the mempool/ante-handler level, not inside eth_gasPrice.Parameters: none.

`eth_maxPriorityFeePerGas`

Limited. Returns a suggested priority fee (tip) per gas in wei (hex).Sei-specific behavior: Sei-specific: returns a hardcoded 1 gwei (defaultPriorityFeePerGas) when the chain is uncongested; only when congested does it derive the tip from the previous block’s 50th-percentile reward. Sei docs advise using a single gasPrice and omitting EIP-1559 fee fields.Parameters: none.

`eth_feeHistory`

Supported. Returns base fees, gas-used ratios, and reward percentile data over a range of blocks.Sei-specific behavior: Base fees and rewards reflect Sei’s x/evm fee market (GetNextBaseFee), not an Ethereum EIP-1559 mempool, and Sei does not burn the base fee. Watermark-aware: pruned/historical blocks may not be available as far back as on Ethereum archive nodes. Matching go-ethereum/execution-apis semantics, on ranges where every block has base-fee data, baseFeePerGas contains one more element than gasUsedRatio: the trailing element is the projected base fee for the child of the newest block in the range, appended only when the newest block’s own header base fee was available. Heights with pruned or partial base-fee data are skipped from baseFeePerGas while still contributing a gasUsedRatio row (0.0 fallback), so the two arrays can diverge from that +1 relationship on ranges with pruned history. Each block’s base fee uses header base fee semantics (the same value reported in the block header — GetNextBaseFee at the parent’s committed height) with a DefaultMinFeePerGas fallback for early blocks.Parameters:

#	Name	Type	Description
1	`blockCount`	QUANTITY	Number of blocks in the requested range.
2	`newestBlock`	BLOCKNUMBER	Highest block of the range (number or tag).
3	`rewardPercentiles`	array of float	Monotonically increasing percentiles to sample for priority-fee rewards.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_feeHistory",
  "params": [
    "0x5",
    "latest",
    [
      25,
      50,
      75
    ]
  ]
}

`net_version`

Supported. Returns the network/chain ID as a decimal string.Sei-specific behavior: Returns the EVM chain ID in decimal (alias of eth_chainId): ‘1329’ on pacific-1 mainnet, ‘1328’ on atlantic-2 testnet.Parameters: none.

`web3_clientVersion`

Supported. Returns the client version string.Sei-specific behavior: Reports a synthetic ‘Geth/<os>-<arch>/<goVersion>’ string (Sei’s EVM is backed by go-ethereum); it does NOT embed the actual sei-chain/seid version, so it is not a reliable Sei version indicator.Parameters: none.

Filters & subscriptions

`eth_newFilter`

Supported. Creates a log filter for the given criteria and returns a filter ID for later polling.Sei-specific behavior: Subject to the same range/size caps as eth_getLogs: open-ended ranges return up to 10,000 logs (DefaultMaxLogLimit); close-ended ranges are limited to 2,000 blocks (DefaultMaxBlockRange), with large-query rate limiting.Parameters:

#	Name	Type	Description
1	`crit`	object	Filter criteria: fromBlock, toBlock (or blockHash), address(es), and topics.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_newFilter",
  "params": [
    {
      "fromBlock": "latest",
      "address": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
      "topics": []
    }
  ]
}

`eth_newBlockFilter`

Supported. Creates a filter that tracks newly arrived block hashes and returns its ID.Parameters: none.

`eth_getFilterChanges`

Supported. Polls a filter and returns new logs (log filters) or block hashes (block filters) since the last poll.Sei-specific behavior: For log filters, returns an empty array ([]) rather than null when no logs match or a bounded filter’s block range has been fully consumed, in line with the Ethereum JSON-RPC spec.Parameters:

#	Name	Type	Description
1	`filterID`	QUANTITY/ID	Filter ID from a New*Filter call.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getFilterChanges",
  "params": [
    "0x1"
  ]
}

`eth_getFilterLogs`

Supported. Returns all logs matching a previously created log filter, including historical logs.Sei-specific behavior: Bounded by the same caps as eth_getLogs (2,000-block range, 10,000-log limit) with large-query rate limiting.Parameters:

#	Name	Type	Description
1	`filterID`	QUANTITY/ID	Filter ID from a NewFilter call.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getFilterLogs",
  "params": [
    "0x1"
  ]
}

`eth_getLogs`

Supported. Returns logs matching the given filter criteria.Sei-specific behavior: Returns EVM logs only. Hard limits: max 2,000 blocks per close-ended query and up to 10,000 logs per response; exceeding the range errors with ‘block range too large’. Large queries are globally rate-limited. Use the legacy sei_getLogs to include synthetic logs from Cosmos activity.Parameters:

#	Name	Type	Description
1	`crit`	object	Filter criteria: fromBlock, toBlock (or blockHash), address(es), topics.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_getLogs",
  "params": [
    {
      "fromBlock": "0x0",
      "toBlock": "latest",
      "address": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
      "topics": []
    }
  ]
}

`eth_uninstallFilter`

Supported. Removes a previously installed filter by ID; returns true if it existed and was removed.Sei-specific behavior: Returns false if the filter did not exist rather than erroring. Filters also expire automatically when not polled.Parameters:

#	Name	Type	Description
1	`filterID`	QUANTITY/ID	Filter ID to remove.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_uninstallFilter",
  "params": [
    "0x1"
  ]
}

`eth_subscribe`

Limited. Opens a WebSocket-only push subscription for newHeads or logs notifications.Sei-specific behavior: WebSocket-only (SubscriptionAPI is not registered on the HTTP server; returns rpc.ErrNotificationsUnsupported over HTTP). Only ‘newHeads’ and ‘logs’ are implemented in source; there is no ‘newPendingTransactions’ subscription despite some client docs implying otherwise. newHeads subscriptions are capped by MaxSubscriptionsNewHead.Parameters:

#	Name	Type	Description
1	`subscriptionType`	string	Subscription name: ‘newHeads’ or ‘logs’.
2	`filter`	object	Optional filter criteria (address/topics) for the ‘logs’ subscription.

The filter object applies only to logs subscriptions. For newHeads, pass the subscription name alone: "params": ["newHeads"].Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_subscribe",
  "params": [
    "logs",
    {
      "address": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
      "topics": []
    }
  ]
}

`eth_unsubscribe`

Supported. Cancels an existing WebSocket subscription by ID; returns true on success.Sei-specific behavior: WebSocket only; has no effect over HTTP (notifications unsupported there).Parameters:

#	Name	Type	Description
1	`subscriptionID`	string	The subscription ID returned by a prior eth_subscribe call.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_unsubscribe",
  "params": [
    "0x9cef478923ff08bf67fde6c64013158d"
  ]
}

Simulation

`eth_call`

Supported. Executes a read-only message call against state without creating a transaction; supports state and block overrides.Sei-specific behavior: Gas is capped by RPCGasCap and execution time by RPCEVMTimeout; a fail-fast limiter may reject with ‘eth_call rejected due to rate limit: server busy’. Canonical EVM<->Sei address resolution uses eth_call to the addr precompile at 0x0000000000000000000000000000000000001004.Parameters:

#	Name	Type	Description
1	`args`	object	Call object (to, from, data/input, gas, gasPrice/maxFeePerGas, value).
2	`blockNrOrHash`	BLOCKNUMBER or DATA	Block number, tag, or hash. Defaults to latest.
3	`overrides`	object	Optional per-account state overrides (balance, code, nonce, state).
4	`blockOverrides`	object	Optional block-context overrides (number, time, coinbase).

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_call",
  "params": [
    {
      "to": "0x0000000000000000000000000000000000001004",
      "data": "0x0c3c20ed000000000000000000000000Da52B9E673d1f48FcD9916b3F606A136a8eA5e55"
    },
    "latest"
  ]
}

`eth_estimateGas`

Supported. Estimates the gas needed to execute a transaction.Sei-specific behavior: Bounded by RPCGasCap and protected by a fail-fast limiter. Block gas limit on Sei is 12.5M; parallel execution can cause estimates to vary slightly, so size gasLimit with a modest buffer.Parameters:

#	Name	Type	Description
1	`args`	object	Transaction call object.
2	`blockNrOrHash`	BLOCKNUMBER or DATA	Optional block number, tag, or hash; defaults to latest.
3	`overrides`	object	Optional state overrides.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_estimateGas",
  "params": [
    {
      "to": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
      "data": "0x18160ddd"
    },
    "latest"
  ]
}

`eth_estimateGasAfterCalls`

Limited. Estimates gas for a transaction after first applying a sequence of preceding calls against the same simulated state.Sei-specific behavior: Non-standard Sei/geth extension (not part of the standard Ethereum JSON-RPC spec). Same gas-cap and fail-fast-limiter behavior as eth_estimateGas.Parameters:

#	Name	Type	Description
1	`args`	object	The final call to estimate gas for.
2	`calls`	array of object	Ordered list of preceding calls applied before the estimate.
3	`blockNrOrHash`	BLOCKNUMBER or DATA	Optional block number, tag, or hash; defaults to latest.
4	`overrides`	object	Optional state overrides.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_estimateGasAfterCalls",
  "params": [
    {
      "to": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
      "data": "0x"
    },
    [],
    "latest"
  ]
}

`eth_createAccessList`

Supported. Generates an EIP-2930 access list (and gas used) for a transaction.Sei-specific behavior: Defaults to the pending block tag (matching geth). A VM error during simulation is surfaced in the result’s ‘error’ field rather than failing the RPC.Parameters:

#	Name	Type	Description
1	`args`	object	Transaction call object.
2	`blockNrOrHash`	BLOCKNUMBER or DATA	Optional block number, tag, or hash; defaults to pending.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "eth_createAccessList",
  "params": [
    {
      "to": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
      "data": "0x"
    },
    "pending"
  ]
}

Transaction pool

`txpool_content`

Limited. Returns the transactions currently in the pool, grouped by sender address and nonce into pending and queued buckets.Sei-specific behavior: Sei-specific simplification: every unconfirmed EVM tx from the CometBFT mempool is reported under ‘pending’ and ‘queued’ is always empty (no geth-style pending/queued nonce-gap distinction). The result set is truncated to the node’s MaxTxPoolTxs config, so it may not reflect the entire mempool.Parameters: none.

Debugging & tracing

`debug_traceTransaction`

Supported. Replays a transaction by hash and returns an execution trace using the configured tracer.Sei-specific behavior: HTTP-only (the debug namespace is not registered on the WebSocket server). Supports geth tracers (callTracer, prestateTracer, flatCallTracer, struct/opcode logger); callTracer/prestateTracer/flatCallTracer results are pre-baked/cached via TraceBaker. Requires trace-enabled/archive state for the target height. Subject to the max block lookback guard (max_trace_lookback_blocks): a request whose target block is older than the configured lookback is rejected with an error of the form block number X is beyond max lookback of Y. This guard now applies consistently across all debug_trace* endpoints, and such attempts increment the evmrpc_historical_debug_trace_attempts_total metric.Parameters:

#	Name	Type	Description
1	`hash`	DATA, 32 bytes	Transaction hash to trace.
2	`config`	object	Optional tracer config (tracer name, tracerConfig, timeout, reexec, disableStorage/Stack/Memory).

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "debug_traceTransaction",
  "params": [
    "0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060",
    {
      "tracer": "callTracer"
    }
  ]
}

`debug_traceBlockByNumber`

Supported. Traces all transactions in a block by number and returns per-transaction execution traces.Sei-specific behavior: HTTP-only. safe/finalized/latest are equivalent due to instant finality. Subject to the max_trace_lookback_blocks historical guard (see debug_traceTransaction).Parameters:

#	Name	Type	Description
1	`number`	BLOCKNUMBER	Block number or tag.
2	`config`	object	Optional tracer config.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "debug_traceBlockByNumber",
  "params": [
    "latest",
    {
      "tracer": "callTracer"
    }
  ]
}

`debug_traceBlockByHash`

Supported. Traces all transactions in a block by hash and returns per-transaction execution traces.Sei-specific behavior: HTTP-only. Subject to the max_trace_lookback_blocks historical guard (see debug_traceTransaction).Parameters:

#	Name	Type	Description
1	`hash`	DATA, 32 bytes	Block hash.
2	`config`	object	Optional tracer config.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "debug_traceBlockByHash",
  "params": [
    "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864",
    {
      "tracer": "callTracer"
    }
  ]
}

`debug_traceCall`

Supported. Executes and traces a call against a block’s state without creating a transaction.Sei-specific behavior: HTTP-only. Arbitrary geth tracer names pass through. Tracing on the pending block is not supported. Subject to the max_trace_lookback_blocks historical guard (see debug_traceTransaction).Parameters:

#	Name	Type	Description
1	`args`	object	Transaction call object.
2	`blockNrOrHash`	BLOCKNUMBER or DATA	Block number, tag, or hash.
3	`config`	object	Optional trace-call config (tracer name, state overrides, block overrides).

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "debug_traceCall",
  "params": [
    {
      "to": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
      "data": "0x70a08231"
    },
    "latest",
    {
      "tracer": "callTracer"
    }
  ]
}

`debug_traceStateAccess`

Limited. Sei extension that replays a transaction and returns its app/tendermint/receipt state-access traces.Sei-specific behavior: Sei-specific extension (not part of upstream go-ethereum’s debug namespace). HTTP-only and subject to historical-debug-trace availability guards. Subject to the max_trace_lookback_blocks historical guard (see debug_traceTransaction).Parameters:

#	Name	Type	Description
1	`hash`	DATA, 32 bytes	Transaction hash whose state accesses are returned.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "debug_traceStateAccess",
  "params": [
    "0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060"
  ]
}

`debug_traceTransactionProfile`

Limited. Sei extension that replays a transaction by hash and returns its execution trace alongside a detailed timing and store-access profile.Sei-specific behavior: Sei-specific extension (not part of upstream go-ethereum’s debug namespace). HTTP-only and subject to historical-debug-trace availability guards. In addition to the standard trace result, it returns a profile object breaking down where time was spent — total wall time, historical DB lookup time, and per-phase timings (transaction lookup, block load, historical tx replay, block-context build, tx prepare, execution, and trace-result assembly) — plus a per-module store access trace (reads, iterators with the keys they surfaced, and per-operation stats roll-ups). Per-tx caps bound the trace size: at most 16 iterators and 64 keys per iterator are retained per module, with overflow flagged via truncated. To run this method across a whole block range and generate aggregate reports, use the seidb trace-profile-report command. Subject to the max_trace_lookback_blocks historical guard (see debug_traceTransaction).Parameters:

#	Name	Type	Description
1	`hash`	DATA, 32 bytes	Transaction hash to trace and profile.
2	`config`	object	Optional tracer config (tracer name, tracerConfig, timeout, reexec, disableStorage/Stack/Memory).

The response result contains a trace field (the standard tracer output) and a profile object shaped as follows:

totalNanos — total wall-clock nanoseconds for the profiled trace.
historicalDbLookupNanos — nanoseconds spent in historical store lookups (get/has/iterator/iteratorNext).
otherNanos — remaining time not attributed to historical lookups or execution.
phases — per-phase timings: lookupTransactionNanos, loadBlockNanos, replayHistoricalTxsNanos, buildBlockContextNanos, prepareTxNanos, executionNanos, traceResultNanos.
store — per-module store access trace: modules (each with reads, has, iterators, and per-op stats) and top-level stats.

Example request:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "debug_traceTransactionProfile",
  "params": [
    "0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060",
    {
      "timeout": "60s"
    }
  ]
}

Example response (trimmed):

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "trace": { "...": "standard tracer output" },
    "profile": {
      "totalNanos": 18422119,
      "historicalDbLookupNanos": 10021554,
      "otherNanos": 8400565,
      "phases": {
        "lookupTransactionNanos": 310221,
        "loadBlockNanos": 902114,
        "replayHistoricalTxsNanos": 6114203,
        "buildBlockContextNanos": 421900,
        "prepareTxNanos": 188212,
        "executionNanos": 9873341,
        "traceResultNanos": 612128
      }
    }
  }
}

Sei Custom Endpoints

Sei extends the standard Ethereum JSON-RPC API with custom endpoints that enhance functionality for developers. These extensions enable better handling of cross-VM interactions, synthetic transactions, improved error reporting, and other Sei-specific features.

Deprecation Notice: All sei_* and sei2_* JSON-RPC methods are deprecated and scheduled for removal. Do not build new integrations on these endpoints. Use standard eth_* and debug_* methods instead.Access is controlled by the enabled_legacy_sei_apis setting under [evm] in app.toml. Only methods explicitly listed in this allowlist are available. Disabled methods return a standard JSON-RPC error (code -32601, data "legacy_sei_deprecated"). Allowed single-object calls pass through unchanged, with an optional Sei-Legacy-RPC-Deprecation HTTP response header signaling deprecation.Batch requests: JSON-RPC batches (a top-level JSON array) are handled by the gate rather than passed through wholesale. Only the allowed methods in the batch are forwarded to the inner handler as a filtered subset, and the inner responses are then merged back by matching each response’s JSON-RPC id. Disallowed methods yield the usual -32601 legacy deprecation error in their slot, and any batch element that is not a JSON object returns a JSON-RPC -32600 "Invalid Request" error in its slot — a malformed element no longer causes the whole batch body to bypass the gate and reach the inner handler.Per JSON-RPC 2.0, notifications — requests that fully omit the id member — do not produce a response entry, including within a batch. A request that includes "id": null is not a notification: null is a valid id, so the request receives a response like any other id. Only requests with no id member at all are treated as notifications and omitted from the batch response. As a result, the merged response array is not 1:1 with the request batch when notifications are present — it is ordered like the batch minus the notification slots. If a batch would produce no response objects at all (for example, an all-notification batch, or an empty result), the gateway returns an empty HTTP body with HTTP 200 rather than an empty JSON array ([]).

Legacy API Configuration

The enabled_legacy_sei_apis setting in app.toml controls which sei_* and sei2_* methods are accessible on the EVM HTTP endpoint. Default allowlist (enabled on seid init):

[evm]
enabled_legacy_sei_apis = [
  "sei_getSeiAddress",
  "sei_getEVMAddress",
  "sei_getCosmosTx",
]

To enable additional legacy methods, add them to this array. All other sei_* and sei2_* methods (including all sei2_* block methods) are disabled by default and must be explicitly enabled.

View all available legacy methods

sei_* methods:

Method	Description
`sei_getCosmosTx`	Get Cosmos transaction by EVM tx hash
`sei_getEvmTx`	Get EVM transaction by Cosmos tx hash
`sei_getTransactionErrorByHash`	Get error message for a failed transaction
`sei_getVMError`	Get VM error details for a transaction
`sei_getBlockByHash`	Get block by hash (includes synthetic txs)
`sei_getBlockByHashExcludeTraceFail`	Get block by hash, excluding untraceable txs — synthetic txs and ante-deferred stub transactions (correct-nonce ante failures such as insufficient funds/fee, whose stub receipts carry `EffectiveGasPrice == 0` and `GasUsed == 0`). Note this differs from the regular `eth_getBlockByHash`, which still includes these ante-failure stubs.
`sei_getBlockByNumber`	Get block by number (includes synthetic txs)
`sei_getBlockByNumberExcludeTraceFail`	Get block by number, excluding untraceable txs — synthetic txs and ante-deferred stub transactions (correct-nonce ante failures such as insufficient funds/fee, whose stub receipts carry `EffectiveGasPrice == 0` and `GasUsed == 0`). Note this differs from the regular `eth_getBlockByNumber`, which still includes these ante-failure stubs.
`sei_getBlockReceipts`	Get block receipts (includes synthetic txs)
`sei_getBlockTransactionCountByHash`	Get tx count by block hash (includes synthetic txs)
`sei_getBlockTransactionCountByNumber`	Get tx count by block number (includes synthetic txs)
`sei_getTransactionByBlockHashAndIndex`	Get tx by block hash and index (includes synthetic txs)
`sei_getTransactionByBlockNumberAndIndex`	Get tx by block number and index (includes synthetic txs)
`sei_getTransactionByHash`	Get transaction by hash (includes synthetic txs)
`sei_getTransactionCount`	Get account transaction count
`sei_getTransactionReceipt`	Get transaction receipt (includes synthetic txs)
`sei_getTransactionReceiptExcludeTraceFail`	Get transaction receipt, excluding txs that never executed opcodes in the VM. The filter keys off the receipt shape (`EffectiveGasPrice == 0` and `GasUsed == 0`), which covers ante-rejected txs, nonce-bumping state-transition failures (for example EIP-7623 floor-data-gas shortfalls, whose synthetic EndBlock receipts carry the same shape), and chain-generated synthetic txs (`ShellEVMTxType`); reverted and out-of-gas transactions are included, because they ran in the VM and produce real traces. (Previously any receipt with `status=0` was excluded, which over-filtered reverts and OOG failures.) The former `sei_traceBlockByHashExcludeTraceFail`/`sei_traceBlockByNumberExcludeTraceFail` trace endpoints were removed in v6.6.0 (#3618); use the standard `debug_traceBlockByHash`/`debug_traceBlockByNumber` instead.
`sei_getFilterLogs`	Get filter logs (includes synthetic logs)
`sei_getLogs`	Get logs (includes synthetic logs)
`sei_getFilterChanges`	Get filter changes (includes synthetic events)
`sei_newFilter`	Create a new log filter
`sei_newBlockFilter`	Create a new block filter
`sei_uninstallFilter`	Remove a filter

sei_traceBlockByHashExcludeTraceFail and sei_traceBlockByNumberExcludeTraceFail were removed in v6.6.0 (#3618) and no longer appear in the gated method list; adding them to enabled_legacy_sei_apis has no effect. Use debug_traceBlockByHash/debug_traceBlockByNumber instead.

sei2_* methods (block queries with bank transfers included):

Method	Description
`sei2_getBlockByHash`	Get block by hash (includes bank transfers)
`sei2_getBlockByNumber`	Get block by number (includes bank transfers)
`sei2_getBlockReceipts`	Get block receipts (includes bank transfers)
`sei2_getBlockTransactionCountByHash`	Get tx count by block hash (includes bank transfers)
`sei2_getBlockTransactionCountByNumber`	Get tx count by block number (includes bank transfers)
`sei2_getBlockByHashExcludeTraceFail`	Get block by hash excluding failed traces (includes bank transfers)
`sei2_getBlockByNumberExcludeTraceFail`	Get block by number excluding failed traces (includes bank transfers)

Address Resolution

For resolving the EVM (0x…) ↔ Sei (sei1…) address pair, use the addr precompile at 0x0000000000000000000000000000000000001004 via a standard eth_call. The precompile is universally available on every Sei RPC, is not part of the deprecated sei_* namespace, and is the canonical resolution path going forward.

# EVM → Sei (getSeiAddr(address), selector 0x0c3c20ed)
curl -X POST $SEIEVM -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "method": "eth_call",
  "params": [{
    "to": "0x0000000000000000000000000000000000001004",
    "data": "0x0c3c20ed000000000000000000000000<evmAddressWithout0x>"
  }, "latest"],
  "id": 1
}'

In TypeScript with viem:

import { createPublicClient, http } from 'viem';
import { sei } from 'viem/chains';

const ADDR_PRECOMPILE = '0x0000000000000000000000000000000000001004';
const ADDR_ABI = [
  { name: 'getSeiAddr', type: 'function', stateMutability: 'view',
    inputs: [{ name: 'addr', type: 'address' }],
    outputs: [{ name: 'response', type: 'string' }] },
  { name: 'getEvmAddr', type: 'function', stateMutability: 'view',
    inputs: [{ name: 'addr', type: 'string' }],
    outputs: [{ name: 'response', type: 'address' }] },
] as const;

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

const seiAddr = await client.readContract({
  address: ADDR_PRECOMPILE, abi: ADDR_ABI, functionName: 'getSeiAddr', args: ['0x…'],
});

const evmAddr = await client.readContract({
  address: ADDR_PRECOMPILE, abi: ADDR_ABI, functionName: 'getEvmAddr', args: ['sei1…'],
});

The call reverts when the input address is not yet associated. See Accounts for the full association lifecycle and how the bidirectional mapping is established.

The legacy JSON-RPC helpers sei_getSeiAddress and sei_getEVMAddress historically served this role and are still enabled by default on nodes today, but they belong to the deprecated sei_* namespace and may be removed in a future release. New integrations should call the precompile.

Cross-VM Transaction Lookup

sei_getCosmosTx resolves the underlying Cosmos transaction hash for a given EVM transaction. It does not yet have a precompile equivalent and is enabled by default on Sei nodes.

View Cross-VM Lookup Endpoints

sei_getCosmosTx

Returns the Cosmos transaction details for a given EVM transaction hash.

Parameters:

Type	Description
`string`	The EVM transaction hash.

Result:

Type	Description
`object`	The Cosmos transaction object.

Example Request

{
  "jsonrpc": "2.0",
  "method": "sei_getCosmosTx",
  "params": ["0xabc123..."],
  "id": 1
}

Legacy Deprecation Error

When a sei_* or sei2_* method is called but not listed in enabled_legacy_sei_apis, the node returns:

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32601,
    "message": "sei_getBlockByNumber is not enabled on this node. The sei_* and sei2_* JSON-RPC surfaces are deprecated, scheduled for removal, and should not be used for new integrations - prefer standard eth_* (and debug_*) methods and official migration guidance. To allow this legacy method, add it to enabled_legacy_sei_apis under [evm] in app.toml.",
    "data": "legacy_sei_deprecated"
  }
}

Deprecation HTTP Header

When an allowlisted sei_* or sei2_* method is successfully called, the response includes an optional HTTP header signaling deprecation:

Sei-Legacy-RPC-Deprecation: All sei_* and sei2_* JSON-RPC methods are deprecated and scheduled for removal; migrate to eth_* and supported APIs.

Clients can use this header to detect legacy API usage and plan migration.

​Overview

​Network endpoints

​Tendermint /status endpoint

​Tendermint block and validator endpoints under Autobahn

​Filter and subscription limits

​Standard Ethereum endpoints

​eth_sendRawTransaction

​eth_sendTransaction

​eth_signTransaction

​eth_sign

​eth_getTransactionByHash

​eth_getTransactionReceipt

​eth_getTransactionByBlockNumberAndIndex

​eth_getTransactionByBlockHashAndIndex

​eth_getTransactionCount

​eth_getNonce

​eth_getTransactionErrorByHash

​eth_getVMError

​eth_getBalance

​eth_getCode

​eth_getStorageAt

​eth_getProof

​eth_accounts

​eth_getBlockByNumber

​eth_getBlockByHash

​eth_getBlockTransactionCountByNumber

​eth_getBlockTransactionCountByHash

​eth_getBlockReceipts

​eth_blockNumber

​eth_chainId

​eth_coinbase

​eth_gasPrice

​eth_maxPriorityFeePerGas

​eth_feeHistory

​net_version

​web3_clientVersion

​eth_newFilter

​eth_newBlockFilter

​eth_getFilterChanges

​eth_getFilterLogs

​eth_getLogs

​eth_uninstallFilter

​eth_subscribe

​eth_unsubscribe

​eth_call

​eth_estimateGas

​eth_estimateGasAfterCalls

​eth_createAccessList

​txpool_content

​debug_traceTransaction

​debug_traceBlockByNumber

​debug_traceBlockByHash

​debug_traceCall

​debug_traceStateAccess

​debug_traceTransactionProfile

​Sei Custom Endpoints

​Legacy API Configuration

​Address Resolution

​Cross-VM Transaction Lookup

​sei_getCosmosTx

​Legacy Deprecation Error

​Deprecation HTTP Header

Overview

Network endpoints

Tendermint `/status` endpoint

Tendermint block and validator endpoints under Autobahn

Filter and subscription limits

Standard Ethereum endpoints

`eth_sendRawTransaction`

`eth_sendTransaction`

`eth_signTransaction`

`eth_sign`

`eth_getTransactionByHash`

`eth_getTransactionReceipt`

`eth_getTransactionByBlockNumberAndIndex`

`eth_getTransactionByBlockHashAndIndex`

`eth_getTransactionCount`

`eth_getNonce`

`eth_getTransactionErrorByHash`

`eth_getVMError`

`eth_getBalance`

`eth_getCode`

`eth_getStorageAt`

`eth_getProof`

`eth_accounts`

`eth_getBlockByNumber`

`eth_getBlockByHash`

`eth_getBlockTransactionCountByNumber`

`eth_getBlockTransactionCountByHash`

`eth_getBlockReceipts`

`eth_blockNumber`

`eth_chainId`

`eth_coinbase`

`eth_gasPrice`

`eth_maxPriorityFeePerGas`

`eth_feeHistory`

`net_version`

`web3_clientVersion`

`eth_newFilter`

`eth_newBlockFilter`

`eth_getFilterChanges`

`eth_getFilterLogs`

`eth_getLogs`

`eth_uninstallFilter`

`eth_subscribe`

`eth_unsubscribe`

`eth_call`

`eth_estimateGas`

`eth_estimateGasAfterCalls`

`eth_createAccessList`

`txpool_content`

`debug_traceTransaction`

`debug_traceBlockByNumber`

`debug_traceBlockByHash`

`debug_traceCall`

`debug_traceStateAccess`

`debug_traceTransactionProfile`

Sei Custom Endpoints

Legacy API Configuration

Address Resolution

Cross-VM Transaction Lookup

sei_getCosmosTx

Legacy Deprecation Error

Deprecation HTTP Header