Sei EVM JSON-RPC API Reference

Sei fully supports the standard Ethereum JSON-RPC API, so existing EVM tools (ethers.js, viem, Hardhat, Foundry, and others) work without changes. Use the explorer below to browse every method that Sei exposes and inspect its parameters. You can also run requests against a live endpoint and copy ready-to-use snippets in a range of popular languages. The text below the explorer is the authoritative reference for the request format, the remaining deprecated sei_* extensions, and address resolution.

By default, the explorer lists only the current methods that are available. Each method has one of three status labels:

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

By default, the explorer hides the remaining deprecated sei_* extensions and the unavailable methods. To browse them, enable Show deprecated & unavailable methods. The deprecated extensions are also documented under Sei custom endpoints.

Overview

Sei supports the Ethereum JSON-RPC API. It also has some Sei-specific extensions for 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 (for example, eth_sendRawTransaction)
- params: an array that differs from endpoint to endpoint

Response format

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

Network endpoints

Network	EVM chain ID	HTTP endpoint	WebSocket endpoint
Sei Mainnet	`1329` (`0x531`)	`https://evm-rpc.sei-apis.com`	`wss://evm-ws.sei-apis.com`
Sei Testnet	`1328` (`0x530`)	`https://evm-rpc-testnet.sei-apis.com`	`wss://evm-ws-testnet.sei-apis.com`

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

Tendermint `/status` endpoint

In addition to 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 serialized to JSON as a string (last_committed_block_height), like 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. Consensus finalizes a block before the app executes it, so the invariant is last_committed_block_height >= latest_block_height. The two values can differ for a short time while the app catches up.

validator_info shape. The validator_info object in the /status response always includes both a pub_key and an address field. On nodes that are not validators, the response does not omit these fields. Instead, pub_key is a zero (empty) public key, address is derived from it, and voting_power is 0. This keeps the response shape stable, so clients like CosmJS can parse /status without special handling for 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. For this reason, /status derives latest_block_height and latest_app_hash from the app layer (ABCIInfo), not from the block store. Several other SyncInfo fields are also not populated in this mode: block hash and time, earliest-block metadata, catching_up, and the peer-height fields.

Tendermint block and validator endpoints under Autobahn

Under Autobahn (AutobahnConfigFile set), the CometBFT BlockStore and StateStore are not populated. These Tendermint RPC endpoints do not return empty or failing responses in this mode. Instead:

/block and /block_by_hash route through the GigaRouter’s in-memory state (the finalized global blocks that the Autobahn data layer retains).
/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 tools, working without each one branching on the consensus engine. /block and /block_by_hash serve responses only for heights that are 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. They 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. 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, such as `AppHash`, `ProposerAddress`, and `LastCommit`, stay at zero values.
`/block_by_hash`	Resolves the block by its Autobahn header hash through an in-memory hash index. An unknown or wrong-size hash returns `{Block: nil}` with no error. This matches 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-transaction `ExecTxResult` details) is empty on purpose, because `FinalizeBlock` responses are not persisted under Autobahn.
`/validators`	Returns the genesis committee for any height up to the current ABCI head. Under Autobahn, the committee is fixed at genesis (there is no validator-updates path). The endpoint does not read the retained block data, so pruned heights still answer. `block_height` matches the requested height. Pagination (`page` and `per_page`) behaves the same as on the CometBFT path.

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

Filter and subscription limits

By default, log filters (eth_getLogs, eth_getFilterLogs) have these limits:

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

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

Standard Ethereum endpoints

You can also browse every method below in the interactive explorer above. This section is the static, copy-friendly reference. Methods are grouped by purpose and labeled 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 because of instant finality. The remaining deprecated sei_* 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 the bytes to an ethtypes.Transaction, wraps it in a Cosmos MsgEVMTransaction, and broadcasts it through CometBFT. By default, it uses a CheckTx-level BroadcastTx (that is, broadcast_tx_sync), and slow mode uses BroadcastTxCommit. Non-zero CheckTx codes are returned as ABCI errors, not geth mempool errors. Legacy (non-1559) transactions must set gasPrice at or above the governance minimum (currently 50 gwei on Sei Mainnet). Blob (EIP-4844) transactions are not enabled. The method 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 nonce order for each sender. It rejects a transaction with a bad-nonce error if its nonce does not match the sender’s next expected nonce. Senders must therefore submit nonces contiguously.Under Autobahn, the default CheckTx-synchronous broadcast (broadcast_tx_sync, the same path named above) blocks while the mempool is full. It returns only after capacity is available. As a result, a default eth_sendRawTransaction call can stall for as long as the mempool stays full. 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 a transaction with a node-hosted key and submits it in one call.Sei-specific behavior: Requires the private key of the ‘from’ address in the node’s local test keyring. Production and public RPC nodes hold no hosted keys, so on those nodes this method 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, and other fields).

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 it.Sei-specific behavior: Requires a node-hosted key for the from address. It does not work on public RPC nodes that hold no keys. Returns both the raw RLP bytes and the decoded transaction.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: Works only for addresses in the node’s local test keyring. Production and public RPC nodes hold no hosted keys, so on those nodes this method 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 that matches the given hash, or null if it is not found.Sei-specific behavior: Looks up EVM transactions only. If the hash resolves to a non-EVM Cosmos transaction, the method returns an error. Pending lookups resolve the transaction directly from the CometBFT mempool through an EVM-hash index, not a geth txpool. As a result, the method finds a pending EVM transaction by its hash without scanning through pages of unconfirmed transactions.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 it is not found.Sei-specific behavior: The receipt is reconstructed from keeper.GetReceipt and CometBFT block data, not from a native MPT receipt trie. The status and logs use the standard Ethereum format.Under the Giga executor, an EVM transaction can bump the sender’s nonce and then fail during state transition. For such a transaction, the method returns a status=0 failed-transaction receipt. It does not return null indefinitely, which would hang clients that poll for the receipt. 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. This synthetic receipt is written at EndBlock, with gasUsed and effectiveGasPrice of 0.The VmError reason is not part of the eth_getTransactionReceipt response. To get it, use the non-standard eth_getVMError method.If a receipt exists but its block height is above the safe-latest watermark, the method returns JSON null rather than an error. This can happen, for example, when the Tendermint status lags the receipt store for a moment. JSON null is the Ethereum JSON-RPC ‘not yet mined’ signal, so clients poll again. This matches the behavior of eth_getBlockByNumber.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: The index counts EVM transactions only. An out-of-range index returns a null result, not 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: The index counts EVM transactions only. As with the block-number variant, an out-of-range index returns null.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. If the sender is sharded to an EvmProxy, Sei redirects the request there. The safe, finalized, and latest tags are equivalent because of instant finality.Parameters:

#	Name	Type	Description
1	`address`	DATA, 20 bytes	Account address.
2	`blockNrOrHash`	BLOCKNUMBER or DATA	Block number, tag, or hash. The ‘pending’ tag 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: This non-standard Sei extension is exposed as eth_getNonce and implemented as StateAPI.GetNonce in state.go (not on TransactionAPI). Unlike eth_getTransactionCount, it takes no block tag (latest only, through ctxProvider(LatestCtxHeight)) and returns a bare uint64. For standard nonce queries, prefer eth_getTransactionCount.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: This non-standard Sei extension is registered under the eth namespace. Unlike eth_getVMError, this method returns an empty string and no error for a not-found lookup.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: This non-standard Sei extension is registered under the eth namespace. It returns the receipt’s VmError field and propagates a not-found error. In contrast, eth_getTransactionErrorByHash returns an empty string when the transaction is 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: The balance reflects the account’s SEI bank balance (18-decimal wei representation). Both EVM and non-EVM transactions (Cosmos bank send or wasm) can change it. The height is resolved through 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 slot value directly from the EVM keeper, not 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). It continues until it reaches an underlying proof-capable queryable store: classic IAVL, a store/v2 memiavl commitment, or any other proof-capable root. Proofs therefore work across these backends, not only on classic IAVL. If the handler cannot reach a proof-capable queryable store, it returns cannot find a proof-capable queryable KV store.The result is a Sei-specific ProofResult{address, hexValues, storageProof}. Its storageProof entries are CometBFT/IAVL crypto.ProofOps, not eth-style MPT proof nodes. The result has no accountProof, balance, codeHash, nonce, or storageHash field (Sei has no per-account state root). Standard eth_getProof verifiers do not work with it.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: The list comes only from the node’s local test keyring. Production and public RPC nodes hold no hosted keys, so on those nodes this method 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 and bank-transfer transactions are excluded. Block number 0 returns a synthetic genesis block, for compatibility with The Graph. Future or non-existent numeric blocks return null. Uncle and PoW header fields (sha3Uncles, nonce, mixHash, difficulty) are placeholders, and the uncles array is always empty (CometBFT consensus). The safe, finalized, and latest tags are equivalent because of instant finality.Parameters:

#	Name	Type	Description
1	`number`	BLOCKNUMBER	Block number (hex) or tag (latest/safe/finalized/pending/earliest).
2	`fullTx`	boolean	If true, the block includes full transaction objects. Otherwise, it includes 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. They differ from Ethereum block hashes and are not interchangeable across chains. Under the eth namespace, synthetic transactions and bank transfers are excluded. The uncles array is always empty.The genesis block hash is 0xF9D3845DF25B43B1C6926F3CEDA6845C17F5624E12212FD8847D0BA01DA1AB9E. It is a synthetic constant, identical on every Sei network. The node returns it in this uppercase form, and lookups are case-insensitive. The method recognizes this hash and returns the encoded genesis block directly. This keeps hash-based lookups consistent with eth_getBlockByNumber("0x0"). Other unknown or zero hashes return null.Parameters:

#	Name	Type	Description
1	`blockHash`	DATA, 32 bytes	Block hash.
2	`fullTx`	boolean	If true, the block includes full transaction objects. Otherwise, it includes 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 the transaction list of eth_getBlockByNumber. EVM transactions are counted only when a receipt exists for them. Synthetic (wasm MsgExecuteContract) and bank-transfer (MsgSend) transactions remain excluded. Genesis returns 0x0. Non-existent or future blocks return null.The receipt store can be configured with a smaller KeepRecent than the block and state stores. For this reason, the method verifies that the requested block’s receipts have not been pruned before it counts. If they have, it returns an error of the form requested height N receipts have been pruned; earliest available is M instead of a count. As a result, 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 and bank-transfer transactions are excluded. The genesis hash returns 0x0, and an unknown hash returns null. Like eth_getBlockTransactionCountByNumber, it returns a “receipts have been pruned” error if 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 and shell receipts are excluded (includeShellReceipts=false). Genesis returns an empty array. An empty (zero), non-existent, or unknown block hash returns result: null instead of an error. This matches the Ethereum RPC spec. The transactionIndex value 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: The block height comes from the latest CometBFT 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: The value comes from the x/evm keeper. Sei Mainnet is 1329 (0x531), and Sei Testnet is 1328 (0x530).Parameters: none.

`eth_coinbase`

Limited. Returns the block reward beneficiary (coinbase) address.Sei-specific behavior: Sei has no miner. This method returns the Cosmos fee-collector module address (GetFeeCollectorAddress), not a validator or 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: The method uses a Sei-specific congestion heuristic, not a raw mempool oracle. The logic is in InfoAPI.GasPrice and GasPriceHelper (info.go). When the chain is uncongested, the method returns baseFee * 110/100 (base fee +10%). When the chain is congested, it returns medianRewardPrevBlock + baseFee. This is the 50th-percentile priority-fee reward from the previous block, added to the base fee.The base fee comes from the x/evm keeper (GetNextBaseFeePerGas) and is itself floored at the governance-set minimum base fee. The RPC handler applies no other explicit lower-bound clamp. The Sei Mainnet minimum gas price (approximately 50 gwei) is enforced for transaction acceptance at the mempool or 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: When the chain is uncongested, the method returns a hardcoded 1 gwei (defaultPriorityFeePerGas). It derives the tip from the previous block’s 50th-percentile reward only when the chain is congested. The Sei docs advise you to use a single gasPrice and omit the 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. Sei does not burn the base fee. The method is watermark-aware: pruned or historical blocks may not be available as far back as on Ethereum archive nodes.On ranges where every block has base-fee data, baseFeePerGas contains one more element than gasUsedRatio. This matches go-ethereum and execution-apis semantics. The trailing element is the projected base fee for the child of the newest block in the range. It is appended only when the newest block’s own header base fee was available.Heights with pruned or partial base-fee data are skipped in baseFeePerGas, but they still contribute a gasUsedRatio row (0.0 fallback). On ranges with pruned history, the two arrays can therefore diverge from that +1 relationship. Each block’s base fee uses header base fee semantics. That is the same value that the block header reports: GetNextBaseFee at the parent’s committed height. For early blocks, the base fee falls back to DefaultMinFeePerGas.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 ID (chain ID) as a decimal string.Sei-specific behavior: Returns the EVM chain ID in decimal (an alias of eth_chainId): '1329' on Sei Mainnet and '1328' on Sei 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). The string does not include the actual sei-chain or 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: Has the same range and 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), and large queries are rate-limited.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, the method returns an empty array ([]) instead of null when no logs match. It does the same when a bounded filter’s block range has been fully consumed. This is 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 that match a previously created log filter, including historical logs.Sei-specific behavior: Has the same caps as eth_getLogs (2,000-block range, 10,000-log limit). Large queries are rate-limited.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 the logs that match the given filter criteria.Sei-specific behavior: Returns EVM logs only. The hard limits are a maximum of 2,000 blocks per close-ended query and up to 10,000 logs per response. A query that exceeds the range limit fails with ‘block range too large’. Large queries are rate-limited globally.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 the filter existed and was removed.Sei-specific behavior: Returns false, not an error, if the filter did not exist. Filters also expire automatically when they are 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: Available over WebSocket only. SubscriptionAPI is not registered on the HTTP server, so over HTTP the method returns rpc.ErrNotificationsUnsupported. Only ‘newHeads’ and ‘logs’ are implemented in source. There is no ‘newPendingTransactions’ subscription, although some client docs imply otherwise. MaxSubscriptionsNewHead caps newHeads subscriptions.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: Available over WebSocket only. It has no effect over HTTP, where notifications are not supported.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 is capped by RPCEVMTimeout. A fail-fast limiter may reject the call 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: The method is bounded by RPCGasCap and protected by a fail-fast limiter. The block gas limit on Sei is 12.5M. Parallel execution can make estimates vary slightly, so set 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 it applies a sequence of preceding calls to the same simulated state.Sei-specific behavior: This is a non-standard Sei/geth extension (not part of the standard Ethereum JSON-RPC spec). It has the 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, as geth does. If a VM error occurs during simulation, the method reports it in the result’s ‘error’ field instead of 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: As a simplification, the method reports every unconfirmed EVM transaction from the CometBFT mempool under ‘pending’. The ‘queued’ bucket is always empty (there is no geth-style nonce-gap distinction between pending and queued). 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 from the configured tracer.Sei-specific behavior: Available over HTTP only, because the debug namespace is not registered on the WebSocket server. Supports geth tracers: callTracer, prestateTracer, flatCallTracer, and the struct (opcode) logger. TraceBaker pre-bakes and caches the results of callTracer, prestateTracer, and flatCallTracer. Requires trace-enabled or archive state for the target height.The max block lookback guard (max_trace_lookback_blocks) applies. If a request’s target block is older than the configured lookback, the request is rejected with an error of the form block number X is beyond max lookback of Y. Each such request increments the evmrpc_historical_debug_trace_attempts_total metric. This guard applies consistently across all debug_trace* endpoints.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: Available over HTTP only. The safe, finalized, and latest tags are equivalent because of instant finality. The max_trace_lookback_blocks historical guard applies (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: Available over HTTP only. The max_trace_lookback_blocks historical guard applies (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: Available over HTTP only. Arbitrary geth tracer names pass through. Tracing on the pending block is not supported. The max_trace_lookback_blocks historical guard applies (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: This Sei-specific extension is not part of the upstream go-ethereum debug namespace. It is available over HTTP only and subject to the availability guards for historical debug traces. The max_trace_lookback_blocks historical guard applies (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 with a detailed timing and store-access profile.Sei-specific behavior: This Sei-specific extension is not part of the upstream go-ethereum debug namespace. It is available over HTTP only and subject to the availability guards for historical debug traces.In addition to the standard trace result, the method returns a profile object that shows where the time was spent. The profile has the total wall time, the historical DB lookup time, and per-phase timings. The phases are transaction lookup, block load, historical transaction replay, block-context build, transaction preparation, execution, and trace-result assembly. The method also returns a per-module store access trace. This trace has reads, iterators with the keys they surfaced, and per-operation stats roll-ups.Per-transaction caps bound the trace size. For each module, the trace retains at most 16 iterators and 64 keys per iterator, and truncated flags any overflow. To run this method across a whole block range and generate aggregate reports, use the seidb trace-profile-report command. The max_trace_lookback_blocks historical guard applies (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 with this shape:

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: the per-phase timings lookupTransactionNanos, loadBlockNanos, replayHistoricalTxsNanos, buildBlockContextNanos, prepareTxNanos, executionNanos, and traceResultNanos.
store: the per-module store access trace, with modules (each with reads, has, iterators, and per-operation 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 keeps four legacy custom endpoints for address resolution, cross-VM transaction lookup, and synthetic receipts.

For new integrations, use standard eth_* and debug_* methods. The four remaining sei_* methods are deprecated and scheduled for removal.The sei2_* namespace has been removed. Most legacy sei_* methods have also been removed, including block, filter, log, signing, association, and transaction lookup methods. The sei_* cleanup is tracked in sei-chain PR #3927.

No remaining block or filter method can discover synthetic logs from Cosmos-originated transactions. If you already know a synthetic transaction hash, enable sei_getTransactionReceipt to fetch its receipt and logs.

The enabled_legacy_sei_apis setting under [evm] in app.toml controls access. 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 that signals deprecation. The gate handles JSON-RPC batches. It does not pass them through as a whole. Only allowed methods are forwarded to the inner handler. The handler then merges the responses by matching the JSON-RPC id of each response. Disallowed methods return the usual -32601 legacy deprecation error in their slot. A batch element that is not a JSON object returns a JSON-RPC -32600 "Invalid Request" error in its slot. In JSON-RPC 2.0, requests that omit the id member are notifications. They do not produce a response entry, and this also applies within a batch. A request with "id": null is not a notification and receives a response. If a batch produces no response objects, the gateway returns an empty HTTP body with HTTP 200 instead of an empty JSON array ([]).

Legacy API configuration

The enabled_legacy_sei_apis setting controls which remaining sei_* methods are accessible on the EVM HTTP endpoint. By default, seid init enables the three address and cross-VM lookup helpers:

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

  # Optional: enable synthetic receipt lookup.
  # "sei_getTransactionReceipt",
]

Only these four methods are available:

Method	Description
`sei_getSeiAddress`	Returns the Sei address associated with an EVM address.
`sei_getEVMAddress`	Returns the EVM address associated with a Sei address.
`sei_getCosmosTx`	Returns the wrapping Cosmos transaction hash as uppercase hexadecimal without a `0x` prefix.
`sei_getTransactionReceipt`	Returns a receipt, including a synthetic receipt when its transaction hash is known.

Address resolution

To resolve the EVM (0x…) ↔ Sei (sei1…) address pair, use the addr precompile at 0x0000000000000000000000000000000000001004 through a standard eth_call. The precompile is available on every Sei RPC and is not part of the deprecated sei_* namespace. It 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. For the full association lifecycle and how the bidirectional mapping is established, see Accounts.

In the past, the legacy JSON-RPC helpers sei_getSeiAddress and sei_getEVMAddress handled address resolution. They are still enabled by default on nodes today. However, 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 returns the hash as uppercase hexadecimal without a 0x prefix. The method does not have a precompile equivalent yet. It is enabled by default on Sei nodes.

View cross-VM lookup endpoints

sei_getCosmosTx

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

Parameters:

Type	Description
`DATA, 32 bytes`	The `0x`-prefixed EVM transaction hash.

Result:

Type	Description
`string`	The Cosmos transaction hash as uppercase hexadecimal without a `0x` prefix.

Example request

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

Legacy deprecation error

If a client calls a remaining sei_* method that is not listed in enabled_legacy_sei_apis, the node returns:

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32601,
    "message": "sei_getTransactionReceipt is not enabled on this node. The sei_* JSON-RPC surface is 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 a call to an allowlisted sei_* method succeeds, the response includes an optional HTTP header that signals deprecation:

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

Clients can use this header to detect legacy API use and plan their 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