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.

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 (async BroadcastTx 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.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 read from the CometBFT mempool (not a geth txpool) via a direct EVM-hash index lookup rather than scanning paginated unconfirmed-tx pages, so pending transactions are resolved efficiently by hash. 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. If a receipt exists but its block height is above the safe-latest watermark (e.g. the CometBFT status momentarily lags the receipt store by a block), the method returns JSON null — the Ethereum JSON-RPC ‘not yet mined’ signal — rather than an error, so clients simply poll again. This matches the behavior of eth_getBlockByNumber for blocks above the watermark.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 tree, not an Ethereum Merkle-Patricia trie. 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. The EVM store is resolved by unwrapping any wrapping KVStore layers (cachekv, Giga cache, tracekv, and prefix stores) to reach the underlying proof-capable queryable store, so proofs succeed across more node/store configurations (classic IAVL, store/v2 memiavl, and future proof-capable roots) rather than only the classic IAVL store.Storage key validation: Each entry in storageKeys must be a valid hex-encoded value (0x-prefixed); it is decoded and left-padded to 32 bytes. Raw non-hex byte strings are no longer accepted — a malformed key is rejected with an invalid storage key error. A request may include at most 1024 storage keys (MaxStorageKeysPerProof); exceeding this returns a too many storage keys error.Parameters:

#	Name	Type	Description
1	`address`	DATA, 20 bytes	Account address.
2	`storageKeys`	array of DATA, 32 bytes	Hex-encoded storage slot keys to prove; each is decoded and left-padded to 32 bytes. Malformed (non-hex) keys are rejected with `invalid storage key`. At most 1024 keys per request (`MaxStorageKeysPerProof`); exceeding returns `too many storage keys`.
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 hash returns a synthetic genesis block; unknown/zero hash returns 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 transactions in a block by number, as a hex quantity.Sei-specific behavior: The count now matches the transaction list returned by eth_getBlockByNumber: EVM transactions are counted only when their receipt lookup succeeds (EVM txs without a valid receipt are excluded), and MsgExecuteContract (wasm) and MsgSend (bank transfer) messages are included. Previously this counted all decodable EVM txs regardless of receipt. Genesis returns 0x0; non-existent/future blocks return null.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. If the block’s receipts have been pruned from the receipt store — which can happen when the receipt store is configured with a smaller KeepRecent than the block/state stores — the method returns an error of the form requested height X receipts have been pruned; earliest available is Y instead of a count.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; zero hash returns null. 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, not an Ethereum EIP-1559 mempool, and Sei does not burn the base fee. Each block’s base fee is the block-header base fee (derived from GetNextBaseFee at the parent committed height), matching the value reported by the block header and transactions. Following the execution-apis/go-ethereum spec, baseFeePerGas contains one more element than gasUsedRatio (len(baseFeePerGas) == len(gasUsedRatio) + 1): the trailing element is the projected base fee for the child of the newest block in the requested range. Watermark-aware: pruned/historical blocks may not be available as far back as on Ethereum archive nodes, and heights that lack a header base fee (pruned or partial data) are skipped.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.

`status` (CometBFT RPC)

Supported. The underlying CometBFT /status RPC endpoint returns node info, validator info, and a sync_info object describing block-sync state. It is exposed on the Tendermint RPC port (not the EVM JSON-RPC endpoint).Sei-specific behavior: The sync_info object now includes an additional field, last_committed_block_height — the height of the last block finalized by consensus, serialized as a JSON string-encoded int64. Under standard CometBFT consensus this always equals latest_block_height, because a block’s commit and app-apply happen in a single step. Under Autobahn consensus the two can briefly differ: consensus finalizes a block (advancing last_committed_block_height, derived from the latest CommitQC) before the app executes it, so the invariant is last_committed_block_height >= latest_block_height.

Autobahn /status behavior. When a node runs under Autobahn (i.e. AutobahnConfigFile is set), the CometBFT block store is not populated, so /status derives latest_block_height and latest_app_hash from the app layer (via ABCIInfo) instead of the block store. Several other sync_info fields remain unpopulated under Autobahn and should not be relied on: latest_block_hash, latest_block_time, the earliest_* fields, and max_peer_block_height; catching_up is currently hardcoded to true.Block-data endpoints are now served under Autobahn by routing through the GigaRouter’s in-memory state (data.State) instead of the unpopulated CometBFT block store, though with some limitations:

/block returns the translated finalized block at the requested height (BlockID.Hash, ChainID, Height, Time, and Data.Txs are populated; fields such as AppHash, ProposerAddress, and LastCommit stay at zero values).
/block_by_hash resolves by hash for heights within the retain window; hashes below the pruning watermark or otherwise unknown return an empty block ({Block: nil}) with no error, matching CometBFT semantics.
/block_results returns the requested height with ConsensusParamUpdates.Block.MaxGas populated from the genesis consensus_params.block.max_gas (the same gas-limit value the producer’s MaxGasPerBlock is derived from), but TxsResults is intentionally empty because FinalizeBlock responses are not persisted under Autobahn (no per-tx ExecTxResult details).

Note: eth_getBlockByNumber’s gasLimit field is sourced from the active consensus params in the SDK context (ctx.ConsensusParams().Block.MaxGas) rather than from blockRes.ConsensusParamUpdates. This means the reported gasLimit matches the value the EVM runtime returns for the GASLIMIT opcode, and stays consistent under Autobahn where /block_results only synthesizes a placeholder.

/validators returns the genesis committee for any retained height, with block_height matching the requested height (fixing the prior behavior where it could report a stale/stuck height).

EVM endpoints that walk through these (e.g. eth_getBlockByNumber) therefore work under Autobahn, rendering the block envelope correctly — just without per-tx result details from /block_results. /commit remains unpopulated under Autobahn.

`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, an empty array ([]) is returned instead of null when there are no matching logs — including once a bounded filter (one created with a blockHash or a toBlock) has had its range fully consumed. This aligns with the Ethereum JSON-RPC spec, which always expects an array result.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.Under Autobahn consensus (i.e. when AutobahnConfigFile is set), newHeads notifications are delivered by an in-process notifier that publishes committed-block headers after a successful Commit, rather than through the CometBFT event bus used by the legacy path. Subscribers therefore observe only committed state, but the header payloads differ from the legacy encoding: parentHash, receiptsRoot, and transactionsRoot are returned as the zero hash (Autobahn does not compute a Tendermint-style hash chain), stateRoot is sourced from the finalized block’s post-execution AppHash, and hash is the Autobahn block-header hash. gasUsed is an approximation (summed over transaction results); subscribers needing exact gas or the omitted header fields should query eth_getBlockByNumber. Under Autobahn, on consumer lag the latest head wins (overwrite-on-full) and intermediate heads may be dropped, and subscribers that chain-validate the head stream will need a different mechanism.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: requests targeting a block older than the node’s configured maxBlockLookback (resolved from the transaction’s receipt block number) are rejected with block number N is beyond max lookback of M.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. When no custom tracer is specified (the default struct/opcode logger), block traces can run through a parallelized, profiled execution path that returns per-transaction result/error entries, but only when the node has evm.enable_parallelized_block_trace = true set in app.toml (default false). On that path, a transaction that fails no longer aborts the whole block trace — its entry carries an error field while the remaining transactions still return their traces. When evm.enable_parallelized_block_trace is false (the default), or when a custom tracer (e.g. callTracer) is specified, block traces use the standard tracing path instead.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.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.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.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 (the debug namespace is not registered on the WebSocket server) and subject to historical-debug-trace/archive availability guards for the target height. The response is an object with two fields: trace (the standard trace produced by the configured tracer, identical to debug_traceTransaction) and profile (timing and KVStore access instrumentation collected while replaying the tx). The profile object reports totalNanos (end-to-end profiling time), historicalDbLookupNanos (time spent in historical DB reads — the sum of get/has/iterator/iteratorNext store latencies), otherNanos (remaining time), a phases object with per-phase timings (lookupTransactionNanos, loadBlockNanos, replayHistoricalTxsNanos, buildBlockContextNanos, prepareTxNanos, executionNanos, traceResultNanos), and a store object with per-module access statistics under store.modules.<module>.stats (each op maps to {count, totalNanos}) plus per-module iterators samples (bounds, direction, surfaced keys, nextCount, and cumulative timing). Iterator and key samples are capped per module to bound response size. To batch-run this method across a block range, see the seidb trace-profile-report command.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).

Example request:

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

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 requests pass through unchanged, with an optional Sei-Legacy-RPC-Deprecation HTTP response header signaling deprecation.JSON-RPC batch requests over HTTP are handled element-by-element: only allowlisted methods are forwarded to the inner handler as a filtered subset, and their responses are merged back by JSON-RPC id. Disabled methods in the batch receive the standard -32601 gate error in place, and any non-object batch element returns a JSON-RPC -32600 Invalid Request without being forwarded — so a malformed element can never bypass the gate. Batch responses follow JSON-RPC 2.0 semantics: only notification requests — those that omit the id member entirely — produce no response entry, so the merged response array is not necessarily 1:1 with the request batch when notifications are present. A request with an explicit "id": null is not a notification; it receives a response like any other request. If a batch would yield no response objects at all, the gateway returns an empty HTTP body rather than an empty JSON array ([]), which JSON-RPC 2.0 forbids. The legacy HTTP request body limit is 5 MiB (matching go-ethereum’s default).

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_getBlockByNumber`	Get block by number (includes synthetic txs)
`sei_getBlockByHashExcludeTraceFail`	Get block by hash, excluding untraceable txs — synthetic txs and ante-deferred stub txs (those that bumped their nonce in ante but never reached the VM, e.g. insufficient funds/fee, identified by `EffectiveGasPrice == 0 && GasUsed == 0`). Note that the regular `eth_getBlockBy`/`sei_getBlockBy` endpoints still surface these stub txs; only the `ExcludeTraceFail` variants drop them.
`sei_getBlockByNumberExcludeTraceFail`	Get block by number, excluding untraceable txs — synthetic txs and ante-deferred stub txs (those that bumped their nonce in ante but never reached the VM, e.g. insufficient funds/fee, identified by `EffectiveGasPrice == 0 && GasUsed == 0`). Note that the regular `eth_getBlockBy`/`sei_getBlockBy` endpoints still surface these stub txs; only the `ExcludeTraceFail` variants drop them.
`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_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_getBlockByHashExcludeTraceFail`	Get block by hash, excluding only untraceable txs (ante-rejected and synthetic); reverts/OOG are included
`sei_getBlockByNumberExcludeTraceFail`	Get block by number, excluding only untraceable txs (ante-rejected and synthetic); reverts/OOG are included
`sei_getTransactionReceiptExcludeTraceFail`	Get receipt, excluding only untraceable txs (ante-rejected and synthetic); reverts/OOG are included
`sei_traceBlockByHashExcludeTraceFail`	Trace block by hash, excluding only untraceable txs (ante-rejected and synthetic); reverts/OOG are included
`sei_traceBlockByNumberExcludeTraceFail`	Trace block by number, excluding only untraceable txs (ante-rejected and synthetic); reverts/OOG are included

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

​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

​status (CometBFT RPC)

​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

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`

`status` (CometBFT RPC)

`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