# Sei Documentation

> Technical documentation for Sei — a parallelized EVM Layer 1 with sub-second finality, full Ethereum tooling compatibility, and a clear roadmap toward Sei Giga (200K TPS, 5 gigagas/s).

Sei is a parallelized EVM Layer 1 blockchain with 400ms finality, ~100 MGas/s throughput today, and full Ethereum tooling compatibility. Deploy standard Solidity contracts with no modifications. Chain ID: mainnet 1329, testnet 1328. The next major upgrade, Sei Giga, targets 200K TPS via Autobahn multi-proposer BFT consensus and a custom EVM execution engine.

Prerequisites: Node.js ≥ 18, a wallet (Compass, Rabby, MetaMask, or any EVM-compatible wallet), and SEI tokens for gas.
Authentication: No API key is required for public RPC endpoints. Rate limits apply — use a dedicated provider (Ankr, DRPC, Nirvana) for production workloads.
Version compatibility: Solidity ≥ 0.8.x recommended. Sei EVM tracks the Pectra EVM (without blob transactions).
Network requirements: Mainnet chain ID 1329 (pacific-1), testnet chain ID 1328 (atlantic-2). Gas is paid in SEI (18 decimals).
Important notes: Sei has 400ms block times — set lower polling intervals than on Ethereum. Transactions touching independent state are parallelized automatically; shared-state writes are serialized.
IBC deprecation: Per SIP-03, inbound/outbound IBC transfers are being disabled. Holders of IBC assets (USDC.n, USDT.kava, Wormhole-bridged tokens) must migrate before the governance proposal activates — see /learn/sip-03-migration.

## Quick Reference

Chain ID: mainnet 1329 (pacific-1), testnet 1328 (atlantic-2)
RPC (mainnet): https://evm-rpc.sei-apis.com
RPC (testnet): https://evm-rpc-testnet.sei-apis.com
Native token: SEI (gas, staking, governance)
USDC (mainnet): 0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392 (6 decimals)
USDC (testnet): 0x4fCF1784B31630811181f670Aea7A7bEF803eaED (6 decimals)
Block time: 400ms finality
Throughput: ~100 MGas/s today; Sei Giga target 200K TPS / 5 gigagas/s
EVM compatibility: Full — standard Solidity, Hardhat, Foundry, wagmi, ethers.js, viem work unmodified

## Learn

Sei is a parallelized EVM Layer 1 blockchain. Performance comes from Twin Turbo Consensus (optimistic block processing), parallel EVM execution (concurrent transactions on independent state), and SeiDB (high-throughput storage). Full Ethereum tooling compatibility — deploy standard Solidity contracts with no modifications.

Sei Giga is the next major upgrade targeting 200K TPS and 5 gigagas/s via Autobahn multi-proposer BFT consensus and a custom EVM execution engine. For developers, Sei Giga's parallel engine rewards contracts with user-scoped state (mapping per address) over shared global state.

Mainnet (pacific-1): chain ID 1329. Testnet (atlantic-2): chain ID 1328.

SIP-03 migration: inbound/outbound IBC transfers are being disabled. Holders of IBC assets must swap, migrate, or bridge out before the governance proposal activates.

- [Learn About Sei](https://docs.sei.io/learn): Discover Sei Network's architecture, performance features, and ecosystem, with detailed resources on consensus, tokenomics, governance, and development frameworks.
- [Getting Started with Sei Network: User Quick Start Guide](https://docs.sei.io/learn/user-quickstart): Comprehensive guide to Getting Started with Sei Network: User Quick Start Guide on Sei. Learn key concepts, commands, and best practices.
- [Sei Blockchain Network Chains Overview](https://docs.sei.io/learn/dev-chains): Compare Sei's different network environments including testnet, mainnet, and local chains, with detailed chain IDs and purposes for each development stage.
- [Token Standards](https://docs.sei.io/learn/dev-token-standards): Explore the different token types on Sei including native SEI, smart contract tokens (ERC20/CW20), and NFTs, with implementation guidance for each standard.
- [Gas](https://docs.sei.io/learn/dev-gas): Understand gas pricing, limits, and optimization strategies for Sei transactions, with guides for sending transactions using seid and EVM interfaces.
- [Sei Network Accounts: Dual Address System Explained](https://docs.sei.io/learn/accounts): Understand how Sei's unified account system works with both EVM (0x) and Cosmos (sei1) addresses, including association methods, security considerations, and cross-environment interactions.
- [SIP-03 Migration Guide](https://docs.sei.io/learn/sip-03-migration): Practical steps and resources for users and exchanges migrating during SIP-03, including asset transfer, USDC, and exchange migration guidance.
- [Sei EVM Upgrade for Exchanges and Custodians](https://docs.sei.io/learn/sip-03-exchange-migration): Practical steps and resources for users and exchanges migrating during SIP-03, including asset transfer, USDC, and exchange migration guidance.
- [Twin Turbo Consensus: Sei's High-Speed Blockchain Consensus](https://docs.sei.io/learn/twin-turbo-consensus): Explore how Sei's Twin Turbo consensus mechanism achieves higher transaction throughput by separating block building from consensus, with detailed explanations of the protocol's design and benefits.
- [Sei Parallelization Engine: Multi-core Blockchain Execution](https://docs.sei.io/learn/parallelization-engine): Learn how Sei's Parallelization Engine enables simultaneous transaction processing across multiple CPU cores, delivering higher throughput while maintaining safety and consistency guarantees.
- [SeiDB: Performance-Optimized Blockchain Database](https://docs.sei.io/learn/seidb): Learn how SeiDB's specialized storage architecture accelerates blockchain operations through multi-level caching, optimized state access, and concurrency control designed specifically for EVM workloads.
- [Sei Wallet Providers Guide](https://docs.sei.io/learn/wallets): Comprehensive guide to Sei Wallet Providers Guide on Sei. Learn key concepts, commands, and best practices.
- [Sei Network RPC Providers](https://docs.sei.io/learn/rpc-providers): Directory of reliable RPC service providers for Sei blockchain. Access endpoints for development, node connections, and blockchain interactions.
- [Sei Blockchain Explorers Guide](https://docs.sei.io/learn/explorers): A comprehensive overview of block explorers for the Sei Network across different environments. Access tools for tracking transactions, analyzing addresses, and monitoring network activity.
- [Sei Network Testnet Faucet](https://docs.sei.io/learn/faucet): Request testnet tokens for development and testing on Sei Network. The faucet distributes test tokens with no real-world value.
- [Blockchain Indexers for Sei Network](https://docs.sei.io/learn/indexers): Comprehensive guide to Blockchain Indexers for Sei Network on Sei. Learn key concepts, commands, and best practices.
- [Oracle Providers on Sei](https://docs.sei.io/learn/oracles): Directory of oracle providers for Sei blockchain. Access reliable price feeds and off-chain data for DeFi applications, smart contracts, and dApps.
- [General Governance](https://docs.sei.io/learn/general-governance): Learn about Sei's governance system and how to participate in the decision-making process
- [Proposals](https://docs.sei.io/learn/proposals): Complete guide to Sei governance proposals. Learn about different proposal types and how to submit them.
- [Sei Blockchain Staking Guide](https://docs.sei.io/learn/general-staking): Participate in Sei's proof-of-stake consensus by staking tokens with validators, with detailed explanations of delegation, rewards, slashing risks, and the unbonding process.
- [Sei Network Interoperability Framework](https://docs.sei.io/learn/dev-interoperability): Understand how Sei enables seamless interaction between EVM and Cosmos ecosystems through its dual address system and precompiles.
- [Sei Pointer Contracts: Bridging EVM and Cosmos Environments](https://docs.sei.io/learn/pointers): Understand how Sei's pointer contract system enables seamless asset movement between EVM and Cosmos environments, with implementation patterns for various token types.
- [Sei Giga Overview: The Fastest EVM Blockchain](https://docs.sei.io/learn/sei-giga): A comprehensive technical overview of Sei Giga - a high-performance blockchain platform combining EVM compatibility with groundbreaking consensus, execution, and storage innovations for unprecedented throughput and sub-second finality.
- [Sei Giga Technical Specifications](https://docs.sei.io/learn/sei-giga-specs): Comprehensive technical specifications for Sei Giga architecture, consensus protocols, and performance characteristics
- [Sei Giga Developer Guide](https://docs.sei.io/learn/sei-giga-developers): Key patterns and techniques for building high-performance dApps on Sei Giga
- [Hardware Wallets](https://docs.sei.io/learn/hardware-wallets)
- [Ledger Hardware Wallet Setup Guide for Sei](https://docs.sei.io/learn/ledger-setup): Configure your Ledger hardware wallet to securely manage Sei assets, with step-by-step instructions for installation, receiving and sending transactions, and security best practices.
- [Sei Brand Guidelines](https://docs.sei.io/learn/general-brand-kit)

## EVM Development

Sei's EVM is fully compatible with Ethereum. Standard Solidity contracts deploy without modification. All Ethereum tooling (Hardhat, Foundry, wagmi, ethers.js, viem, RainbowKit) works as-is. Transactions touching independent state execute concurrently.

Precompiled contracts at fixed addresses expose native Sei functionality (staking, governance, IBC, JSON, oracle, p256) to EVM.

Native USDC: mainnet 0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392, testnet 0x4fCF1784B31630811181f670Aea7A7bEF803eaED (6 decimals).

- [Sei EVM - High Performance Ethereum Virtual Machine](https://docs.sei.io/evm): Build on the fastest EVM with 400ms finality, 100 MGas/s throughput, and full Ethereum tooling compatibility.
- [Sei EVM Networks](https://docs.sei.io/evm/networks): Discover network information for Sei EVM across all environments including mainnet and testnet. Access RPC endpoints, chain IDs, and blockchain explorers.
- [Sei EVM vs Ethereum: Key Differences](https://docs.sei.io/evm/differences-with-ethereum): A comparison of Sei EVM and Ethereum, highlighting Sei's advantages in blocktime, throughput, finality, and execution environment, as well as technical differences in opcodes, state storage, and other features.
- [EVM Compatibility](https://docs.sei.io/evm/evm-parity/evm-compatibility): EVM feature support on Sei — what works, what differs from Ethereum, and what is not available
- [Finality and Block Tags](https://docs.sei.io/evm/evm-parity/finality): How Sei instant finality affects block tag behavior and pending state
- [Gas and Fees](https://docs.sei.io/evm/evm-parity/gas-and-fees): Sei gas price floor, EIP-1559 fee model differences, and SSTORE cost
- [Transaction Types](https://docs.sei.io/evm/evm-parity/transaction-types): Which Ethereum transaction types are supported on Sei
- [State Proofs](https://docs.sei.io/evm/evm-parity/state-proofs): How eth_getProof differs on Sei due to IAVL tree storage
- [WebSocket Connections](https://docs.sei.io/evm/evm-parity/websocket): Connecting to Sei via WebSocket for real-time block and event subscriptions
- [Signing](https://docs.sei.io/evm/evm-parity/signing): Wallet signing method support and EIP-712 typed data on Sei
- [Migrate Your EVM dApp to Sei](https://docs.sei.io/evm/migrate-from-other-evms): Step-by-step checklist for teams that already run on another EVM chain and want to redeploy on Sei, including environment prep, contract migration, liquidity planning, and chain-specific guidance for Ethereum, Arbitrum, Base, Polygon, and Avalanche.
- [Migrate from Solana to Sei EVM](https://docs.sei.io/evm/migrate-from-solana): A comprehensive guide for Solana developers transitioning to Sei EVM, covering architectural differences, concept mapping, code translation patterns, and step-by-step migration strategies.
- [Installing seid CLI](https://docs.sei.io/evm/installing-seid-cli): Complete guide to installing and setting up the Sei CLI (seid) tool, including wallet creation, EVM imports, and troubleshooting common installation issues.
- [Querying the EVM](https://docs.sei.io/evm/querying-the-evm): Read EVM state from the seid CLI: address associations, ERC20 reads, ABI-encoded payloads, and transaction details.
- [Transactions with seid](https://docs.sei.io/evm/transactions-with-seid): Complete guide to executing EVM transactions using the Sei CLI (seid). Learn how to send tokens, deploy contracts, and interact with smart contracts.
- [Changelog](https://docs.sei.io/evm/changelog): Track the latest updates, improvements, and changes to Sei Chain. Stay informed about new features, bug fixes, and protocol upgrades.
- [Sei Global Wallet Integration Guide](https://docs.sei.io/evm/sei-global-wallet): Learn how to integrate and use Sei Global Wallet, a cross-application embedded crypto wallet that provides persistent wallet experience across Sei ecosystem applications.
- [Building a Frontend for Sei EVM: A Comprehensive Guide](https://docs.sei.io/evm/building-a-frontend): Comprehensive guide on Building a Frontend for Sei EVM. Learn key concepts, commands, and best practices.
- [In-App Swaps - Symphony Integration Guide](https://docs.sei.io/evm/in-app-swaps): Guide to integrating the Symphony swap widget into your Sei application for seamless token exchanges.
- [EVM General Guide for Sei Blockchain](https://docs.sei.io/evm/evm-general): Comprehensive guide on Ethereum Virtual Machine (EVM) on Sei blockchain. Learn about smart contract languages, development tools, and best practices for building on Sei's parallelized EVM.
- [Sei EVM Development with Hardhat](https://docs.sei.io/evm/evm-hardhat): Learn how to set up Hardhat for Sei EVM development, create and deploy smart contracts, and leverage OpenZeppelin components for secure, standardized implementations.
- [Sei EVM Smart Contract Development with Foundry](https://docs.sei.io/evm/evm-foundry): Learn how to develop, test, and deploy smart contracts on Sei EVM using Foundry, with step-by-step examples of contract creation, testing, deployment, and interaction using both CLI and ethers.js.
- [Python Quickstart (web3.py)](https://docs.sei.io/evm/python-quickstart): Connect to Sei from Python using web3.py — read chain data, then sign and broadcast transactions against the Sei EVM JSON-RPC.
- [Using the OpenZeppelin Contract Wizard with Sei EVM](https://docs.sei.io/evm/evm-wizard): Learn how to use the OpenZeppelin Contract Wizard to create secure, standard-compliant smart contracts for Sei EVM, with step-by-step guidance and best practices.
- [Solidity Development Resources for Sei EVM](https://docs.sei.io/evm/solidity-resources): Comprehensive guide on Solidity Development Resources for Sei EVM on Sei. Learn key concepts, commands, and best practices.
- [Optimizing Contracts for Parallelization](https://docs.sei.io/evm/best-practices/optimizing-for-parallelization): Design patterns to reduce state conflicts and maximize Sei EVM parallel execution while lowering gas usage.
- [Zeroing Out Stale State](https://docs.sei.io/evm/best-practices/zeroing-stale-state): Strategies for clearing unused EVM storage on Sei to reduce state growth and improve node performance.
- [Debugging for EVM](https://docs.sei.io/evm/debugging-contracts): Advanced debugging techniques for EVM transactions on Sei. Learn transaction template generation and analysis using seid and Foundry cast tools.
- [Debug Tracing Overview](https://docs.sei.io/evm/tracing): Comprehensive guide to debugging and tracing EVM transactions on Sei. Learn to analyze transaction execution, optimize gas usage, and troubleshoot smart contracts with real examples and end-to-end workflows.
- [JavaScript Tracers](https://docs.sei.io/evm/tracing/javascript-tracers): Create custom debugging logic with JavaScript tracers for advanced EVM transaction analysis on Sei. Learn performance optimization, memory management, and advanced debugging patterns.
- [Troubleshooting Guide](https://docs.sei.io/evm/tracing/troubleshooting): Comprehensive troubleshooting guide for EVM transaction tracing on Sei. Resolve common issues with timeouts, memory limits, JavaScript errors, and performance optimization.
- [Verify Contracts](https://docs.sei.io/evm/evm-verify-contracts): Comprehensive guide on how to verify your EVM smart contracts on Sei
- [Precompile Example Usage](https://docs.sei.io/evm/precompiles/example-usage): Learn how to interact with Sei's precompiles through viem and ethers, covering all available precompiles with quick examples and common patterns for seamless integration between EVM and Sei-native functionality.
- [Distribution Precompile](https://docs.sei.io/evm/precompiles/distribution): Manage staking rewards and validator commissions through Sei's distribution precompile. EVM applications can withdraw rewards, set withdrawal addresses, and interact with Cosmos SDK distribution functionality.
- [Governance Precompile Usage](https://docs.sei.io/evm/precompiles/governance): Learn how to interact with Sei's governance precompile through ethers.js, enabling proposal submission, voting, token deposits, and governance queries to participate in on-chain governance directly from EVM applications.
- [JSON Precompile Usage](https://docs.sei.io/evm/precompiles/json): Learn how to interact with Sei's JSON precompile through ethers.js, enabling efficient parsing, manipulation, and querying of JSON data within EVM smart contracts to overcome Solidity's native limitations for handling complex data structures.
- [Oracle Precompile Usage](https://docs.sei.io/evm/precompiles/oracle): Learn how to interact with Sei's Oracle precompile through ethers.js, enabling real-time access to exchange rates, TWAPs, and other economic data directly in your EVM smart contracts for DeFi applications.
- [Staking Precompile](https://docs.sei.io/evm/precompiles/staking): Learn how to interact with Sei's Staking precompile through ethers.js, enabling delegation, undelegation, redelegation, and validator management directly in your EVM smart contracts for DeFi and staking applications.
- [P256 Precompile](https://docs.sei.io/evm/precompiles/p256-precompile): Use the P256 precompile to verify secp256r1/P-256 signatures directly from EVM smart contracts, enabling efficient passkey-based authentication and signature verification.
- [Example Usage](https://docs.sei.io/evm/precompiles/cosmwasm-precompiles/example-usage): Learn how to interact with Sei precompiles using ethers.js to query and execute CosmWasm contracts from the EVM.
- [Address Precompile](https://docs.sei.io/evm/precompiles/cosmwasm-precompiles/addr): Learn how to interact with Sei's Addr precompile through ethers.js and Solidity, enabling address association and cross-chain address mapping directly in your EVM smart contracts for seamless user experiences.
- [Bank Precompile](https://docs.sei.io/evm/precompiles/cosmwasm-precompiles/bank): Learn how to interact with Sei's Bank precompile through ethers.js and Solidity, enabling native token transfers, balance queries, and token metadata management directly in your EVM smart contracts for seamless DeFi experiences.
- [CosmWasm Precompile](https://docs.sei.io/evm/precompiles/cosmwasm-precompiles/cosmwasm): Learn how to interact with Sei's CosmWasm precompile through ethers.js, enabling execution, batch operations, and querying of pre-existing CosmWasm contracts directly from your EVM smart contracts.
- [@sei-js SDK](https://docs.sei.io/evm/sei-js): A complete TypeScript SDK for building decentralized applications on Sei Network
- [Scaffold Sei](https://docs.sei.io/evm/sei-js/create-sei): CLI tool for scaffolding production-ready Sei applications with pre-configured templates
- [@sei-js/ledger](https://docs.sei.io/evm/sei-js/ledger): TypeScript library for SEI Ledger app helper functions — address derivation, Amino signing, and CosmJS integration
- [@sei-js/registry](https://docs.sei.io/evm/sei-js/registry): Chain constants, RPC endpoints, token metadata, and wallet info for Sei Network
- [Video Tutorials](https://docs.sei.io/evm/videos): Watch video tutorials covering Sei EVM development, smart contract tooling, precompiles, and more.
- [viem Quickstart](https://docs.sei.io/evm/evm-parity/examples/viem-quickstart): Using viem with Sei in a Node.js script, CLI tool, or backend service
- [ethers v6 Quickstart](https://docs.sei.io/evm/evm-parity/examples/ethers-quickstart): Using ethers v6 with Sei in a Node.js script or browser context
- [Wagmi + React](https://docs.sei.io/evm/evm-parity/examples/wagmi-react): Connect wallets, read chain state, and write transactions in a React app on Sei using Wagmi
- [ERC-20 Interaction](https://docs.sei.io/evm/evm-parity/examples/erc20): Reading and writing ERC-20 tokens on Sei with viem and ethers
- [ERC-721 Interaction](https://docs.sei.io/evm/evm-parity/examples/erc721): Reading and writing ERC-721 NFTs on Sei with viem and ethers
- [ERC-1155 Interaction](https://docs.sei.io/evm/evm-parity/examples/erc1155): Reading and writing ERC-1155 multi-token contracts on Sei with viem and ethers
- [Multicall](https://docs.sei.io/evm/evm-parity/examples/multicall): Batch multiple contract reads into a single RPC call using Multicall3 on Sei
- [Pointer Contracts](https://docs.sei.io/evm/evm-parity/examples/pointer-contracts): Looking up and interacting with pointer contracts that bridge CosmWasm and EVM tokens on Sei
- [Sei Precompiles](https://docs.sei.io/evm/evm-parity/examples/sei-precompiles): Interact with native Sei chain features — staking, governance, native token balances, and more — from EVM applications
- [Deploy and Verify](https://docs.sei.io/evm/evm-parity/examples/deploy-verify): Deploying and verifying smart contracts on Sei with viem, ethers, Foundry, and Hardhat
- [Transaction Lifecycle](https://docs.sei.io/evm/evm-parity/examples/transaction-lifecycle): Send transactions, wait for receipts, and decode event logs on Sei
- [Error Handling](https://docs.sei.io/evm/evm-parity/examples/error-handling): Decode contract reverts, handle wallet rejections, and recover from RPC errors in Sei apps
- [Envio](https://docs.sei.io/evm/indexer-providers/envio): Index Sei smart contract data using Envio, a modular hyper-performant data indexing solution.
- [Goldsky](https://docs.sei.io/evm/indexer-providers/goldsky): Implement Goldsky's Subgraphs and Mirror products to efficiently index, query, and stream Sei blockchain data for your dApps with customizable data models and real-time pipelines.
- [The Graph](https://docs.sei.io/evm/indexer-providers/the-graph): Build and deploy subgraphs on The Graph to efficiently index and query data from Sei smart contracts, with step-by-step instructions from initialization to production deployment.
- [GoldRush API Integration](https://docs.sei.io/evm/indexer-providers/goldrush): Learn how to integrate GoldRush indexing services with Sei network for blockchain data analysis and application development.
- [Sim by Dune](https://docs.sei.io/evm/indexer-providers/dune-sim): Learn how to integrate Sim by Dune real-time multichain indexing services with Sei network for blockchain data analysis and application development.
- [Moralis](https://docs.sei.io/evm/indexer-providers/moralis): Complete guide to integrating Moralis with Sei blockchain for Web3 development
- [Social logins with Particle Connect](https://docs.sei.io/evm/wallet-integrations/particle): Comprehensive guide on Social logins with Particle Connect on Sei. Learn key concepts, commands, and best practices.
- [Pimlico Account Abstraction Integration](https://docs.sei.io/evm/wallet-integrations/pimlico): Learn how to integrate Pimlico's account abstraction services with Sei network for gasless transactions and smart account functionality.
- [Thirdweb](https://docs.sei.io/evm/wallet-integrations/thirdweb): Learn how to integrate thirdweb's Account Abstraction SDK with Sei network to build decentralized applications with seamless wallet connectivity.
- [Thirdweb EIP-7702 Integration Guide](https://docs.sei.io/evm/wallet-integrations/thirdweb-7702): Learn how to integrate thirdweb's Account Abstraction SDK with Sei network to build decentralized applications with seamless wallet connectivity.
- [Enable Onramps, Swapping & Bridging on Any EVM Chain](https://docs.sei.io/evm/bridging/thirdweb): Comprehensive guide on enabling onramps, swapping & bridging on Any EVM Chain on Sei. Learn key concepts, commands, and best practices.
- [LayerZero V2 on SEI - Complete Integration Guide](https://docs.sei.io/evm/bridging/layerzero): Step-by-step guide to building cross-chain applications on SEI using LayerZero V2
- [USDC on Sei](https://docs.sei.io/evm/usdc-on-sei): Guide to integrating USDC stablecoin on Sei using Viem and Node.js for transfers and balance checks.
- [Dune Analytics](https://docs.sei.io/evm/dune): Complete guide to working with Dune Analytics on Sei Network
- [Chainlink Data Streams](https://docs.sei.io/evm/oracles/chainlink): Complete guide to integrating Chainlink Data Streams with Sei Network
- [RedStone](https://docs.sei.io/evm/oracles/redstone): Complete guide to integrating RedStone oracles with Sei
- [API3](https://docs.sei.io/evm/oracles/api3): Complete guide to integrating API3 with Sei
- [Pyth Network](https://docs.sei.io/evm/oracles/pyth-network): Complete guide to integrating Pyth Network with Sei
- [Pyth Network VRF Integration](https://docs.sei.io/evm/vrf/pyth-network-vrf): Complete guide to integrating Pyth Network VRF with Sei Network
- [Transactions](https://docs.sei.io/evm/transactions): Comprehensive guide on Transactions on Sei. Learn key concepts, commands, and best practices.
- [Sei EVM JSON-RPC API Reference](https://docs.sei.io/evm/reference): Comprehensive reference documentation for Sei's EVM JSON-RPC API endpoints, including standard Ethereum methods and Sei-specific extensions for developers.
- [Viewing Tokens in MetaMask](https://docs.sei.io/evm/tokens): Learn how to view and manage different token types in MetaMask with Sei network, including ERC20 tokens, ERC721 NFTs.
- [Analytics Setup](https://docs.sei.io/evm/analytics-setup): Comprehensive guide on how to set up analytics for your project
- [Ecosystem Contracts](https://docs.sei.io/evm/ecosystem-contracts): Comprehensive registry of smart contract addresses for projects building on Sei. Find verified contract addresses organized by project.
- [Ledger Setup (EVM)](https://docs.sei.io/evm/ledger-ethers): Set up your Ledger hardware wallet for signing EVM transactions on Sei, including device configuration, Ethers.js integration, and a simple transfer example.

## Node Operations

Sei supports full nodes (recent state, consensus relay), archive nodes (complete historical state), and validator nodes (block production and consensus). StateSync enables fast bootstrap — new nodes fetch a recent state snapshot instead of replaying all historical blocks. The Sei Giga storage migration moves nodes to a new format optimized for the upcoming throughput targets.

- [Node Operations on Sei](https://docs.sei.io/node): Deploy and maintain Sei Network infrastructure with comprehensive guides for validators, RPC nodes, and archive nodes, including hardware requirements, installation steps, and operational best practices.
- [Sei Node Operations Guide](https://docs.sei.io/node/node-operators): Detailed guide for running and maintaining Sei nodes. Learn about configuration management, database maintenance, service management, and update procedures.
- [Configure Nodes with seictl](https://docs.sei.io/node/seictl): Install and use the seictl CLI to patch Sei node configuration and genesis files safely with merge-patch workflows.
- [Join the network using StateSync](https://docs.sei.io/node/statesync): Detailed guide for using statesync to join the network
- [Join the network using Snapshots](https://docs.sei.io/node/snapshot): Detailed guide for using snapshots to join the network
- [Node Types](https://docs.sei.io/node/node-types): Learn about different types of Sei nodes, their purposes, commonly used ports, and systemd configuration.
- [Troubleshooting](https://docs.sei.io/node/troubleshooting): Detailed guide for troubleshooting node problems.
- [Swagger API Documentation](https://docs.sei.io/node/swagger): Learn how to enable and access Swagger API documentation for your Sei node. Configure the swagger endpoint in app.toml and view interactive API docs.
- [Sei Validator Operations Guide](https://docs.sei.io/node/validators): Learn how to set up and maintain a validator node on Sei Network, including hardware security configuration, key management, monitoring practices, and governance participation requirements.
- [Sei Node Advanced Configuration & Monitoring](https://docs.sei.io/node/advanced-config-monitoring): Optimize your Sei node's performance with advanced system configurations, monitoring setup with Prometheus and Grafana, and effective alerting strategies for maintaining reliable node operations.
- [RocksDB Backend Setup & Performance](https://docs.sei.io/node/rocksdb-backend): Build and enable the RocksDB backend for seid to significantly improve iteration-heavy operations and traceBlock latency, especially on long-history RPC and archive nodes.
- [Giga SS Store Migration Guide](https://docs.sei.io/node/giga-storage-migration): Migrate a Sei RPC node to Giga SS Store: split EVM state into a dedicated state-store backend so non-EVM modules stop paying EVM write amplification.
- [Sei Technical Reference](https://docs.sei.io/node/technical-reference): Access detailed command syntax, configuration parameters, and troubleshooting procedures for node operators and validators running Sei network infrastructure.

## Examples

### Deploy a contract with Hardhat

```javascript
// hardhat.config.js
module.exports = {
  solidity: "0.8.26",
  networks: {
    sei: {
      url: "https://evm-rpc.sei-apis.com",
      chainId: 1329,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};
```

### Query a balance with viem

```typescript
import { createPublicClient, http } from "viem";
import { sei } from "viem/chains";

const client = createPublicClient({ chain: sei, transport: http() });
const balance = await client.getBalance({
  address: "0xYourAddress",
});
console.log("Balance:", balance);
```

### Connect a wallet with wagmi

```typescript
import { http, createConfig } from "wagmi";
import { sei } from "wagmi/chains";
import { injected } from "wagmi/connectors";

export const config = createConfig({
  chains: [sei],
  connectors: [injected()],
  transports: { [sei.id]: http() },
});
```

## Optional

- [Build on Sei with AI](https://docs.sei.io/ai): AI tools for building on Sei — from knowledge injection that makes your AI assistant Sei-aware, to live blockchain tooling that lets it act on-chain.
- [Agent Skills](https://docs.sei.io/ai/sei-skill): A knowledge base that makes AI coding assistants Sei-aware — covering contracts, frontend, and ecosystem with Sei-specific facts baked in.
- [sei-skill Installation](https://docs.sei.io/ai/sei-skill/install): Install sei-skill for Claude Code, Cursor, GitHub Copilot, Windsurf, and other AI coding assistants.
- [sei-skill Example Prompts](https://docs.sei.io/ai/sei-skill/prompts): Prompts that unlock Sei-specific guidance from your AI assistant after installing sei-skill.
- [MCP Server](https://docs.sei.io/ai/mcp-server): Enable AI assistants to interact with Sei networks through natural language using the Model Context Protocol
- [Cambrian Agent Kit Ecosystem Tutorial](https://docs.sei.io/ai/cambrian-agent-kit): Learn to build powerful, autonomous AI agents and agentic chatbots on the SEI blockchain with DeFi protocol integrations including Takara, Silo, Citrex, and Symphony.
- [Agentic Wallets](https://docs.sei.io/ai/agentic-wallets): Build AI agents with secure, programmable wallets on Sei using Coinbase AgentKit or Privy server wallets. Includes setup guides, policy engines, and a full feature comparison.
- [x402 Protocol on Sei](https://docs.sei.io/ai/x402): Implement HTTP micropayments on Sei using the x402 protocol for API monetization and digital services.

## Resources

- [GitHub](https://github.com/sei-protocol): Open source repositories including sei-chain, sei-js, and MCP server
- [Developer Hub](https://www.sei.io/developers): Curated entry points, ecosystem programs, and grant info
- [Ecosystem](https://www.sei.io/ecosystem): Directory of projects building on Sei
- [Blog](https://blog.sei.io): Announcements and technical deep dives
- [Dashboard](https://dashboard.sei.io): Transfer, bridge, and stake on Sei

---

URL: https://docs.sei.io/learn

# Learn About Sei

> Discover Sei Network's architecture, performance features, and ecosystem, with detailed resources on consensus, tokenomics, governance, and development frameworks.

**Performance-Optimized Ethereum Compatibility**

Sei's EVM implementation addresses traditional performance constraints through three key subsystems that work together to deliver unparalleled speed while maintaining full compatibility with the Ethereum ecosystem.

## Understand the Sei Ecosystem

### Fundamentals

<CardGroup cols={2}>
  <Card horizontal title="Account System" icon="key" href="/learn/accounts">
    Understand native & EVM addresses, keys, and account abstraction.
  </Card>

  <Card horizontal title="Token Standards" icon="coins" href="/learn/dev-token-standards">
    Discover ERC20, ERC721, and native Sei token capabilities.
  </Card>

  <Card horizontal title="Gas & Fees" icon="gas-pump" href="/learn/dev-gas">
    Learn how transaction costs are calculated and paid on Sei.
  </Card>

  <Card horizontal title="Wallets" icon="wallet" href="/learn/wallets">
    Explore supported wallets and integration options for Sei.
  </Card>
</CardGroup>

### Network

<CardGroup cols={2}>
  <Card horizontal title="Staking & Delegation" icon="users" href="/learn/general-staking">
    Secure the network and earn rewards by participating in staking.
  </Card>

  <Card horizontal title="Network Governance" icon="gavel" href="/learn/general-governance">
    Understand the on-chain proposal and voting process for upgrades.
  </Card>

  <Card horizontal title="Chains" icon="network-wired" href="/learn/dev-chains">
    Connect to Sei mainnet, testnet, and development environments.
  </Card>

  <Card horizontal title="Block Explorers" icon="globe" href="/learn/explorers">
    Track transactions, blocks, and contract activity on Sei.
  </Card>
</CardGroup>

## MCP Server: AI-Powered Blockchain

**Enable AI assistants to interact with Sei through natural language**

The Sei Model Context Protocol (MCP) Server brings blockchain functionality directly to AI assistants like Claude, ChatGPT, and Cursor. Execute transactions, query data, and build on Sei using conversational AI.

<CardGroup cols={4}>
  <Card horizontal title="Wallet Integration" icon="wallet">
    Check balances, transfer tokens, and manage accounts through AI.
  </Card>

  <Card horizontal title="Smart Contracts" icon="file-code">
    Read and write contract state with natural language commands.
  </Card>

  <Card horizontal title="Blockchain Data" icon="database">
    Query blocks, transactions, and network state instantly.
  </Card>

  <Card horizontal title="Token Operations" icon="coins">
    Transfer SEI, ERC20, NFTs, and multi-tokens seamlessly.
  </Card>
</CardGroup>

<CardGroup cols={2}>
  <Card horizontal title="Get Started with MCP" icon="rocket" href="/ai/mcp-server">
    Get Started with MCP
  </Card>

  <Card horizontal title="View on GitHub" icon="github" href="https://github.com/sei-protocol/sei-js/tree/main/packages/mcp-server">
    View on GitHub
  </Card>
</CardGroup>

## Sei EVM Platform Details

### Traditional EVM Constraints Solved by Sei

<CardGroup cols={3}>
  <Card horizontal title="Block Time Limitations" icon="clock">
    Replaces \~15s block times with sub-second finality.
  </Card>

  <Card horizontal title="Sequential Processing" icon="microchip">
    Eliminates single-threaded bottlenecks via parallelization.
  </Card>

  <Card horizontal title="Inefficient State Access" icon="database">
    Optimizes state reads/writes with SeiDB.
  </Card>
</CardGroup>

### Core System Architecture

<CardGroup cols={3}>
  <Card horizontal title="Twin Turbo Consensus" icon="clock" href="/learn/twin-turbo-consensus">
    * Sub-Second Blocks
    * Fast Finality
  </Card>

  <Card horizontal title="Parallelization Engine" icon="microchip" href="/learn/parallelization-engine">
    * Multi-Core Execution
    * Transaction Classification
  </Card>

  <Card horizontal title="SeiDB" icon="database" href="/learn/seidb">
    * Optimized State Access
    * Concurrent Operations
  </Card>
</CardGroup>

### Performance Advantages

<CardGroup cols={3}>
  <Card horizontal title="High Throughput" icon="bolt">
    * 100 MGas/s capacity
    * Sub-second block times
    * Immediate transaction inclusion
  </Card>

  <Card horizontal title="Linear Scaling" icon="arrow-trend-up">
    * Multi-core utilization
    * Hardware-optimized
    * Efficient resource usage
  </Card>

  <Card horizontal title="EVM Compatibility" icon="shield-check">
    * 100% Ethereum-compatible
    * Full tooling support
    * No code modifications needed
  </Card>
</CardGroup>

## Sei Giga: Next-Generation Architecture

**Engineered for Maximum Throughput & Efficiency**

Sei Giga represents a leap forward in blockchain performance. It combines cutting-edge consensus with novel execution strategies to deliver sub-second finality and massive scalability.

<CardGroup cols={3}>
  <Card horizontal title="Autobahn Consensus" icon="bolt">
    High-speed BFT consensus for sub-second finality.
  </Card>

  <Card horizontal title="Async Execution" icon="clock">
    Decouples execution to unblock consensus.
  </Card>

  <Card horizontal title="Parallel Processing" icon="shuffle">
    Optimistic concurrency for max throughput.
  </Card>
</CardGroup>

<Card horizontal title="Deep Dive into Sei Giga" icon="arrow-right" href="/learn/sei-giga">
  Full technical specifications, developer guidance, and upgrade details.
</Card>

## Key Use Cases

<CardGroup cols={3}>
  <Card horizontal title="High-Frequency Trading" icon="chart-line">
    Fast settlement, low-latency, and on-chain order books.
  </Card>

  <Card horizontal title="Interactive Applications" icon="mobile-screen">
    Responsive interfaces with reduced confirmation times.
  </Card>

  <Card horizontal title="Content & Social Platforms" icon="users">
    Efficient interaction for high-volume applications.
  </Card>
</CardGroup>

---

URL: https://docs.sei.io/learn/user-quickstart

# Getting Started with Sei Network: User Quick Start Guide

> Comprehensive guide to Getting Started with Sei Network: User Quick Start Guide on Sei. Learn key concepts, commands, and best practices.

This getting started guide will help you set up your wallet and start using Sei, even if you're new to blockchain. By the end, you'll be ready to explore the most performant blockchain ever.

## 1. Get a Wallet

Download a compatible wallet such as [MetaMask](https://metamask.io/), [Rabby](https://rabby.io/), [Binance Wallet](https://www.binance.com/en/web3wallet), or any other [supported wallet](/learn/wallets).

## 2. Set Up and "Associate" Your Wallet

Making a transaction will broadcast your public key to the chain, allowing full cross-environment functionality. If your wallet is not "associated" it means that the network is not aware that your key exists, and therefore it cannot be determined which two addresses are actually the same wallet due to the cryptographic algorithm by which the EVM wallet address is derived from the key(s).

<Info>
  Learn more about [how accounts work](/learn/accounts) on Sei.
</Info>

## 3. Get Tokens

* [Bridge from another network](https://welcome.symph.ag)
* [Transfer from another account](https://dashboard.sei.io/transfer)
* [Use the faucet](/learn/faucet) (testnet only)
* Transfer from CEX by copying your wallet address

<Warning>
  Typically, no memo is required for withdrawals from CEXs, but depositing back may require a memo. Check your CEX's guidelines to ensure smooth transfers.
</Warning>

## 4. Explore the ecosystem

Sei has a diverse ecosystem of applications, ranging from DeFi to Games and beyond. Explore the [Sei Ecosystem Hub](https://www.sei.io/ecosystem) to discover the latest projects and innovations or follow [@SeiNetwork](https://x.com/SeiNetwork) on X.

---

URL: https://docs.sei.io/learn/dev-chains

# Sei Blockchain Network Chains Overview

> Compare Sei's different network environments including testnet, mainnet, and local chains, with detailed chain IDs and purposes for each development stage.

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

Sei utilizes multiple chains for various stages of the development lifecycle.
This multi-chain approach allows developers to build, deploy, manage, and
iterate confidently, ensuring thorough testing and feedback before updates go
live on the mainnet.

<Info>All chain updates are first deployed to the testnet for thorough testing and validation before they are released to the mainnet. This process allows developers to test their applications thoroughly and raise any concerns regarding the upgrades before they go live on the mainnet.</Info>

## Mainnet

Mainnet is the live, production environment where actual transactions and
smart contract deployments occur. This chain is used for all real-world
applications and activities.

* **Purpose**: Production
* **Chain ID**: `pacific-1`
* **EVM Chain ID**: `1329` or `0x531`
* **EVM RPC**: `https://evm-rpc.sei-apis.com`
* **WebSocket**: `wss://evm-ws.sei-apis.com`
* **Explorer**: `https://seiscan.io`

<AddSeiButton network="mainnet" label="Add Sei Mainnet to your wallet" />

## Testnet

Testnet is used for testing and development purposes. Developers can
deploy and test their dApps and smart contracts in a controlled environment that
simulates the mainnet conditions. This chain is crucial for ensuring that
applications work as expected before going live.

* **Purpose**: Staging
* **Chain ID**: `atlantic-2`
* **EVM Chain ID**: `1328` or `0x530`
* **EVM RPC**: `https://evm-rpc-testnet.sei-apis.com`
* **WebSocket**: `wss://evm-ws-testnet.sei-apis.com`
* **Explorer**: `https://testnet.seiscan.io`

<AddSeiButton network="testnet" label="Add Sei Testnet to your wallet" />

## Local Chains

Developers can also run local chains on their machines for testing and
development purposes. Local chains are isolated environments that mimic the
behavior of the mainnet or testnet chains. They are useful for testing
new features, debugging issues, and experimenting with smart contracts with full
control over all tokens and governance decisions.

* **Purpose**: Development
* **Chain ID**: Set by user (default: `sei-chain`)

Please read the [Nodes Introduction](/node) section for more
information on how to set up and run a local chain.

<Tip>
  TIP: View more chain specific information, RPC endpoints, and Explorers for the [EVM](/evm/networks).
</Tip>

## Chain Registry

The [Sei Chain Registry](https://github.com/sei-protocol/chain-registry)
contains additional information about each chain.

---

URL: https://docs.sei.io/learn/dev-token-standards

# Token Standards

> Explore the different token types on Sei including native SEI, smart contract tokens (ERC20/CW20), and NFTs, with implementation guidance for each standard.

<Info>
  **Use ERC20 / ERC721 / ERC1155 for new tokens.** Per [Proposal 115](https://www.mintscan.io/sei/proposals/115), CosmWasm code uploads and contract instantiations are disabled on Sei, so no new CW20 / CW721 / CW1155 tokens can be deployed. The CW standards described below are documented for users and developers interacting with already-deployed legacy contracts.
</Info>

In this section, we delve into the various token standards supported on Sei.
Understanding these standards is crucial for developers as they form the
foundation of many decentralized applications.

Sei offers support for the following token types:

* [Sei Token](#sei-token)
* [Smart Contract Tokens](#smart-contract-tokens)

## Sei Token

The Sei token is the native token of the Sei blockchain, serving multiple roles
within the ecosystem.

* **Fee Token**: Used to pay transaction fees on the Sei network.
* **Governance Token**: Used to participate in governance decisions affecting
  the network.

**EVM**

`1 sei = 10**18 wei = 1_000_000_000_000_000_000 wei`

`1sei = 10**9 gwei = 1000000000 gwei` (giga-wei)

**Cosmos**

`1sei = 10**18 asei = 1000000000000000000 asei` (atto-sei)

`1sei = 10**9 nsei = 1000000000 nsei` (nano-sei)

`1sei = 10**6 usei = 1000000 usei` (micro-sei)

`1 gwei = 1 nsei`

## Fungible Tokens

Fungible tokens are digital assets that are interchangeable with one another and
are not unique. Sei supports both ERC20 and CW20 fungible token standards.

### Smart Contract Tokens

* **ERC20** (recommended): The ERC20 standard defines a common set of rules for
  fungible tokens on EVM-based blockchains. These tokens can be transferred,
  approved, and queried using standard functions. **Use ERC20 for any new
  fungible token on Sei.**
* **CW20** (legacy only): The Cosmos-side fungible token standard. Per
  [Prop 115](https://www.mintscan.io/sei/proposals/115), no new CW20 contracts
  can be deployed. Existing CW20 tokens continue to function and can still have
  pointer contracts created for them.
* **Interoperability and Pointer Contracts**:
  [Pointer contracts](/learn/pointers) expose existing CW20 tokens as ERC20 on
  the EVM. A registry tracks pointer contracts and facilitates discovery.

<Info>
  **Interoperability:** Existing CW20 tokens can have ERC20 pointer contracts deployed for them. New tokens should be deployed as ERC20 directly.

  For more detailed guidance, refer to the
  [Pointer Contracts Documentation](/learn/pointers).
</Info>

## NFTs

Non-fungible tokens (NFTs) represent unique digital assets. Sei supports
ERC721 and ERC1155 (and their royalty-aware counterparts via ERC2981) as the
standards for new NFT collections, along with legacy CW721 / CW1155 contracts.

* **ERC721 / ERC1155** (recommended): EVM standards for non-fungible and
  semi-fungible tokens. **Use these for any new NFT collection on Sei.**
* **ERC2981**: Defines a royalty mechanism for NFTs, ensuring creators receive
  a percentage of sales.
* **CW721 / CW1155** (legacy only): Per [Prop 115](https://www.mintscan.io/sei/proposals/115),
  no new CW721 / CW1155 contracts can be deployed. Existing collections continue
  to function and can be surfaced on the EVM via pointer contracts.
* **Interoperability**: Similar to fungible tokens, legacy CW NFT collections
  can interact with the EVM using pointer contracts.

## Wrapped Sei (wSei)

Some dApps may require Sei tokens to be wrapped in order to interact with them (similar to Wrapped ETH on Ethereum). The Wrapped Sei Token WSEI is deployed under the contract address [`0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7`](https://seiscan.io/address/0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7).

---

URL: https://docs.sei.io/learn/dev-gas

# Gas

> Understand gas pricing, limits, and optimization strategies for Sei transactions, with guides for sending transactions using seid and EVM interfaces.

Gas is a measure of computational effort required to execute a transaction or
contract on the Sei network. Gas fees are paid in Sei and are used to
incentivize validators to process transactions and smart contracts.

## Key Terms and Concepts

### Gas

A unit of measurement representing the work done to execute a transaction, "gas"
varies based on the complexity of the transaction being executed.

### Gas Price

The amount of Sei paid per unit of gas used when executing a transaction. The
gas price is set by the user and is used to calculate the fee for the
transaction.

### Gas Limit

The maximum amount of gas the user wants the transaction to use. If the gas
limit is set too low, the node attempting to run the transaction will run out of
gas and fail to complete the transaction, using up the entire max gas without
completing the transaction.

### Fee

`Fee = Gas Price * Gas Used`.

The gas limit caps the maximum possible charge at `Gas Price * Gas Limit`. Note
that on Sei, excess gas (the gas limit beyond the actual gas used) may not be
refunded in full or in part, so avoid setting gas limits far above what a
transaction actually needs. See
[Sei EVM vs Ethereum](/evm/differences-with-ethereum) for details.

To help developers and users estimate fees on Sei, please reference
[Sei Gas](https://seigas.com) and the associated
[APIs](https://docs.blocknative.com/gas-prediction/gas-platform) provided by
Blocknative. Their estimates are based on real-time SEI data and advanced ML
modeling to accurately and consistently estimate SEI transaction fees.

### Maximum Gas

The maximum gas limit for a transaction ensures that complex transactions do not
consume excessive resources. You can find the maximum gas limits for each chain
in the
[Sei chain registry](https://github.com/sei-protocol/chain-registry/blob/main/gas.json)
or by querying the `/consensus_params` of the RPC node itself (ex.
[https://rpc.sei-apis.com/consensus\_params](https://rpc.sei-apis.com/consensus_params)).

### Minimum Gas Price

Sei enforces minimum gas prices to prevent spam transactions. These prices are
set per chain and are detailed in the
[chain registry](https://github.com/sei-protocol/chain-registry/blob/main/gas.json).

### Max Bytes

Each transaction has a maximum size in bytes, which is set per chain. This limit
can be queried on the RPC node directly using the `/consensus_params` endpoint.

### Max Gas for Queries

Since queries also use gas, there is a maximum gas limit for queries. This limit
is RPC specific, so check with your RPC provider to determine the maximum gas
limit for queries.

## Sending Gas in Transactions

When submitting a TX to be broadcast, users specify the gas price and the gas
limit to create the fee.

### Using `seid`

When using `seid`, the fee is set using the `--fees` flag, gas limit and gas
price can be set with `--gas` and `--gas-prices` flags respectively.

```sh theme={"dark"}
seid tx bank send <from_address> <to_address> <amount> --gas <gas_limit> --gas-prices <gas_price> --fees <fee>
```

### Using EVM (wagmi)

```ts theme={"dark"}
import { parseEther, parseGwei } from 'viem';
import { sendTransaction } from '@wagmi/core';
import { config } from './config'; // your wagmi config

await sendTransaction(config, {
  to: '0xRecipientAddress',
  value: parseEther('1'), // 1 SEI
  gasPrice: parseGwei('100'), // 100 gwei (legacy tx; omit to use EIP-1559 maxFeePerGas/maxPriorityFeePerGas)
  gas: 21000n
});
```

## Optimizing Gas Prices for Smart Contracts

Optimizing gas prices involves efficient smart contract coding practices:

* Minimize storage operations.
* Use fixed-size data structures where possible.
* Avoid unnecessary computations.

## Using Blocknative's Gas API

To leverage Blocknative's Gas API, you will need an [API Key](https://docs.blocknative.com/gas-prediction/gas-platform#authentication). This API is free, but heavily rate limited, so it is recommended you get an API key. Once you have your key, you can request fee estimation for SEI:

```
curl -H "Authorization: your-apikey-here" https://api.blocknative.com/gasprices/blockprices?chainid=1329
```

---

URL: https://docs.sei.io/learn/accounts

# Sei Network Accounts: Dual Address System Explained

> Understand how Sei's unified account system works with both EVM (0x) and Cosmos (sei1) addresses, including association methods, security considerations, and cross-environment interactions.

Every account on Sei has a unique public key. This public key can be used to
generate multiple wallet addresses, but it is important to note that the two are
functionally the same. They appear different, and depending on the app they may
be used interchangeably, but they both point to the same destination - your
account. The difference is like the difference between the numeral "2" and the
word "two". They both define the same value, but may be used in different
contexts.

* **"hex" Address**: Starts with `0x` and is EVM-based.

* **"bech32" Address**: Starts with `sei1` and is used for Cosmos functions.

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/address-derivation.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=23cfcb90fbd44a69781b884302670b92" alt="Address derivation" width="1600" height="900" data-path="assets/address-derivation.png" />

Although these addresses appear different, they actually share the same
underlying account. Once the two addresses are linked through association
(described below), whatever action you take with one address also affects the
other.

Once associated, if you deposit funds into your EVM address you can access and
use those same funds with your SEI address, and vice versa — they behave as one
account, ensuring seamless integration between the EVM and SEI ecosystems. Until
the addresses are associated, they are treated as separate accounts with
separate balances (see **Before Linking** below).

Both addresses for a single account are derived from the same **public key**, but the chain can only determine their association **after the public key is known by the chain** via association.

## Key Points

### Before Linking

* The Bech32 (`sei...`) and EVM (`0x...`) addresses are treated as **separate
  accounts**.
* They will have separate balances until linked.
* Cosmos tokens received by the EVM address prior to association will be held in
  a temporary Cosmos Bech32 address, which will transfer to the associated address upon
  linking.
* Some types of transactions will **not be possible** (see table below).

### After Linking

* Balances are reflected consistently across both addresses.
* Applications can query either address format seamlessly.

## Wallet Association and Transfer Limitations

Certain actions are **not possible** before wallets are associated:

* Transfers of **CW-based tokens** (e.g., CW20/721/1155) from a non-EVM wallet
  to an **unassociated EVM address**.
* Transfers of **ERC-based tokens** (e.g., ERC20/721/1155) from an EVM wallet to
  an **unassociated Cosmos address**.

## Methods of Association

| Method                     | Security Risk | User Action Required                                                     |
| -------------------------- | ------------- | ------------------------------------------------------------------------ |
| 1. Broadcast a Transaction | Low           | Association happens automatically                                        |
| 2. Direct Private Key      | High          | Provide private key directly                                             |
| 3. Signed Message          | Medium        | Sign a predefined message to prove ownership *(recommended for wallets)* |
| 4. Public Key              | Low           | Provide a compressed public key for association                          |

<Info>Each method ensures the **public key** is known to the chain, enabling automatic association between the EVM-compatible and Bech32 addresses. All four go through the on-chain `addr` precompile (`0x0000000000000000000000000000000000001004`) or the EVM ante handler and are available on every Sei EVM RPC.</Info>

<Note>A previous "gasless" association flow that used the `sei_associate` JSON-RPC method has been retired — the method is part of the deprecated `sei_*` namespace and is not in the default `enabled_legacy_sei_apis` allowlist, so it returns `legacy_sei_deprecated` on public RPCs. Method 3 covers the same wallet-signed-message UX without depending on a gated endpoint. Node operators who want to re-enable the legacy method on their own infrastructure can add `sei_associate` to `enabled_legacy_sei_apis` in `app.toml` — see [Node Operators](/node/node-operators) for the surrounding config.</Note>

Constants for the `addr` precompile can also be found in the repo
[Sei-Chain/precompiles](https://github.com/sei-protocol/sei-chain/tree/main/precompiles/addr):

## Method 1: Broadcast a Transaction

* When an account **broadcasts a transaction** (e.g., sending tokens), its
  public key is recorded on-chain.
* Once the public key is known, the **EVM address** and **Bech32 address** are
  linked automatically.
* This ensures balances and transactions are accessible across both address
  formats.

## Method 2: Direct Private Key Association

<Danger>**Security Risk**: **High** – Requires the private key to be directly available. Exposing the private key can compromise the wallet.</Danger>

This method directly uses the private key to interact with the network.

```ts theme={"dark"}
import { createPublicClient, createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { seiTestnet } from 'viem/chains';
import { ADDRESS_PRECOMPILE_ABI, ADDRESS_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

const PRIVATE_KEY = '<replace_with_private_key>';

const publicClient = createPublicClient({
	chain: seiTestnet,
	transport: http()
});
const client = createWalletClient({ chain: seiTestnet, transport: http() });

const account = privateKeyToAccount(PRIVATE_KEY);

const response = await client.writeContract({
	account,
	address: ADDRESS_PRECOMPILE_ADDRESS,
	abi: ADDRESS_PRECOMPILE_ABI,
	functionName: 'associate',
	args: ['0', '0', '0', 'example_message'],
	gasPrice: BigInt(100_000_000_000)
});
console.log(response);
```

## Method 3: Associate via Signed Message

<Warning>**Security Risk**: **Medium** – Requires signing a specific message using the private key.</Warning>

This method involves signing a predefined message to prove ownership of the
account.

```ts theme={"dark"}
import { createWalletClient, http, parseSignature, toHex } from 'viem';
import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
import { seiTestnet } from 'viem/chains';
import { ADDRESS_PRECOMPILE_ABI, ADDRESS_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

const client = createWalletClient({ chain: seiTestnet, transport: http() });

const associate = async () => {
	const account = privateKeyToAccount('<replace_with_private_key>');
	const newPk = generatePrivateKey();
	const newAccount = privateKeyToAccount(newPk);

	const message = 'associate';
	const signature = await newAccount.signMessage({ message });
	const parsedSignature = parseSignature(signature);
	const customMessage = `\x19Ethereum Signed Message:\n${message.length}${message}`;

	const response = await client.writeContract({
		account,
		address: ADDRESS_PRECOMPILE_ADDRESS,
		abi: ADDRESS_PRECOMPILE_ABI,
		functionName: 'associate',
		args: [toHex(Number(parsedSignature.v) - 27), parsedSignature.r, parsedSignature.s, customMessage],
		gasPrice: BigInt(100_000_000_000)
	});
	console.log(response);
};

associate();
```

## Method 4: Associate via Public Key

<Info>**Security Risk**: **Low** – Involves using the public key, which is less sensitive than the private key.</Info>

This method compresses the public key and sends it for association.

```ts theme={"dark"}
import secp256k1 from 'secp256k1';
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
import { seiTestnet } from 'viem/chains';
import { ADDRESS_PRECOMPILE_ABI, ADDRESS_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

const client = createWalletClient({ chain: seiTestnet, transport: http() });

const associateViaPubkey = async () => {
	const account = privateKeyToAccount('<replace_with_private_key>');
	const newPk = generatePrivateKey();
	const newAccount = privateKeyToAccount(newPk);

	const publicKeyBuffer = Buffer.from(newAccount.publicKey.slice(2), 'hex');
	const compressedPubKey = secp256k1.publicKeyConvert(publicKeyBuffer, true);

	const response = await client.writeContract({
		account,
		address: ADDRESS_PRECOMPILE_ADDRESS,
		abi: ADDRESS_PRECOMPILE_ABI,
		functionName: 'associatePubKey',
		args: [Buffer.from(compressedPubKey).toString('hex')],
		gasPrice: BigInt(100_000_000_000)
	});
	console.log(response);
};

associateViaPubkey();
```

## Query Linked Addresses

Resolve either side of an existing association by calling the `addr` precompile at `0x0000000000000000000000000000000000001004` over a standard `eth_call`. The precompile is universally available on every Sei RPC.

### Fetch Bech32 Address for an EVM Address

```bash theme={"dark"}
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
}'
```

The selector `0x0c3c20ed` is `getSeiAddr(address)`. The returned ABI-encoded string is the bech32 `sei1…` address, or the call reverts if the EVM address is not yet associated.

In TypeScript with viem:

```ts theme={"dark"}
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…'],
});
```

### Fetch EVM Address for a Sei Address

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

The precompile reverts if the address has never been associated; surface this as "not linked" rather than re-throwing.

## Deriving Addresses from the Public Key

Both address formats come from the same secp256k1 public key, but they use
**different hashing schemes**: the bech32 (`sei1…`) side follows the standard
Cosmos derivation (`SHA256` then `RIPEMD160` of the **compressed** pubkey), and
the EVM (`0x…`) side follows the standard Ethereum derivation (`keccak256` of
the **uncompressed** pubkey without its `0x04` prefix byte).

### Sei Address Derivation

The Cosmos address is derived from the public key using the following steps:

1. Take the **compressed** secp256k1 public key (33 bytes; first byte `0x02` or `0x03`).
2. Hash it with `SHA256`.
3. Hash the result with `RIPEMD160` to get a 20-byte digest.
4. Encode that digest in **Bech32 format** with the `sei` prefix.

Example implementation:

```ts theme={"dark"}
import { bech32 } from 'bech32';
import { sha256 } from '@noble/hashes/sha256';
import { ripemd160 } from '@noble/hashes/ripemd160';

/**
 * @param compressedPublicKey 33-byte secp256k1 pubkey in compressed form
 */
export function deriveSeiAddress(compressedPublicKey: Uint8Array): string {
  const digest = ripemd160(sha256(compressedPublicKey));
  return bech32.encode('sei', bech32.toWords(digest));
}
```

### EVM Address Derivation

The EVM-compatible address is derived as follows:

1. Take the **uncompressed** secp256k1 public key (65 bytes; first byte `0x04`).
2. Drop the leading `0x04` prefix byte so the input to the hash is the bare 64-byte `(x, y)` coordinate pair.
3. Hash with `keccak256`.
4. Take the **last 20 bytes** of the hash and format as `0x…` hex.

Example implementation:

```ts theme={"dark"}
import { keccak_256 } from '@noble/hashes/sha3';

/**
 * @param uncompressedPublicKey 65-byte secp256k1 pubkey in uncompressed form (leading 0x04)
 */
export function deriveEVMAddress(uncompressedPublicKey: Uint8Array): string {
  const hash = keccak_256(uncompressedPublicKey.slice(1));
  return `0x${Buffer.from(hash.slice(-20)).toString('hex')}`;
}
```

### Summary

* **Sei Address**: `bech32('sei', RIPEMD160(SHA256(compressedPubKey)))` — 20 bytes, Cosmos-standard derivation.
* **EVM Address**: `'0x' + keccak256(uncompressedPubKey[1:])[-20:]` — last 20 bytes of the keccak256 hash, Ethereum-standard derivation.
* The two formats share an account because the chain stores the **public key** itself on association; either format can be derived from it deterministically.

### Why It Works

Both formats are deterministic, public-key-derived address schemes. Once the
public key is on-chain (via any of the four association methods above, or
implicitly via a first signed transaction), the chain can derive both formats
itself and route any incoming reference to the same account.

### Recap

* Accounts are automatically linked when a transaction is broadcast, or can be
  associated manually via the `addr` precompile (`associate` / `associatePubKey`).
* Both address formats share the same **public key**.
* Linking enables dApps and tools to access balances consistently across both
  address formats.

## HD Paths and Coin Types

When deriving a private key from a mnemonic phrase, the hierarchical
deterministic (HD) path involves multiple parameters, including the coin type.
The coin type determines the blockchain ecosystem for which the key is derived,
making it crucial when dealing with different wallets and blockchains.

### Coin Type Parameter

The second parameter in the HD path specifies the coin type, which is defined by
the BIP-44 standard. This parameter identifies the blockchain ecosystem
associated with the derived keys.

* **Ethereum (Coin Type 60)**: Wallets like MetaMask use coin type 60. The HD
  path for Ethereum typically looks like this: `m/44'/60'/0'/0/0`.
* **Cosmos (Coin Type 118)**: Wallets for Cosmos-based chains, such as OKX,
  use coin type 118. The HD path for Cosmos typically looks like this:
  `m/44'/118'/0'/0/0`.

### Implications

Due to the different coin types, a mnemonic phrase used to derive keys for
Ethereum (coin type 60) cannot be directly used in a Cosmos wallet (coin
type 118) to access the same accounts. This is because the HD path determines a
different set of keys for each coin type, meaning the derived addresses will
differ.

### Private Key Export

Users can export their private key from MetaMask (derived using coin type 60)
and import it into any Cosmos wallet. This works because the private key, once
derived, can be used across different blockchain ecosystems, provided the
receiving wallet supports the import function. This allows users to manage their
assets across various blockchains using the same underlying cryptographic key.

### Example HD Paths

* **Traditional Cosmos Path**: `m/44'/118'/0'/0/0`
* **Traditional EVM Path**: `m/44'/60'/0'/0/0`

## Generating Wallets

### Deriving bech32 and hex addresses from pubkey

Sei derives both the Cosmos/Tendermint style bech32 address and the
Ethereum-style hex address from the same public key, but each format uses its
own hashing scheme: the bech32 address uses the Cosmos-standard `SHA256` then
`RIPEMD160`, while the hex address uses the `keccak256` method common in EVM
networks. These extensively commented snippets demonstrate the 'proper' method
of deriving both bech32 and hex addresses from a given ECDSA SECP256k1 key:

<Accordion title="Python - from pubkey">
  ```python theme={"dark"}
  import base64
  import json
  from hashlib import sha256, new as hashlib_new
  from coincurve import PublicKey
  from bech32 import bech32_encode, convertbits
  from Crypto.Hash import keccak

  # Example input, replace with the actual pubkey JSON string
  pubkey_json = '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"Agmik4xkmF57hNjzykYHP3gRu1Mpae4B5BCiwx7jmRzI"}'

  # Extract the base64-encoded key from the JSON-like string
  pubkey_dict = json.loads(pubkey_json)
  pubkey_base64 = pubkey_dict['key']

  # Decode the base64-encoded public key
  public_key_compressed = base64.b64decode(pubkey_base64)

  # Ensure the public key length is 33 bytes (compressed key format)
  if len(public_key_compressed) != 33:
      raise ValueError(f"Invalid public key length, expected 33 bytes for compressed format, got {len(public_key_compressed)}")

  # Debugging: Print the public key details
  print(f"Compressed public key (hex): {public_key_compressed.hex()}")

  # SHA-256 on the compressed public key
  sha256_digest = sha256(public_key_compressed).digest()
  # Debugging: Print SHA-256 digest
  print(f"SHA-256 Digest: {sha256_digest.hex()}")

  # RIPEMD-160 on SHA-256 hash
  ripemd160 = hashlib_new('ripemd160')
  ripemd160.update(sha256_digest)
  ripemd160_digest = ripemd160.digest()
  # Debugging: Print RIPEMD-160 digest
  print(f"RIPEMD-160 Digest: {ripemd160_digest.hex()}")

  # Convert the digest to 5-bit groups for Bech32 encoding
  five_bit_ripemd160 = convertbits(ripemd160_digest, 8, 5, pad=True)
  bech32_address = bech32_encode("sei", five_bit_ripemd160)

  print(f"Bech32 Cosmos Address: {bech32_address}")

  # Decompress the public key to 65 bytes
  public_key = PublicKey(public_key_compressed).format(compressed=False)

  # Debugging: Print the public key details
  print(f"Decompressed public key length: {len(public_key)}")
  print(f"Decompressed public key (hex): {public_key.hex()}")

  # Derive Ethereum Address using Keccak-256
  keccak_hash = keccak.new(digest_bits=256)
  keccak_hash.update(public_key[1:])  # Exclude the first byte (0x04)
  digest_keccak = keccak_hash.digest()
  eth_address = digest_keccak[-20:]
  eth_address_hex = '0x' + eth_address.hex()

  print(f"Ethereum Address: {eth_address_hex}")
  ```
</Accordion>

<Accordion title="Typescript - from pubkey">
  ```typescript theme={"dark"}
  import { fromBase64 } from '@cosmjs/encoding';
  import { sha256 } from '@noble/hashes/sha256';
  import { ripemd160 } from '@noble/hashes/ripemd160';
  import { keccak_256 } from '@noble/hashes/sha3';
  import { secp256k1 } from '@noble/curves/secp256k1';
  import { bech32 } from 'bech32';

  // Utility function to convert bits for Bech32 encoding
  function convertBits(data: Uint8Array, fromBits: number, toBits: number, pad: boolean): number[] {
    let acc = 0;
    let bits = 0;
    const result: number[] = [];
    const maxv = (1 << toBits) - 1;

    for (const value of data) {
      acc = (acc << fromBits) | value;
      bits += fromBits;
      while (bits >= toBits) {
        bits -= toBits;
        result.push((acc >> bits) & maxv);
      }
    }

    if (pad) {
      if (bits > 0) {
        result.push((acc << (toBits - bits)) & maxv);
      }
    } else if (bits >= fromBits || (acc << (toBits - bits)) & maxv) {
      throw new Error('Unable to convert bits');
    }

    return result;
  }

  // Define the prefix for the Bech32 address (e.g., "sei" for Sei network)
  const chainPrefix = 'sei';

  // Public key JSON string (replace with actual data)
  const pubkeyJson = '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"AiN+aFvHgjblWPaP9Er5p005JjPX3nj4I/+jA6W4BOho"}';

  // Parse the JSON string to extract the public key in Base64 format
  const pubkeyDict = JSON.parse(pubkeyJson);
  const pubkeyBase64 = pubkeyDict.key;

  console.log('Original public key JSON:', pubkeyJson);
  console.log('Parsed public key object:', pubkeyDict);
  console.log('Base64-encoded public key:', pubkeyBase64);

  // Decode the Base64-encoded public key to its compressed form
  const publicKeyCompressed = fromBase64(pubkeyBase64);

  console.log('Compressed public key (bytes):', publicKeyCompressed);
  console.log('Compressed public key (hex):', Buffer.from(publicKeyCompressed).toString('hex'));

  // Perform SHA-256 hashing on the compressed public key
  const sha256Digest = sha256(publicKeyCompressed);
  console.log('SHA-256 hash of public key (hex):', Buffer.from(sha256Digest).toString('hex'));

  // Perform RIPEMD-160 hashing on the SHA-256 digest
  const ripemd160Digest = ripemd160(sha256Digest);
  console.log('RIPEMD-160 hash of SHA-256 hash (hex):', Buffer.from(ripemd160Digest).toString('hex'));

  // Convert the RIPEMD-160 digest to a 5-bit array for Bech32 encoding
  const fiveBitArray = convertBits(ripemd160Digest, 8, 5, true);

  // Encode the 5-bit array into a Bech32 address with the specified prefix
  const bech32Address = bech32.encode(chainPrefix, fiveBitArray);

  console.log(`Bech32 Cosmos Address: ${bech32Address}`);

  // Decompress the public key to its uncompressed form (65 bytes) and exclude the first byte
  const publicKeyUncompressed = secp256k1.ProjectivePoint.fromHex(publicKeyCompressed).toRawBytes(false).slice(1);

  // Perform Keccak-256 hashing on the uncompressed public key to derive the Ethereum address
  const keccakHash = keccak_256(publicKeyUncompressed);
  const ethAddress = '0x' + Buffer.from(keccakHash.slice(-20)).toString('hex');

  console.log('Uncompressed public key (hex):', Buffer.from(publicKeyUncompressed).toString('hex'));
  console.log('Keccak-256 hash of uncompressed public key (hex):', Buffer.from(keccakHash).toString('hex'));
  console.log(`Ethereum Address: ${ethAddress}`);
  ```
</Accordion>

<Accordion title="Typescript - Full Derivation from Private Key">
  ```typescript theme={"dark"}
  import { sha256 } from '@noble/hashes/sha256';
  import { ripemd160 } from '@noble/hashes/ripemd160';
  import { keccak_256 } from '@noble/hashes/sha3';
  import { secp256k1 } from '@noble/curves/secp256k1';
  import { bech32 } from 'bech32';

  // Utility function to convert bits for Bech32 encoding
  function convertBits(data: Uint8Array, fromBits: number, toBits: number, pad: boolean): number[] {
    let acc = 0;
    let bits = 0;
    const result: number[] = [];
    const maxv = (1 << toBits) - 1;

    for (const value of data) {
      acc = (acc << fromBits) | value;
      bits += fromBits;
      while (bits >= toBits) {
        bits -= toBits;
        result.push((acc >> bits) & maxv);
      }
    }

    if (pad) {
      if (bits > 0) {
        result.push((acc << (toBits - bits)) & maxv);
      }
    } else if (bits >= fromBits || (acc << (toBits - bits)) & maxv) {
      throw new Error('Unable to convert bits');
    }

    return result;
  }

  // Function to generate addresses from a private key
  function generateAddresses(privateKeyHex: string): {
    seiAddress: string;
    ethAddress: string;
  } {
    // Ensure the private key is exactly 32 bytes long
    const privateKey = Uint8Array.from(Buffer.from(privateKeyHex.padStart(64, '0'), 'hex'));
    if (privateKey.length !== 32) {
      throw new Error('Private key must be 32 bytes long.');
    }

    // Derive the compressed public key from the private key
    const publicKey = secp256k1.getPublicKey(privateKey, true);
    const publicKeyBytes = publicKey;

    // Perform SHA-256 hashing on the compressed public key
    const sha256Digest = sha256(publicKeyBytes);

    // Perform RIPEMD-160 hashing on the SHA-256 digest
    const ripemd160Digest = ripemd160(sha256Digest);

    // Convert the RIPEMD-160 digest to a 5-bit array for Bech32 encoding
    const fiveBitArray = convertBits(ripemd160Digest, 8, 5, true);

    // Bech32 address with "sei" prefix
    const seiAddress = bech32.encode('sei', fiveBitArray, 256);

    // Derive the uncompressed public key from the private key and exclude the first byte
    const publicKeyUncompressed = secp256k1.getPublicKey(privateKey, false).slice(1);

    // Perform Keccak-256 hashing on the uncompressed public key to derive the Ethereum address
    const keccakHash = keccak_256(publicKeyUncompressed);
    const ethAddress = `0x${Buffer.from(keccakHash).slice(-20).toString('hex')}`;

    return { seiAddress, ethAddress };
  }

  // Example usage of the generateAddresses function
  const privateKeyHex = '907ab4bf7fc60cff';
  const { seiAddress, ethAddress } = generateAddresses(privateKeyHex);

  console.log(`Sei Address: ${seiAddress}`);
  console.log(`Ethereum Address: ${ethAddress}`);
  ```
</Accordion>

---

URL: https://docs.sei.io/learn/sip-03-migration

# SIP-03 Migration Guide

> Practical steps and resources for users and exchanges migrating during SIP-03, including asset transfer, USDC, and exchange migration guidance.

<Danger>
  **Action required: IBC assets on Sei will become inaccessible**

  If you hold [USDC.n](https://seiscan.io/address/0x3894085Ef7Ff0f0aeDf52E2A2704928d1Ec074F1) (USDC via Noble), [USDT.kava](https://seiscan.io/address/0xb75d0b03c06a926e488e2659df1a861f860bd3d1) (Kava USDT), Wormhole-bridged tokens, or any other IBC asset on Sei, you **must** swap, migrate, or bridge out **before [Proposal #116](https://www.mintscan.io/sei/proposals/116) (disables inbound IBC transfers) passes and is activated** to avoid permanent loss of access. After this, Sei will no longer support IBC bridging of assets from Cosmos-based chains to and from Sei Network.

  Consult the [IBC Asset Migration Table](#ibc-asset-migration-table) below for the full list of affected assets, required actions, and supported routes.

  For USDC.n specifically, see: [Holders of USDC.n Need to Swap or Migrate](https://blog.sei.io/announcements/holders-of-usdcn-need-to-swap-or-migrate/).
</Danger>

This page consolidates the most important, practical actions for the SIP-03 migration and links to the official resources.

<Info>
  For the full proposal text, see:

  * The [official SIP-03](https://github.com/sei-protocol/sips/blob/main/sips/sip-3.md)

  * Governance [Proposal #99](https://www.mintscan.io/sei/proposals/99) — initiated the migration

  * Governance [Proposal #115](https://www.mintscan.io/sei/proposals/115) — disables CosmWasm code uploads and contract instantiations. After this passes, no new CosmWasm contracts can be deployed on Sei.

  * Governance [Proposal #116](https://www.mintscan.io/sei/proposals/116) — disables inbound IBC transfers. After this passes and is activated, IBC assets bridged from Cosmos chains can no longer arrive on Sei.
</Info>

## What most users need to do

* If you use Keplr or Leap (Cosmos-style wallets) and hold assets on the native address (sei1...), you should move assets to an EVM-compatible address (0x...). Use the Asset Transfer tool linked below.
* If you use Compass or another EVM wallet already, you’re good — continue as normal.

## IBC Asset Migration Table

If you hold any of the following IBC assets on Sei, take action before [Proposal #116](https://www.mintscan.io/sei/proposals/116) (disables inbound IBC transfers) passes and is activated.

\[We’ll update this table as more resources are made available]

| Asset                            | Token contract                                                                                                                                                                                         | Action(s)                               | Possible route(s)                                                                                                                                                                                                                  | Support                                                                                                                                                                                            |
| :------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **USDC.n (USDC via Noble)**      | [seiscan](https://seiscan.io/address/0x3894085ef7ff0f0aedf52e2a2704928d1ec074f1) [mintscan](https://www.mintscan.io/sei/assets/ibc%2FCA6FBFAF399474A06263E10D0CE5AEBBE15189D6D4B2DD9ADE61007E68EB9DB0) | Swap to native USDC or migrate via CCTP | [Saphyre](https://saphyre.xyz/swap?inputCurrency=0x3894085Ef7Ff0f0aeDf52E2A2704928d1Ec074F1\&outputCurrency=0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392), [Symphony](https://symph.ag/), or [CCTP Exchange](https://cctp.exchange/) | [Sei blog](https://blog.sei.io/announcements/holders-of-usdcn-need-to-swap-or-migrate/) [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk)  [Discord](https://discord.com/invite/sei?ref=blog.sei.io) |
| **USDT.kava (USDT via Kava)**    | [seiscan](https://seiscan.io/token/0xb75d0b03c06a926e488e2659df1a861f860bd3d1) [mintscan](https://www.mintscan.io/sei/assets/ibc%2F6C00E4AA0CC7618370F81F7378638AE6C48EFF8C9203CE1C2357012B440EBDB7)   | Swap to a native asset via Symphony     | [Symphony](https://symph.ag/)                                                                                                                                                                                                      | [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk)  [Discord](https://discord.com/invite/sei)                                                                                                         |
| **USDCso (Wormhole, Solana)**    | [mintscan](https://www.mintscan.io/sei/assets/factory%2Fsei189adguawugk3e55zn63z8r9ll29xrjwca636ra7v7gxuzn98sxyqwzt47l%2F9fELvUhFo6yWL34ZaLgPbCPzdk9MD1tAzMycgH45qShH)                                 | Bridge out to Solana via Wormhole       | [Portal Bridge (legacy)](https://legacy.portalbridge.com/#/transfer)                                                                                                                                                               | [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk) [Discord](https://discord.com/invite/sei)                                                                                                          |
| **Wormhole-bridged WETH**        | [mintscan](https://www.mintscan.io/sei/assets/factory%2Fsei189adguawugk3e55zn63z8r9ll29xrjwca636ra7v7gxuzn98sxyqwzt47l%2F4tLQqCLaoKKfNFuPjA9o39YbKUwhR1F8N29Tz3hEbfP2)                                 | Bridge out to Ethereum via Wormhole     | [Portal Bridge (legacy)](https://legacy.portalbridge.com/#/transfer)                                                                                                                                                               | [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk)  [Discord](https://discord.com/invite/sei)                                                                                                         |
| **USDCet (Wormhole, Ethereum)**  | [mintscan](https://www.mintscan.io/sei/assets/factory%2Fsei189adguawugk3e55zn63z8r9ll29xrjwca636ra7v7gxuzn98sxyqwzt47l%2FHq4tuDzhRBnxw3tFA5n6M52NVMVcC19XggbyDiJKCD6H)                                 | Bridge out to Ethereum via Wormhole     | [Portal Bridge (legacy)](https://legacy.portalbridge.com/#/transfer)                                                                                                                                                               | [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk)  [Discord](https://discord.com/invite/sei)                                                                                                         |
| **USDCop (Wormhole, Optimism)**  | [mintscan](https://www.mintscan.io/sei/assets/factory%2Fsei189adguawugk3e55zn63z8r9ll29xrjwca636ra7v7gxuzn98sxyqwzt47l%2F3VKKYtbQ9iq8f9CaZfgR6Cr3TUj6ypXPAn6kco6wjcAu)                                 | Bridge out to Optimism via Wormhole     | [Portal Bridge (legacy)](https://legacy.portalbridge.com/#/transfer)                                                                                                                                                               | [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk)  [Discord](https://discord.com/invite/sei)                                                                                                         |
| **USDTbs (Wormhole, BSC Chain)** | [mintscan](https://www.mintscan.io/sei/assets/factory%2Fsei189adguawugk3e55zn63z8r9ll29xrjwca636ra7v7gxuzn98sxyqwzt47l%2F871jbn9unTavWsAe83f2Ma9GJWSv6BKsyWYLiQ6z3Pva)                                 | Bridge out to BSC Chain via Wormhole    | [Portal Bridge (legacy)](https://legacy.portalbridge.com/#/transfer)                                                                                                                                                               | [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk)  [Discord](https://discord.com/invite/sei)                                                                                                         |
| **ATOM**                         | [mintscan](https://www.mintscan.io/sei/assets/ibc%2FC4CFF46FD6DE35CA4CF4CE031E643C8FDC9BA4B99AE598E9B0ED98FE3A2319F9)                                                                                  | Bridge out to Cosmos Hub                | Skip:Go                                                                                                                                                                                                                            | [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk) [Discord](https://discord.com/invite/sei)                                                                                                          |
| **WBTC**                         | [mintscan](https://www.mintscan.io/sei/assets/factory%2Fsei189adguawugk3e55zn63z8r9ll29xrjwca636ra7v7gxuzn98sxyqwzt47l%2F7omXa4gryZ5NiBmLep7JsTtTtANCVKXwT9vbN91aS1br)                                 | Bridge out to origin chain              | Skip:Go                                                                                                                                                                                                                            | [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk)  [Discord](https://discord.com/invite/sei)                                                                                                         |

The mention of third-party platforms does not constitute an endorsement. Users should do their own research before using any third-party service.

## Key tools and resources

### 1) Asset Transfer (Native ↔ EVM)

* Use the official Sei Dashboard to move assets between native (Keplr/Leap/Fin) and EVM (MetaMask/Compass etc.) addresses: [Sei Dashboard Transfer](https://dashboard.sei.io/evm-upgrade) or the Bridge tab at [Sei Dashboard Bridge](https://dashboard.sei.io/bridge).

When to use this:

* You used Keplr or Leap before and want assets available via an EVM wallet going forward.
* You need to access tokens on apps that now expect an EVM (0x) address.

### 2) USDC on Sei

Native USDC and Circle's CCTP V2 are now supported on Sei. USDC from Noble (USDC.n) is deprecated.

* QuickStart: [USDC on Sei](/evm/usdc-on-sei)
* Background: [USDC & CCTP v2 announcement](https://www.circle.com/blog/native-usdc-and-cctp-v2-are-coming-to-sei)

#### How to swap or migrate USDC.n

**Swap (smaller amounts):**

* [DragonSwap](https://dragonswap.app/) or [Symphony](https://symph.ag/?tokenIn=0x3894085ef7ff0f0aedf52e2a2704928d1ec074f1\&tokenOut=0xe15fc38f6d8c56af07bbcbe3baf5708a2bf42392) — slippage may vary depending on market conditions and liquidity.

**Migrate (larger amounts):**

USDC.n reached Sei over IBC from Noble, so larger balances are best migrated to native USDC by routing back through Noble — this avoids the slippage of a direct DEX swap.

* IBC-transfer your USDC.n from Sei back to Noble, where it becomes native Noble USDC, then use Circle's CCTP to mint native USDC on Sei. [CCTP Exchange](https://cctp.exchange/) is a useful frontend for the CCTP leg.

Complete this **before** the SIP-03 upgrade, while IBC routing through Noble is still available.

**For DeFi suppliers of USDC.n (Yei, Takara Lend, etc.):**

* Wind down and withdraw your positions **before** migrating to native USDC. Failure to do so before the SIP-03 upgrade may result in inability to access your supplied assets.

### 3) Address Association (Seistream)

[Seistream's SIP-03 migration page](https://seistream.app/migrate-sip03) links your EVM (`0x...`) and Cosmos (`sei1...`) addresses for the **native SEI token** in three guided steps. It is a community-built tool that streamlines the standard association flow.

Address association is the one-time, on-chain step that links your `0x...` and `sei1...` addresses so a single key controls both. It must be completed **before** the SIP-03 upgrade — afterward, Cosmos (`sei1...`) interfaces stop working and addresses can no longer be associated. See [Account Linking](/learn/accounts) for how association works under the hood.

What the tool does:

1. **Connect wallet** — connect any EVM wallet with an injected provider (MetaMask, Keplr, Rabby, Compass, Tangem, Trust Wallet, OKX, and most others).
2. **Gas + association** — cover the small amount of SEI needed for gas (Seistream provides a mainnet faucet to help), then submit the transaction that associates your `0x...` and `sei1...` addresses on-chain. Any outgoing EVM transaction registers the link automatically.
3. **Transfer from Cosmos** — send your existing native SEI from the old Cosmos wallet to the linked `sei1...` address, where it becomes spendable from your EVM wallet.

This is a streamlined alternative to the manual association flow in [Migrating a hardware or mnemonic-only wallet](#migrating-a-hardware-or-mnemonic-only-wallet).

<Warning>
  Seistream handles association for the **native SEI token only**. For USDC, USDT, ATOM, WBTC, and other IBC-bridged assets, use the [IBC Asset Migration Table](#ibc-asset-migration-table). Seistream is a third-party tool; its inclusion here is not an endorsement, and you should do your own research before connecting a wallet.
</Warning>

## Migrating a hardware or mnemonic-only wallet

If your wallet can export a raw private key, the simplest path is to import that key into an EVM wallet. A private key is independent of coin type, so it reproduces the same `0x...` and `sei1...` addresses in any wallet, and no funds need to move.

If your wallet cannot export a private key, you can still migrate by moving your funds to a new EVM-native account, as described below.

### When private-key export isn't an option

A raw private key always works, but two common setups do not provide one:

* **Mnemonic-only wallets.** Some wallets back up only a recovery phrase, not a raw private key. Sei's Cosmos (`sei1...`) accounts use coin type 118 (`m/44'/118'/0'/0/0`). Importing the same phrase into an EVM wallet such as MetaMask derives it on coin type 60 (`m/44'/60'/0'/0/0`), producing a different account with no access to the original funds. The underlying private key would import correctly if the wallet exposed it, but a mnemonic-only wallet does not.
* **Hardware wallets (such as Ledger).** A Ledger does not export the private key or seed under any circumstances. It only allows switching between the Cosmos app (coin type 118) and the Ethereum app (coin type 60), which control separate accounts with different addresses. The Cosmos-app account cannot be used from an EVM wallet.

For background, see [HD Paths and Coin Types](/learn/accounts#hd-paths-and-coin-types).

### Migration steps

This works because every account has exactly one EVM (`0x...`) address and one Cosmos (`sei1...`) address, both derived from the same key. Funds sent to the new account's `sei1...` address are therefore spendable from the EVM wallet that holds its `0x...` address.

<Tip>
  Prefer a guided flow? [Seistream's SIP-03 migration tool](https://seistream.app/migrate-sip03) walks through these same steps — connect an EVM wallet, cover gas, associate addresses, then transfer native SEI from the Cosmos side. See [Address Association (Seistream)](#3-address-association-seistream). It covers native SEI only; the manual steps below work for any wallet you control.
</Tip>

<Steps>
  <Step title="Create a new account in an EVM wallet you control">
    Use MetaMask, Compass, Rabby, or a Ledger running its Ethereum app. This produces a new `0x...` address.
  </Step>

  <Step title="Fund the new address with a small amount of SEI">
    Roughly 0.1 SEI is sufficient. Association is an on-chain transaction, so the account requires SEI for gas. Fund it from an exchange withdrawal or from any EVM wallet that already holds SEI.
  </Step>

  <Step title="Associate the new account on the Sei Dashboard">
    Connect the new EVM account to the [Sei Dashboard](https://dashboard.sei.io) and complete address association. This records the public key on-chain and links the `0x...` address to its `sei1...` counterpart. The dashboard then displays the linked `sei1...` address, which is the destination for the next step. See [Account Linking](/learn/accounts) for details on association.
  </Step>

  <Step title="Send a test transfer of 1 SEI">
    From the original Cosmos wallet (Keplr, Leap, the Ledger Cosmos app, and so on), send 1 SEI to the `sei1...` address from step 3. This is a standard Cosmos-to-Cosmos transfer.
  </Step>

  <Step title="Confirm receipt">
    Because the addresses are associated, the test amount should appear under the new account on the dashboard and as a spendable balance in the EVM wallet.
  </Step>

  <Step title="Transfer the remaining balance">
    Once the test transfer is confirmed, send the rest of the funds the same way. The assets are then held by an account whose key you control from an EVM wallet.
  </Step>
</Steps>

<Warning>
  Send the 1 SEI test transfer and confirm receipt before moving the full balance. Verify that the destination matches the exact `sei1...` address shown after association in step 3.
</Warning>

### Notes and limitations

* **Complete this before the SIP-03 upgrade.** After the Cosmos interface is deprecated, addresses can no longer be associated and `sei1...` transfers can no longer be broadcast. Steps 3 and 4 must be completed beforehand.
* **This procedure moves liquid balances only.** Staked SEI must be unbonded first, and the unbonding period is 21 days. See the staking question in the [FAQ](#faq).
* **Associate before sending.** Associating the new account before transferring ensures the funds arrive at the correct, immediately spendable address rather than a temporary holding address.
* **Optional verification.** To confirm the paired `sei1...` address independently, call `getSeiAddr(0x...)` on the `addr` precompile. See [Query Linked Addresses](/learn/accounts#query-linked-addresses).

## FAQ

### I am a Keplr / Leap wallet user; do I need to do anything?

Yes. Use the Asset Transfer tool to ensure your assets are available via an EVM wallet. See Asset Transfer above.

### I use Compass wallet; do I need to do anything?

No action needed. Compass ensures your assets are available via EVM. Continue connecting to Sei like any EVM chain.

### My wallet only shows a recovery phrase, or I use a Ledger — how do I migrate?

If you can export a raw private key, import it into an EVM wallet. This always works, because the key reproduces the same addresses in any wallet. If you cannot (a wallet that exports only a recovery phrase, or a Ledger that only switches between apps), create a new account in an EVM wallet you control, fund it with a small amount of SEI, associate it to reveal its paired `sei1...` address, and send your existing Cosmos funds to that address. Send a 1 SEI test transfer first. See [Migrating a hardware or mnemonic-only wallet](#migrating-a-hardware-or-mnemonic-only-wallet) for the full procedure.

### I stake SEI — do I need to do anything?

It depends on whether your Cosmos (`sei1...`) and EVM (`0x...`) addresses are **associated (linked)**. Staking on Sei is handled by the Cosmos staking module. After SIP-03, Cosmos-native transaction interfaces will no longer be available — but the underlying staking state is preserved and accessible via EVM for associated addresses.

**If your addresses are associated:** No action is needed. After the upgrade, your existing delegations, rewards, and unbonding state will be fully accessible via EVM. You can continue managing your stake through an EVM wallet using the [Staking Precompile](/evm/precompiles/staking) or the [Sei Dashboard](https://dashboard.sei.io/stake).

**If your addresses are NOT associated:** You must act before the upgrade. After SIP-03, you will not be able to associate addresses or manage delegations through a Cosmos wallet.

Your options:

1. **Associate your addresses** before the upgrade. You can do this by connecting your Cosmos wallet on the [Sei Dashboard](https://dashboard.sei.io) or by using any of the methods described in [Accounts](/learn/accounts). Once associated, your staking state becomes accessible via EVM — no need to unbond.
2. **Unbond your stake** and migrate assets to an EVM wallet using the [Asset Transfer tool](https://dashboard.sei.io/evm-upgrade). **The unbonding period is 21 days**, so you must begin this process at least 21 days before the Cosmos shutdown to ensure your tokens are liquid in time.

To check whether your addresses are linked, see [Query Linked Addresses](/learn/accounts#query-linked-addresses).

<Warning>
  **Do not confuse address linking with staking migration.** Even though `sei1...` and `0x...` addresses point to the same underlying account once associated, the chain can only recognize this link after explicit association. Without association, your staked SEI will not be accessible via EVM after the upgrade, and you will have no way to unbond or claim rewards.
</Warning>

### I hold USDC.n (USDC via Noble) — what should I do?

You must swap or migrate your USDC.n to native USDC before the SIP-03 deprecation of Cosmos, CosmWasm and IBC related functionality, slated for **June 15, 2026**. After the upgrade, USDC.n may become inaccessible or lose its value on Sei. See the [USDC on Sei](#2-usdc-on-sei) section above for swap and migration options, or read the full announcement: [Holders of USDC.n Need to Swap or Migrate](https://blog.sei.io/announcements/holders-of-usdcn-need-to-swap-or-migrate/).

---

URL: https://docs.sei.io/learn/sip-03-exchange-migration

# Sei EVM Upgrade for Exchanges and Custodians

> Practical steps and resources for users and exchanges migrating during SIP-03, including asset transfer, USDC, and exchange migration guidance.

This section is for exchanges, custodians, and other service providers that currently support SEI token deposits and withdrawals using native (`sei1...`) addresses. It explains what SIP-03 changes, the options available for migrating customer holdings to EVM (`0x...`) addresses, and the timeline by which migration must be complete.

### What SIP-03 changes

For exchanges, the practical implication of the SIP-03 migration is that any integration treating "Sei" (native) and "Sei EVM" as two separate chains needs to be reconciled into a single integration before the Cosmos shutdown. Every native address (`sei1...`) on Sei has a corresponding EVM address (`0x...`) on the same chain. This is not two distinct chains or wallets, it is one chain with two ways to interact with it.

### Migration options

There are four ways an exchange/custodian can migrate customer holdings to EVM.

#### 1) Combine native and EVM access points

The exchange surfaces the EVM (`0x...`) address corresponding to each existing native (`sei1...`) wallet directly to the customer. Each `sei1...` address has exactly one corresponding `0x...` address, determined by the public key the addresses are derived from. They are not freely pairable, and association does not create the pairing, it only registers it onchain. Because the pairing already exists at the keypair level, no funds need to move.

This is the cleanest path and requires no customer action. It does require the exchange to:

* Derive or look up the EVM address for each native wallet under management.
* Ensure the native and EVM addresses are associated on-chain (see [Address association](#address-association) below).
* Update internal accounting and customer-facing UI to present the EVM address as the canonical Sei address.

#### 2) Automated forwarding contract

The exchange uses a `FundsForwarder` smart contract to programmatically move customer funds from the native side to the customer's EVM wallet on the exchange. The exchange handles deployment and triggering; the customer sees the funds arrive at the new address without taking any action themselves.

This is appropriate when the exchange cannot or does not want to expose EVM addresses for existing native wallets directly, but is willing to operate the migration itself.

#### 3) User-directed forwarding contract

The exchange notifies customers of the change and directs them to the `FundsForwarder` contract address. Customers initiate the transfer themselves; this action triggers the contract to automatically forward funds to the appropriate EVM wallet on the exchange.

This is functionally similar to option 2 but pushes the trigger action onto the customer. It is appropriate when the exchange cannot operate the contract directly but wants to provide an automated destination.

#### 4) Fully manual transfer

The exchange notifies customers of the change and asks them to manually withdraw funds to a self-custodial wallet and then redeposit them to the EVM address provided by the exchange.

### Address association

The first two options depend on the exchange's native and EVM addresses being **associated** on-chain. Association is the explicit on-chain link between a `sei1...` address and its corresponding `0x...` address. Without it, the chain cannot recognize that the two addresses belong to the same account, and funds held under the native address will not be accessible via EVM after support for CosmWasm is deprecated.

<Warning>
  **Address association must be completed prior to deprecation. After that point, there is no mechanism to associate addresses.**
</Warning>

For details on how to query association status and the methods for associating addresses, see [Accounts](/learn/accounts).

### FundsForwarder contract

The `FundsForwarder` is a one-way smart contract that accepts deposits at a native (`sei1...`) address and forwards the full balance to a pre-configured EVM (`0x...`) destination address. It is the underlying mechanism for options 2 and 3 above.

Key properties:

* The destination address is fixed at deployment and cannot be changed. Funds can only be forwarded to that address.
* The contract accepts deposits via native `sei1...` transfers and forwards the full balance to the configured `0x...` destination.
* The `FundsForwarder` was audited by OtterSec.

### Migration milestone

Address association must be completed prior to deprecation of all Cosmos, CosmWasm and IBC related functionality, slated for **June 15, 2026**. After deprecation:

* Exchanges and their users will not be able to access or transfer funds.
* Cosmos-native transaction interfaces will no longer be available. Exchanges will not be able to broadcast Cosmos-format transactions, sign with Cosmos key derivations against the live chain, or interact with the chain through Cosmos RPC endpoints.
* Address associations can no longer be created through a Cosmos wallet.
* The `FundsForwarder` pattern will no longer function for new deposits.

### Support

For technical questions about exchange migration, contact the Sei Labs team via the [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk) or [Discord](https://discord.com/invite/sei).

---

URL: https://docs.sei.io/learn/twin-turbo-consensus

# Twin Turbo Consensus: Sei's High-Speed Blockchain Consensus

> Explore how Sei's Twin Turbo consensus mechanism achieves higher transaction throughput by separating block building from consensus, with detailed explanations of the protocol's design and benefits.

## Introduction

Sei's consensus mechanism, often referred to as Twin Turbo Consensus, represents a suite of optimizations designed to achieve exceptionally low block finality times, targeting approximately 400 milliseconds. This rapid finality is not achieved through a novel consensus algorithm but rather through significant enhancements to the underlying Tendermint Byzantine Fault Tolerant (BFT) consensus engine, aggressive configuration tuning, and tight integration with Sei's parallel execution layer and SeiDB storage system. The goal is to provide near-instant transaction confirmation, enabling a new class of high-performance decentralized applications, particularly those built for the EVM.

## Core Concept: Pipelined & Parallelized Consensus

The key to achieving sub-second finality lies in aggressively optimizing and parallelizing the standard BFT consensus flow. While traditional Tendermint proceeds through distinct rounds of propose, prevote, precommit, and commit somewhat sequentially for each block height, Sei's approach heavily pipelines these operations and integrates them closely with parallel transaction execution.

This optimized flow involves several key enhancements:

1. **Aggressive Timeout Configuration:** Sei utilizes heavily tuned Tendermint consensus parameters. Configuration settings (e.g., `UnsafeProposeTimeoutOverride`, `UnsafeCommitTimeoutOverride`) enforce much shorter durations for block proposal, voting, and commit rounds compared to standard Tendermint configurations, directly contributing to the sub-second target block time. Faster gossip propagation for consensus messages further reduces communication latency between validators.
2. **Intelligent Mempool Management & Transaction Preparation:** Even before a block proposal is formally initiated for height `H`, validators can begin processing transactions intended for that block. This involves collecting transactions from the network, decoding them concurrently (`DecodeTransactionsConcurrently`), analyzing potential state dependencies (`GenerateEstimatedWritesets`), and potentially pre-fetching required state data from SeiDB. This "pre-consensus" preparation minimizes the work needed once the actual proposal for height `H` arrives.
3. **Optimized BFT Rounds with Parallel Execution Integration:** The critical optimization is the deep integration with Sei's parallelization engine. When a validator receives a block proposal for height `H`, it doesn't necessarily wait for the prevote/precommit rounds to complete before starting execution. Instead:
   * The block's transactions are dispatched to the parallel execution engine (`ProcessTXsWithOCC`, `DeliverTxBatch`).
   * Transaction execution proceeds *optimistically and concurrently* using multiple worker goroutines, managed via mechanisms like `CacheMultiStore` for state buffering.
   * Simultaneously, the validator participates in the standard BFT prevote and precommit voting rounds for the proposed block `H`.
4. **Rapid Finalization and Commit:** Because transaction execution overlaps significantly with the consensus voting process, the time delta between achieving 2/3+ precommits for block `H` and having the resulting state changes ready for commitment is drastically reduced. Once consensus is reached, the validated state changes buffered during parallel execution are efficiently committed to the underlying SeiDB storage layer, leveraging its high I/O capabilities.

**Optimized & Pipelined Consensus**

<Columns cols={2}>
  <Card horizontal title="Pre-Consensus (TX Preparation)">
    * Transaction Collection & Analysis
    * State Prefetching (SeiDB)
  </Card>

  <Card horizontal title="Optimized BFT Consensus (Voting & Concurrent Execution)">
    * Block Proposal Reception & Initial Validation
    * BFT Voting (Prevote/Precommit)
    * Parallel TX Execution (Optimistic)
  </Card>
</Columns>

*(Consensus Reached)* → **Finalize State & Commit to SeiDB**

This diagram illustrates the conceptual overlap. Transaction preparation feeds into a process where BFT voting happens *alongside* parallel transaction execution. The final commit to SeiDB occurs rapidly after consensus is achieved, enabled by the preceding concurrent work.

## Performance Impact for EVM Developers

This highly optimized consensus flow translates directly into tangible benefits:

* **Near-Instant Finality:** Sei has instant, deterministic finality — a transaction is final as soon as its block is committed, within the \~400ms target block time. There is no probabilistic confirmation window or multi-block wait. This eliminates the long confirmation waits common on other chains.
* **Responsive Applications:** The low latency transforms the user experience. Interactions feel instantaneous, bridging the gap between decentralized applications and traditional web services.
* **Advanced Use Cases:** The speed enables applications previously impractical on-chain, such as high-frequency trading components, real-time price oracles critical for stable DeFi, and responsive on-chain games.
* **Efficient Multi-Step Operations:** Complex DeFi workflows (e.g., approve-swap-stake) that involve multiple transactions can execute in sequence within roughly a second, boosting capital efficiency and simplifying user interactions.

These performance gains are delivered while preserving core EVM compatibility, including standard gas models and support for Solidity/Vyper and common Ethereum development tools.

### Leveraging Fast Finality in Solidity

The rapid block times enable and encourage specific development patterns:

**1. Minimal Confirmation Waits:** Off-chain applications and scripts should rely on just one block confirmation (`txResponse.wait(1)`) for probabilistic finality, significantly speeding up application logic that depends on transaction inclusion.

```javascript theme={"dark"}
// Fast transaction submission leveraging ~400ms finality
async function sendTransaction(tx) {
  // ... prepare transaction ...
  const signedTx = await wallet.signTransaction(transaction);
  const txResponse = await provider.sendTransaction(signedTx);

  // Wait for ONE block confirmation
  const receipt = await txResponse.wait(1); // Returns quickly

  console.log(`Tx ${receipt.transactionHash} confirmed in block ${receipt.blockNumber} (~400ms)`);
  return receipt; // Proceed with logic assuming finality
}
```

**2. Practical Multi-Step Interactions:** Complex sequences involving multiple dependent transactions become efficient and user-friendly.

```javascript theme={"dark"}
// Example: Multi-step DeFi operation (Approve + Swap + Deposit)
async function executeDeFiStrategy(tokenAddress, amount) {
  const approveTx = await erc20.approve(ROUTER_ADDRESS, amount);
  await approveTx.wait(1); // ~400ms

  const swapTx = await router.swapExactTokensForETH(/* ... */);
  await swapTx.wait(1); // ~400ms

  const depositTx = await lendingPool.deposit(/* ... */);
  await depositTx.wait(1); // ~400ms

  // Total time ~1.2 seconds
  console.log('Multi-step strategy completed.');
  return {
    /* ... results ... */
  };
}
```

**3. Time-Sensitive Contract Logic:** Smart contracts can implement logic sensitive to short time intervals, measured reliably in blocks.

* **Short-Duration Auctions/Votes:** Contracts can define processes that resolve within seconds or minutes, using `block.number` for precise timing based on the \~400ms block interval.
* **High-Frequency Oracles:** Oracles can push updates much more frequently (e.g., every few seconds, corresponding to a small number of blocks), providing fresher data to DeFi protocols.

```solidity theme={"dark"}
// Example: High-Frequency Oracle Update Constraint
contract HighFrequencyOracle {
    uint256 public lastUpdateBlock;
    // Allow update every 5 blocks (~2 seconds)
    uint256 public updateFrequency = 5;

    function updatePrice(bytes32 asset, uint256 price) external /* ... */ {
        // Enforce minimum block interval between updates
        require(block.number >= lastUpdateBlock + updateFrequency, "Update too frequent");
        // ... update price state ...
        lastUpdateBlock = block.number;
        // ... emit event ...
    }

    // Check price freshness (e.g., < 25 blocks = ~10 seconds)
    function isPriceFresh(bytes32 asset) external view returns (bool) {
        return block.number - lastUpdateBlock < 25;
    }
}
```

### Compatibility and Future Directions

Sei's consensus optimizations are implemented while maintaining full compatibility with the EVM standard. Existing smart contracts, dApps, and developer tools function smoothly.

Ongoing and future work focuses on further optimizing the pipeline, including advanced state management techniques (predictive loading, EVM-specific caching integrated with SeiDB), potential bytecode optimizations or JIT compilation for the EVM execution layer, and building cross-chain communication protocols that leverage Sei's fast finality.

---

URL: https://docs.sei.io/learn/parallelization-engine

# Sei Parallelization Engine: Multi-core Blockchain Execution

> Learn how Sei's Parallelization Engine enables simultaneous transaction processing across multiple CPU cores, delivering higher throughput while maintaining safety and consistency guarantees.

## Introduction

The Sei Parallelization Engine is a core component designed to increase transaction processing throughput beyond the limitations of traditional sequential execution models common in many blockchain systems. The engine enables concurrent execution of non-conflicting transactions within a block and leverages multi-core processors to improve performance and scalability. This document provides a technical explanation of its architecture and mechanisms.

<Tip>
  The Parallelization Engine is a key innovation that allows Sei to process transactions concurrently across multiple CPU cores, significantly increasing throughput while maintaining deterministic outcomes identical to sequential processing.
</Tip>

## Core Mechanism: Optimistic Concurrency Control

At its heart, the Parallelization Engine utilizes an **Optimistic Concurrency Control (OCC)** strategy. Unlike pessimistic approaches that lock state resources before execution, OCC allows transactions to execute in parallel based on an initial *estimation* of the state they will access. Conflicts (e.g., two transactions writing to the same state key) are detected *during* or *after* this parallel execution phase. When conflicts occur, they are resolved through mechanisms that often include re-execution of the conflicting transactions. This approach minimizes overhead when conflicts are infrequent and boosts overall throughput.

## System Architecture

**Sei Parallelization Engine**

<Columns cols={3}>
  <Card horizontal title="Transaction Preprocessing">
    * Classifier
    * Batch Formation
    * Gas Estimation
  </Card>

  <Card horizontal title="Dependency Analysis">
    * Access Analysis
    * Dependency Mapping
    * Contract Interaction
  </Card>

  <Card horizontal title="Parallel Execution">
    * Worker Pool
    * State Transitions
    * Speculative Execution
  </Card>
</Columns>

<Columns cols={2}>
  <Card horizontal title="Conflict Resolution">
    * Conflict Detection
    * Sequential Re-execution
  </Card>

  <Card horizontal title="SeiDB & Consensus">
    * State Commit
    * MVCC Support
  </Card>
</Columns>

This architecture enables the Sei blockchain to process transactions in parallel while ensuring consistency and correctness. Let's explore each component in detail.

### 1. Transaction Preprocessing

Before execution can begin, incoming transactions undergo preparatory processing. Raw transaction bytes transform into structured transaction objects that allow the system to identify message types and transaction characteristics. Initial validation occurs at this stage through ante handlers that verify signatures, fees, and other prerequisites.

The system also identifies certain critical transactions, such as oracle price feed updates, which may need prioritized execution to ensure timely data processing. This initial analysis leads to transaction grouping into batches for subsequent processing stages and establishes the foundation for parallel execution.

### 2. Dependency Analysis (Estimation)

This critical stage forms the backbone of the OCC approach. The system estimates potential state accesses for each transaction rather than determining exact dependencies.

An access control module analyzes each transaction to predict which state keys it might read or write during execution. Specialized Dependency Generator functions predict potential state access patterns for each transaction type. The precision of this analysis varies depending on transaction complexity:

Simple transactions like token transfers allow precise determination of which account balances will be accessed. Complex smart contract interactions make prediction of all potential storage accesses much more challenging. The generators provide broader estimates for these complex cases and acknowledge areas of uncertainty.

For example, a token transfer transaction between accounts `A` and `B` will generate estimated read/write sets that include:

* Read access to account `A`'s balance
* Read access to account `B`'s balance
* Write access to account `A`'s balance
* Write access to account `B`'s balance
* Read access to any related metadata or configuration

The dependency analyzer might also consider secondary effects such as:

* Fee payment impacts on the transaction sender's account
* Potential interactions with staking or governance mechanisms if the tokens have such properties

<Note>
  For smart contract calls, the analyzer employs heuristic methods that consider the contract's address and storage layout, the specific function selectors being called, any parameters passed to the contract functions, and historical patterns of state access from previous similar calls.
</Note>

The dependency generator outputs an estimated read/write set for each transaction. These sets contain the state keys expected to be accessed, with additional metadata indicating access types (read vs. write) and confidence levels for each prediction. The system uses these confidence levels during scheduling decisions to minimize the likelihood of conflicts.

The output from this phase consists of an "estimated writeset" for each transaction—a prediction of its state impact—which serves as crucial input for the next execution planning phase.

### 3. Parallel Execution

The system attempts concurrent execution with the estimated writesets through these steps:

1. **Batch Organization**: The process organizes transactions and their associated writesets for processing.

   * Transactions receive logical grouping based on estimated dependencies
   * The system creates execution units with appropriate metadata
   * Priority queues determine processing order for maximum throughput
   * Metadata tags track transaction relationships for later conflict analysis

2. **Worker Assignment**: A pool of execution workers (typically implemented as goroutines) stands ready to process transactions concurrently.

   * The worker pool size adapts dynamically based on system resources
   * CPU core allocation strategies optimize for NUMA architectures
   * Worker specialization allows for targeted execution of specific transaction types
   * Load balancing algorithms redistribute work for maximum resource utilization

3. **Strategic Scheduling**: Transaction assignment to workers occurs based on estimated writesets, with strategic grouping of non-conflicting transactions.

   * Graph-based scheduling algorithms minimize potential conflicts
   * The scheduler includes lookahead capabilities for multi-step dependency chains
   * Execution time estimates prioritize shorter transactions when appropriate
   * Locality-aware scheduling places related transactions on the same worker when beneficial

4. **Buffered Execution**: Workers execute transactions and write all state modifications to a temporary buffer instead of the main state store.

   * Each worker maintains an isolated transaction context
   * The execution engine applies gas metering and limits
   * Buffered state operations capture all read and write operations
   * Intermediate results remain isolated until conflict detection completes

5. **Runtime Tracking**: The system monitors which state keys are actually read and written throughout execution to build an accurate picture of real (versus estimated) state access patterns.
   * Access tracking captures both direct and indirect state interactions
   * Runtime statistics feed back into the dependency estimation system
   * Execution anomalies trigger adaptive scheduling adjustments
   * Performance metrics identify optimization opportunities

Advanced techniques ensure maximum parallelism extraction:

* Adaptive batch sizing based on system load and conflict rates
* Predictive execution of high-probability transaction paths
* Distributed execution capabilities across multiple physical nodes when available
* Resource throttling to prevent worker starvation

### 4. Conflict Detection & Resolution

The system must identify and resolve any conflicts that emerge during and after parallel execution. The process follows this sequence:

1. **Conflict Identification**: The system compares the actual read/write sets recorded during execution. A conflict exists when one transaction reads state that another concurrent transaction wrote, or when multiple transactions write to the same state key.

   The conflict detector implements several optimized algorithms:

   * A hash-based data structure tracks state accesses in memory for efficient lookup
   * Bloom filters provide rapid preliminary conflict checks
   * A deterministic conflict resolution order prevents cyclic dependencies during re-execution
   * Precise timestamp tracking ensures proper sequencing based on arrival order

   Common conflict patterns include:

   * Read-After-Write (RAW): Transaction `B` reads a key that Transaction `A` has modified
   * Write-After-Read (WAR): Transaction `B` modifies a key that Transaction `A` has read
   * Write-After-Write (WAW): Multiple transactions attempt to modify the same key

2. **Conflict Resolution**: The system executes a resolution strategy when it detects conflicts:

   * It identifies the conflicting transactions as a group
   * It removes their results from the temporary state buffer
   * It re-executes the conflicting set in a deterministic, sequential order to ensure correctness

   The deterministic ordering relies on transaction prioritization rules:

   * Critical system transactions receive highest priority
   * Oracle updates and price feeds receive elevated priority
   * Standard transactions follow their original sequence in the block
   * Gas price and other economic factors may influence the ordering

   The resolution system maintains isolation guarantees through careful state management:

   * Conflict groups remain isolated from successfully processed transactions
   * The temporary buffer preserves successfully executed state transitions
   * Resolution attempts track their own read/write sets to detect cascading conflicts

<Note>
  This conflict resolution makes the final state after parallel execution identical to what sequential processing would have produced, which maintains blockchain consistency.
</Note>

### 5. Fallback Mechanism

The OCC approach includes a critical safety mechanism for situations where parallel execution cannot succeed:

1. **Failure Detection**: The system detects failure conditions when parallel execution encounters excessive conflicts or critical errors.
2. **State Rollback**: All state changes from the failed parallel attempt are discarded.
3. **Sequential Reprocessing**: The entire transaction batch undergoes sequential processing as a fallback.

This fallback guarantees that the blockchain can always make progress, even in worst-case scenarios where parallelization proves ineffective for a particular block.

## Interaction with SeiDB

The parallelization engine works in close concert with SeiDB, Sei's custom storage layer. SeiDB's State Commit layer provides extremely low-latency read/write access needed for high transaction volume concurrent execution. Its asynchronous commit capabilities also allow quick block state finalization, which creates an efficient pipeline for block processing.

SeiDB integration offers several technical advantages crucial for parallelization:

**Performance Optimizations:**

* Multi-version concurrency control (MVCC) at the storage level supports multiple execution attempts
* Lock-free read operations prevent stalls during parallel transaction execution
* Memory-mapped state caching reduces I/O overhead for frequently accessed keys
* Batch commit optimizations minimize disk write amplification

**Parallelization-Specific Features:**

* Snapshot isolation provides consistent views of state for each transaction execution
* Atomic multi-key operations ensure multi-part state transitions remain consistent
* Versioned state access allows concurrent reads of different state versions
* Optimized rollback capabilities support the rapid discarding of speculative state changes

**Storage Architecture Alignment:**

* The key-value structure mirrors the state access patterns in the dependency analysis
* Prefix-based organization aligns with contract and module-based access patterns
* Hybrid storage tiers optimize for different access patterns across workloads
* Asynchronous persistence decouples block execution from storage commit latency

<Info>
  The tight integration between the parallelization engine and SeiDB enables the system to maintain high throughput even under challenging workloads with complex dependency patterns or high conflict rates.
</Info>

## Performance Impact

The Parallelization Engine delivers significant performance improvements:

| Transaction Type  | Sequential TPS | Parallel TPS | Improvement |
| ----------------- | -------------- | ------------ | ----------- |
| Simple Transfers  | 3,000          | 15,000+      | 5x          |
| ERC-20 Transfers  | 2,200          | 9,500+       | 4.3x        |
| DEX Swaps         | 800            | 2,800+       | 3.5x        |
| Complex Contracts | 500            | 1,500+       | 3x          |

These improvements scale with CPU core count, allowing Sei to take full advantage of modern server hardware.

---

URL: https://docs.sei.io/learn/seidb

# SeiDB: Performance-Optimized Blockchain Database

> Learn how SeiDB's specialized storage architecture accelerates blockchain operations through multi-level caching, optimized state access, and concurrency control designed specifically for EVM workloads.

## Introduction

SeiDB is a specialized database system designed to optimize blockchain state storage for the Ethereum Virtual Machine (EVM). It addresses fundamental performance constraints in traditional blockchain storage systems through targeted optimizations for EVM's specific state access patterns. This document explains the technical design and key components of SeiDB.

## Core Technical Design

Traditional blockchain databases store state in structures optimized for cryptographic verification rather than transaction execution speed. SeiDB uses a hybrid architecture that preserves cryptographic verifiability while accelerating state access operations.

Key design goals include:

* Minimizing storage slot access latency even at peak load
* Maximizing state operation throughput for both reads and writes
* Enabling parallel execution for non-conflicting state operations
* Maintaining consistent performance under variable workloads

## System Architecture

SeiDB implements a multi-layered architecture optimized for EVM state management:

**SeiDB Core**

<Columns cols={3}>
  <Card horizontal title="EVM Cache System" />

  <Card horizontal title="Query Processor" />

  <Card horizontal title="Storage Engine" />
</Columns>

<Columns cols={3}>
  <Card horizontal title="Merkle Trie Optimizer" />

  <Card horizontal title="Storage Indexer" />

  <Card horizontal title="LSM-Tree Manager" />
</Columns>

<Columns cols={3}>
  <Card horizontal title="Concurrency Control" />

  <Card horizontal title="Version Manager" />

  <Card horizontal title="I/O Scheduler" />
</Columns>

<Card horizontal title="Ethereum Compatibility Layer" />

Each component in this architecture addresses specific performance bottlenecks found in traditional blockchain storage systems. The integrated design enables specialized optimization at each level while maintaining a cohesive system.

### EVM-Optimized Storage Engine

The storage engine forms the foundation of SeiDB and represents its most significant departure from traditional blockchain state databases. While standard Ethereum implementations use a single Merkle Patricia Trie for all storage, SeiDB employs a hybrid approach combining cryptographic verification with performance optimizations from modern database systems.

Key technical innovations include:

* **Enhanced Merkle Patricia Trie**: The implementation preserves cryptographic properties required for consensus validation while addressing performance bottlenecks. SeiDB's node caching dramatically reduces I/O overhead. Hot nodes remain in memory through a priority retention system that analyzes access frequency and recency patterns across multiple blocks.

* **Incremental State Root Calculation**: The system employs specialized techniques that avoid recalculating entire trie branches when only leaf nodes change. This method accelerates block finalization for blocks with transactions affecting different state areas. The calculation process intelligently reuses intermediate hash values from unchanged subtrees, allowing rapid state root derivation even after thousands of storage modifications.

* **Direct Storage Slot Indexing**: SeiDB provides mapping between composite keys (address + slot) and their storage location. This technique reduces lookup complexity from O(log n) to near-constant time for most operations. The indexing system maintains consistency through a dual-update mechanism that modifies both the index and underlying trie atomically.

* **Account-Level Optimizations**: The system applies different strategies to external accounts (user wallets) and contract accounts. Contract accounts receive specialized treatment with code caching and execution context preservation. The code caching mechanism exploits the immutability of contract bytecode once deployed, keeping frequently accessed contracts in memory with custom deserialization to minimize runtime overhead.

* **Optimized Bloom Filters**: The storage engine accelerates negative lookups (checking for non-existent keys) during contract execution. These filters use multi-layer filtering with dynamic sizing based on the active working set to minimize false positives during typical workloads.

### Multi-Level Cache Architecture

The caching system implements multiple specialized caches optimized for particular EVM access patterns, unlike general-purpose databases that employ uniform caching strategies.

The system includes:

* **Hot Slot Cache**: This component maintains frequently used storage slots in memory using a frequency-recency hybrid eviction policy tuned for blockchain workloads. This adaptive approach achieves improved hit rates compared to static caching policies. The cache intelligently separates frequently accessed slots from burst-access slots to prevent cache thrashing during high-intensity operations.

* **Account State Cache**: This cache maintains complete information for recently accessed addresses, including code, balance, nonce, and metadata. It implements predictive loading based on transaction analysis for improved hit rates during smart contract interactions. The predictive engine analyzes calldata patterns and historical interaction graphs to preload likely-to-be-accessed contract accounts.

* **Execution Context Cache**: This specialized cache preserves partial execution environments for frequently called contracts. When the same contract executes repeatedly with similar call patterns, this contextual caching reduces setup overhead compared to cold execution. The context includes pre-validated jump destinations, resolved address references, and warmed storage slots.

### Concurrency Management

SeiDB's concurrency control system employs optimistic concurrency control (OCC) adapted specifically for EVM's state access patterns. The system incorporates semantic knowledge of common smart contract behavior to minimize conflicts.

The transaction execution process follows these steps:

1. Analysis of transaction targets, calldata patterns, and historical access data to create an initial dependency graph
2. Parallel execution of transactions without overlapping state dependencies in isolated worker threads
3. Monitoring of actual storage accesses during execution to identify conflicts against predictions
4. Selective reexecution of minimal conflict sets in sequential order when conflicts occur

For common operations like token transfers, SeiDB applies specialized conflict handlers that understand operation semantics. The semantic analysis identifies token sender and recipient addresses from calldata and method signatures. This understanding reduces false conflicts for common ERC-20 token operations.

The worker pool adjusts parallelism dynamically based on observed conflict rates. During periods with few conflicts, the system increases worker count to maximize throughput. When conflict rates rise, it reduces parallelism to avoid wasting resources on speculative execution that might require reversion. The scheduler incorporates a feedback loop that monitors aborted transactions and adjusts the parallelism factor within milliseconds of detecting changing workload patterns.

### I/O Optimization

SeiDB implements storage I/O optimizations designed specifically for blockchain workloads, which typically involve append-heavy state changes.

Key optimization techniques include:

* **Log-Structured Storage**: The system organizes state into multiple levels, with recent changes in memory and older state in progressively larger but slower storage tiers. This architecture transforms random writes into sequential operations, improving write throughput. The storage layer maintains a memory-resident delta table that captures recent modifications and periodically flushes these changes to persistent storage in optimized batches.

* **Priority-Based I/O Scheduling**: The I/O subsystem prioritizes operations based on critical path status. State reads required for transaction validation receive highest priority, followed by state updates, and background operations receive lowest priority. The scheduler also employs operation batching techniques that combine multiple small I/O operations into more efficient larger operations.

* **State Versioning**: SeiDB uses multi-version concurrency control designed for blockchain's block-based execution model. Each block creates a new state version, using full state snapshots at epoch boundaries and delta encoding between intermediate blocks. The versioning system enables point-in-time queries against historical state with minimal storage overhead through a combination of differential storage and periodic compaction.

* **Configurable Persistence**: The database offers adjustable durability guarantees based on node type and network requirements, from fully synchronous writes to asynchronous persistence with periodic checkpoints. The configuration system allows operators to make explicit tradeoffs between performance and durability based on their specific node's role in the network.

## Performance Characteristics

SeiDB is designed to deliver substantial performance improvements compared to traditional EVM state implementations. The architecture focuses on enhancing both throughput and latency across various operation types.

<Info>**Note:** Performance characteristics described in this section represent design targets rather than verified benchmarks. Actual performance will vary based on hardware configuration, workload patterns, and network conditions. Production deployments should conduct their own benchmarking to validate performance in their specific environment.</Info>

### Storage Operation Throughput

SeiDB is architected to significantly improve operation throughput across all major storage operation categories, particularly for storage reads and account lookups. These improvements result from architectural innovations rather than hardware scaling, with performance gains across all operation types.

### Latency Profile

The system is designed to maintain consistent low latency across different load conditions, from low to peak usage. This latency stability represents one of SeiDB's most significant advantages for applications requiring predictable performance. The system aims to maintain relatively stable response times even at high utilization levels, unlike traditional implementations that may exhibit severe latency spikes during high network activity.

## Optimization Patterns

Understanding certain storage access patterns allows developers to take maximum advantage of SeiDB's architecture. While existing contracts work without modification, those designed with these patterns achieve even greater performance.

### Localized Storage Access

SeiDB's caching mechanisms work most effectively when related data exists in localized regions:

```solidity theme={"dark"}
// Suboptimal: Random storage access pattern
contract BasicStorage {
    mapping(uint256 => uint256) public values;

    function processValues(uint256[] calldata keys) external {
        for (uint i = 0; i < keys.length; i++) {
            values[keys[i]] = values[keys[i]] + 1;
        }
    }
}

// Optimized: Localized storage access
contract OptimizedStorage {
    mapping(uint256 => mapping(uint256 => uint256)) public valuesByBucket;

    function processValuesBatch(uint256 bucket, uint256[] calldata keys, uint256[] calldata vals) external {
        for (uint i = 0; i < keys.length; i++) {
            valuesByBucket[bucket][keys[i]] = vals[i];
        }
    }
}
```

In the optimized version, related values cluster under common bucket keys. This organization aligns with SeiDB's caching strategy, which loads entire buckets into memory as a unit. The pattern improves performance compared to randomized access, particularly for operations processing many values in a single transaction.

### Contention Reduction

Smart contracts handling high transaction volumes benefit from storage designs that minimize contentious storage locations:

```solidity theme={"dark"}
// Suboptimal: High contention design
contract HighContentionContract {
    uint256 public totalOperations;

    function recordOperation() external {
        totalOperations++; // High contention point
        // Other operation logic
    }
}

// Optimized: Sharded counter design
contract LowContentionContract {
    mapping(uint256 => uint256) public operationsByDay;

    function recordOperation() external {
        uint256 today = block.timestamp / 86400;
        operationsByDay[today]++; // Temporal sharding reduces contention
        // Other operation logic
    }

    function getTotalOperations(uint256 daysToInclude) external view returns (uint256) {
        uint256 total = 0;
        uint256 today = block.timestamp / 86400;

        for (uint256 i = 0; i < daysToInclude; i++) {
            total += operationsByDay[today - i];
        }

        return total;
    }
}
```

The optimized contract shards the counter across time-based buckets, dramatically reducing contention when multiple transactions execute concurrently. SeiDB's concurrency control system recognizes these sharded patterns and executes transactions affecting different shards in parallel. This approach increases throughput for high-volume contracts during peak load conditions.

## Technical Integration

### EVM Compatibility

SeiDB maintains complete compatibility with the Ethereum protocol specifications while delivering performance enhancements:

* Full support for all EVM opcodes and precompiled contracts
* Identical state transition logic to standard Ethereum implementations
* Consistent gas cost model for all operations
* Complete compatibility with JSON-RPC API endpoints

These compatibility guarantees ensure existing smart contracts, development tools, and infrastructure components work without modification. The system undergoes extensive compatibility testing against the official Ethereum test suites to verify identical results compared to reference implementations.

### Deployment Configurations

SeiDB's architecture supports various deployment configurations optimized for different node roles:

* **Validator nodes** prioritize state consistency and durability through synchronous I/O operations and redundant state verification
* **API service nodes** optimize for query throughput and low latency responses with larger cache allocations and specialized read paths
* **Archive nodes** employ specialized storage strategies for efficient historical state access, including custom indexing for time-based queries
* **Light clients** benefit from optimized state proof generation with compact inclusion proofs for partial state verification

Each configuration tunes the SeiDB components to match specific requirements while maintaining protocol compatibility. The configuration framework provides fine-grained control over cache sizes, worker pools, I/O policies, and persistence strategies to match the operational needs of different node types.

---

URL: https://docs.sei.io/learn/wallets

# Sei Wallet Providers Guide

> Comprehensive guide to Sei Wallet Providers Guide on Sei. Learn key concepts, commands, and best practices.

export const EcosystemAppGrid = props => {
  const category = props.category;
  const ECOSYSTEM_API_URL = 'https://app-api.seinetwork.io/sanity/ecosystem';
  const integrationGuideOverrides = {
    'The Graph': '/evm/indexer-providers/the-graph',
    Covalent: '/evm/indexer-providers/goldrush',
    Goldsky: '/evm/indexer-providers/goldsky',
    Alchemy: '/evm/indexer-providers/alchemy'
  };
  const [isDark, setIsDark] = useState(false);
  useEffect(() => {
    const el = document.documentElement;
    const update = () => setIsDark(el.classList.contains('dark'));
    update();
    const obs = new MutationObserver(update);
    obs.observe(el, {
      attributes: true,
      attributeFilter: ['class']
    });
    return () => obs.disconnect();
  }, []);
  const [data, setData] = useState([]);
  const [isLoading, setIsLoading] = useState(true);
  const [hasError, setHasError] = useState(false);
  useEffect(() => {
    let cancelled = false;
    fetch(ECOSYSTEM_API_URL, {
      headers: {
        Accept: 'application/json'
      }
    }).then(res => {
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return res.json();
    }).then(json => {
      if (cancelled) return;
      setData(Array.isArray(json && json.data) ? json.data : []);
      setIsLoading(false);
    }).catch(() => {
      if (cancelled) return;
      setHasError(true);
      setIsLoading(false);
    });
    return () => {
      cancelled = true;
    };
  }, []);
  const WorldIcon = ({size = 24, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<circle cx="12" cy="12" r="9" />
			<path d="M3 12h18" />
			<path d="M12 3a14 14 0 0 1 0 18a14 14 0 0 1 0-18" />
		</svg>;
  const ExternalLinkIcon = ({size = 14, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<path d="M15 3h6v6" />
			<path d="M10 14L21 3" />
			<path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" />
		</svg>;
  const ArrowRightIcon = ({size = 14, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<path d="M5 12h14" />
			<path d="M12 5l7 7-7 7" />
		</svg>;
  const AppCardSkeleton = () => <div className="animate-pulse border backdrop-blur-sm bg-neutral-50/80 dark:bg-neutral-900/80 border-neutral-200/50 dark:border-neutral-800/50 p-5 h-full flex flex-col">
			<div className="flex flex-col gap-4">
				<div className="w-12 h-12 bg-neutral-200 dark:bg-neutral-800 rounded" />
				<div className="flex flex-col gap-2">
					<div className="h-5 w-32 bg-neutral-200 dark:bg-neutral-800 rounded" />
					<div className="h-4 w-full bg-neutral-200/70 dark:bg-neutral-800/70 rounded" />
					<div className="h-4 w-2/3 bg-neutral-200/70 dark:bg-neutral-800/70 rounded" />
				</div>
				<div className="h-4 w-28 bg-neutral-200/50 dark:bg-neutral-800/50 rounded mt-auto pt-2" />
			</div>
		</div>;
  const [AppCard] = useState(() => ({app, isDark}) => {
    const [hover, setHover] = useState(false);
    const [linkHover, setLinkHover] = useState(false);
    const fieldData = app.fieldData;
    const appName = fieldData.name;
    const logo = fieldData.logo;
    const desc = fieldData['short-description'];
    const integration = fieldData['integration-guide-link'];
    const logoUrl = logo && logo.url;
    if (!logoUrl) return null;
    const finalIntegrationLink = integrationGuideOverrides[appName] || integration;
    const isExternalLink = finalIntegrationLink && !finalIntegrationLink.startsWith('/');
    const linkText = isExternalLink ? 'Documentation' : 'Integration Guide';
    const resolvedLink = finalIntegrationLink ? finalIntegrationLink : undefined;
    const titleColor = hover ? isDark ? 'var(--sei-maroon-25)' : 'var(--sei-maroon-200)' : undefined;
    const linkColor = isDark ? linkHover ? 'var(--sei-cream)' : 'var(--sei-maroon-25)' : 'var(--sei-maroon-200)';
    const maroonRgb = isDark ? '96, 0, 20' : '52, 5, 13';
    const decorativeGradient = `linear-gradient(to right, rgba(${maroonRgb}, 0.15), rgba(${maroonRgb}, 0.1), rgba(${maroonRgb}, 0.15))`;
    const logoTileBg = hover ? `rgba(${maroonRgb}, ${isDark ? 0.2 : 0.1})` : undefined;
    return <div onMouseEnter={() => setHover(true)} onMouseLeave={() => setHover(false)} className="group relative overflow-hidden transition-all duration-300 ease-out transform-gpu will-change-transform hover:scale-[1.02] hover:shadow-xl hover:shadow-black/10 dark:hover:shadow-black/30 border backdrop-blur-sm bg-neutral-50/80 dark:bg-neutral-900/80 border-neutral-200/50 dark:border-neutral-800/50 hover:bg-white dark:hover:bg-neutral-900 hover:border-neutral-300 dark:hover:border-neutral-700 p-5 h-full flex flex-col">
				{}
				<div className="absolute inset-0 opacity-0 group-hover:opacity-100 transition-opacity duration-500 bg-gradient-to-br from-white/10 via-transparent to-transparent dark:from-white/5 dark:via-transparent dark:to-transparent pointer-events-none" />

				{}
				<div className="absolute inset-0 transition-all duration-700 blur-sm -z-10 transform scale-105 pointer-events-none" style={{
      background: decorativeGradient,
      opacity: hover ? 1 : 0
    }} />

				<div className="flex flex-col gap-4 relative z-10">
					<div className="flex items-start justify-between">
						<figure className="w-12 h-12 overflow-hidden flex-shrink-0 bg-neutral-200/50 dark:bg-neutral-800/50 transition-all duration-300 group-hover:scale-110 group-hover:rotate-3 flex items-center justify-center" style={{
      backgroundColor: logoTileBg
    }}>
							{logoUrl ? <img src={logoUrl} alt={appName || ''} width={48} height={48} className="object-cover w-full h-full transform transition-all duration-300 group-hover:scale-110" /> : <WorldIcon size={24} style={{
      color: hover ? 'var(--sei-maroon-100)' : '#737373',
      transition: 'color 0.3s'
    }} />}
						</figure>
					</div>

					<div className="flex flex-col gap-2 flex-grow">
						<h3 className="text-base font-bold text-neutral-800 dark:text-neutral-200 transition-colors duration-300 leading-tight" style={{
      color: titleColor
    }}>
							{appName}
						</h3>
						{desc && <p className="text-sm text-neutral-600 dark:text-neutral-400 leading-relaxed line-clamp-2 flex-grow">{desc}</p>}
					</div>

					{resolvedLink && <div className="flex items-center mt-auto pt-2">
							<a href={resolvedLink} target={isExternalLink ? '_blank' : undefined} rel={isExternalLink ? 'noopener noreferrer' : undefined} onMouseEnter={() => setLinkHover(true)} onMouseLeave={() => setLinkHover(false)} style={{
      color: linkColor,
      transition: 'color 0.2s'
    }} className="inline-flex items-center gap-1.5 text-sm font-medium no-underline">
								<span>{linkText}</span>
								{isExternalLink ? <ExternalLinkIcon size={14} style={{
      marginLeft: linkHover ? '0.25rem' : 0,
      transform: linkHover ? 'scale(1.1)' : 'none',
      transition: 'all 0.3s'
    }} /> : <ArrowRightIcon size={14} style={{
      transform: linkHover ? 'translateX(0.25rem)' : 'none',
      transition: 'transform 0.3s'
    }} />}
							</a>
						</div>}

					{}
					<div className="w-full h-0.5 transition-opacity duration-300" style={{
      background: `linear-gradient(to right, transparent, rgba(${maroonRgb}, 0.2), transparent)`,
      opacity: hover ? 1 : 0
    }} />
				</div>
			</div>;
  });
  if (isLoading) {
    return <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6 py-2">
				{Array.from({
      length: 4
    }).map((_, i) => <AppCardSkeleton key={`skeleton-${i}`} />)}
			</div>;
  }
  if (hasError) {
    return <div className="py-10 text-sm text-neutral-500 dark:text-neutral-400 italic">
				Couldn’t load {category} integrations right now. Please refresh to try again.
			</div>;
  }
  const apps = data.filter(app => app && app.fieldData && app.fieldData['docs-category'] === category);
  if (!apps || apps.length === 0) {
    return <div className="py-10 text-sm text-neutral-500 dark:text-neutral-400 italic">No {category} integrations published yet.</div>;
  }
  return <div className="sei-eco-grid grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6 py-2">
			{apps.map(app => <AppCard key={app.id} app={app} isDark={isDark} />)}
		</div>;
};

Wallets are essential for managing assets and interacting with the Sei
blockchain. There are various types of wallets available, each offering
different features and levels of security.

<Warning>Manually importing your wallet using a mnemonic from an EVM-only wallet app to a Cosmos-based wallet app, or vice versa, is not recommended. This may generate unexpected wallet addresses due to differing [Coin Types](https://en.bitcoin.it/wiki/BIP_0044#Coin_type).</Warning>

## Types of Wallets

1. **Software Wallets**: These are applications or browser extensions that
   manage private keys and interact with the blockchain. They are easy to use
   and accessible on both desktop and mobile devices.
2. **Hardware Wallets**: These are physical devices that securely store private
   keys offline. They provide enhanced security but are less convenient for
   frequent transactions.
3. **Passkey-based Wallets**: These wallets use passkeys for authentication
   instead of traditional seed phrases, offering an additional layer of
   security.

## Recommended Wallets

| Wallet         | EVM | Auth Method                       | Coin Type | Type     | Mobile | Link                                                                                                   |
| -------------- | --- | --------------------------------- | --------- | -------- | ------ | ------------------------------------------------------------------------------------------------------ |
| MetaMask 🦊    | ✅   | Mnemonic / Privkey                | 60        | Software | ✅      | [MetaMask](https://metamask.io/)                                                                       |
| Backpack 🎒    | ✅   | Mnemonic / Privkey                | 60        | Software | ✅      | [Backpack](https://backpack.app/)                                                                      |
| Binance Wallet | ✅   | MPC / Keyless                     | 60        | Software | ✅      | [Binance Wallet](https://www.binance.com/en/web3wallet)                                                |
| Dynamic        | ✅   | Any                               | All       | Embedded | ✅      | [Dynamic Wallet](https://dynamic.xyz)                                                                  |
| Privy          | ✅   | Email / Social / Passkey / Wallet | 60        | Embedded | ✅      | [Privy](https://privy.io)                                                                              |
| Rabby          | ✅   | Mnemonic / Priv/Passkey           | 60        | Software | ✅      | [Rabby Wallet](https://chromewebstore.google.com/detail/rabby-wallet/acmacodkjbdgmoleebolmdjonilkdbch) |
| OKX            | ✅   | Mnemonic / Privkey                | 118 / 60  | Software | ✅      | [OKX Wallet](https://web3.okx.com/wallet/sei-evm)                                                      |
| Gem Wallet     | ✅   | Mnemonic / Privkey                | 118 / 60  | Software | ✅      | [Gem Wallet](https://gemwallet.com/sei-wallet/)                                                        |

Wallets with coin type 118 use the Cosmos HD derivation path; the same key still maps to a unique EVM `0x...` address via Sei's address-association system.

For more information on coin types and hierarchical deterministic (HD) paths as
well as deriving wallet addresses properly, please refer to the
[Advanced Concepts on HD Path Coin Types](/learn/accounts#hd-paths-and-coin-types).

## Hardware Wallets

| Wallet  | EVM | Cosmos | Coin Type | Type     | Mobile | Link                                   |
| ------- | --- | ------ | --------- | -------- | ------ | -------------------------------------- |
| Ledger  | ✅   | ✅      | 118 / 60  | Hardware | ❌      | [Ledger](https://www.ledger.com/)      |
| Arculus | ✅   | ✅      | 118 / 60  | Hardware | ✅      | [Arculus](https://www.getarculus.com/) |

## Integration Guides

* [Pimlico Wallet](/evm/wallet-integrations/pimlico)
* [Particle Wallet](/evm/wallet-integrations/particle)

## All Wallets

<EcosystemAppGrid category="wallet" />

---

URL: https://docs.sei.io/learn/rpc-providers

# Sei Network RPC Providers

> Directory of reliable RPC service providers for Sei blockchain. Access endpoints for development, node connections, and blockchain interactions.

export const EcosystemAppGrid = props => {
  const category = props.category;
  const ECOSYSTEM_API_URL = 'https://app-api.seinetwork.io/sanity/ecosystem';
  const integrationGuideOverrides = {
    'The Graph': '/evm/indexer-providers/the-graph',
    Covalent: '/evm/indexer-providers/goldrush',
    Goldsky: '/evm/indexer-providers/goldsky',
    Alchemy: '/evm/indexer-providers/alchemy'
  };
  const [isDark, setIsDark] = useState(false);
  useEffect(() => {
    const el = document.documentElement;
    const update = () => setIsDark(el.classList.contains('dark'));
    update();
    const obs = new MutationObserver(update);
    obs.observe(el, {
      attributes: true,
      attributeFilter: ['class']
    });
    return () => obs.disconnect();
  }, []);
  const [data, setData] = useState([]);
  const [isLoading, setIsLoading] = useState(true);
  const [hasError, setHasError] = useState(false);
  useEffect(() => {
    let cancelled = false;
    fetch(ECOSYSTEM_API_URL, {
      headers: {
        Accept: 'application/json'
      }
    }).then(res => {
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return res.json();
    }).then(json => {
      if (cancelled) return;
      setData(Array.isArray(json && json.data) ? json.data : []);
      setIsLoading(false);
    }).catch(() => {
      if (cancelled) return;
      setHasError(true);
      setIsLoading(false);
    });
    return () => {
      cancelled = true;
    };
  }, []);
  const WorldIcon = ({size = 24, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<circle cx="12" cy="12" r="9" />
			<path d="M3 12h18" />
			<path d="M12 3a14 14 0 0 1 0 18a14 14 0 0 1 0-18" />
		</svg>;
  const ExternalLinkIcon = ({size = 14, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<path d="M15 3h6v6" />
			<path d="M10 14L21 3" />
			<path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" />
		</svg>;
  const ArrowRightIcon = ({size = 14, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<path d="M5 12h14" />
			<path d="M12 5l7 7-7 7" />
		</svg>;
  const AppCardSkeleton = () => <div className="animate-pulse border backdrop-blur-sm bg-neutral-50/80 dark:bg-neutral-900/80 border-neutral-200/50 dark:border-neutral-800/50 p-5 h-full flex flex-col">
			<div className="flex flex-col gap-4">
				<div className="w-12 h-12 bg-neutral-200 dark:bg-neutral-800 rounded" />
				<div className="flex flex-col gap-2">
					<div className="h-5 w-32 bg-neutral-200 dark:bg-neutral-800 rounded" />
					<div className="h-4 w-full bg-neutral-200/70 dark:bg-neutral-800/70 rounded" />
					<div className="h-4 w-2/3 bg-neutral-200/70 dark:bg-neutral-800/70 rounded" />
				</div>
				<div className="h-4 w-28 bg-neutral-200/50 dark:bg-neutral-800/50 rounded mt-auto pt-2" />
			</div>
		</div>;
  const [AppCard] = useState(() => ({app, isDark}) => {
    const [hover, setHover] = useState(false);
    const [linkHover, setLinkHover] = useState(false);
    const fieldData = app.fieldData;
    const appName = fieldData.name;
    const logo = fieldData.logo;
    const desc = fieldData['short-description'];
    const integration = fieldData['integration-guide-link'];
    const logoUrl = logo && logo.url;
    if (!logoUrl) return null;
    const finalIntegrationLink = integrationGuideOverrides[appName] || integration;
    const isExternalLink = finalIntegrationLink && !finalIntegrationLink.startsWith('/');
    const linkText = isExternalLink ? 'Documentation' : 'Integration Guide';
    const resolvedLink = finalIntegrationLink ? finalIntegrationLink : undefined;
    const titleColor = hover ? isDark ? 'var(--sei-maroon-25)' : 'var(--sei-maroon-200)' : undefined;
    const linkColor = isDark ? linkHover ? 'var(--sei-cream)' : 'var(--sei-maroon-25)' : 'var(--sei-maroon-200)';
    const maroonRgb = isDark ? '96, 0, 20' : '52, 5, 13';
    const decorativeGradient = `linear-gradient(to right, rgba(${maroonRgb}, 0.15), rgba(${maroonRgb}, 0.1), rgba(${maroonRgb}, 0.15))`;
    const logoTileBg = hover ? `rgba(${maroonRgb}, ${isDark ? 0.2 : 0.1})` : undefined;
    return <div onMouseEnter={() => setHover(true)} onMouseLeave={() => setHover(false)} className="group relative overflow-hidden transition-all duration-300 ease-out transform-gpu will-change-transform hover:scale-[1.02] hover:shadow-xl hover:shadow-black/10 dark:hover:shadow-black/30 border backdrop-blur-sm bg-neutral-50/80 dark:bg-neutral-900/80 border-neutral-200/50 dark:border-neutral-800/50 hover:bg-white dark:hover:bg-neutral-900 hover:border-neutral-300 dark:hover:border-neutral-700 p-5 h-full flex flex-col">
				{}
				<div className="absolute inset-0 opacity-0 group-hover:opacity-100 transition-opacity duration-500 bg-gradient-to-br from-white/10 via-transparent to-transparent dark:from-white/5 dark:via-transparent dark:to-transparent pointer-events-none" />

				{}
				<div className="absolute inset-0 transition-all duration-700 blur-sm -z-10 transform scale-105 pointer-events-none" style={{
      background: decorativeGradient,
      opacity: hover ? 1 : 0
    }} />

				<div className="flex flex-col gap-4 relative z-10">
					<div className="flex items-start justify-between">
						<figure className="w-12 h-12 overflow-hidden flex-shrink-0 bg-neutral-200/50 dark:bg-neutral-800/50 transition-all duration-300 group-hover:scale-110 group-hover:rotate-3 flex items-center justify-center" style={{
      backgroundColor: logoTileBg
    }}>
							{logoUrl ? <img src={logoUrl} alt={appName || ''} width={48} height={48} className="object-cover w-full h-full transform transition-all duration-300 group-hover:scale-110" /> : <WorldIcon size={24} style={{
      color: hover ? 'var(--sei-maroon-100)' : '#737373',
      transition: 'color 0.3s'
    }} />}
						</figure>
					</div>

					<div className="flex flex-col gap-2 flex-grow">
						<h3 className="text-base font-bold text-neutral-800 dark:text-neutral-200 transition-colors duration-300 leading-tight" style={{
      color: titleColor
    }}>
							{appName}
						</h3>
						{desc && <p className="text-sm text-neutral-600 dark:text-neutral-400 leading-relaxed line-clamp-2 flex-grow">{desc}</p>}
					</div>

					{resolvedLink && <div className="flex items-center mt-auto pt-2">
							<a href={resolvedLink} target={isExternalLink ? '_blank' : undefined} rel={isExternalLink ? 'noopener noreferrer' : undefined} onMouseEnter={() => setLinkHover(true)} onMouseLeave={() => setLinkHover(false)} style={{
      color: linkColor,
      transition: 'color 0.2s'
    }} className="inline-flex items-center gap-1.5 text-sm font-medium no-underline">
								<span>{linkText}</span>
								{isExternalLink ? <ExternalLinkIcon size={14} style={{
      marginLeft: linkHover ? '0.25rem' : 0,
      transform: linkHover ? 'scale(1.1)' : 'none',
      transition: 'all 0.3s'
    }} /> : <ArrowRightIcon size={14} style={{
      transform: linkHover ? 'translateX(0.25rem)' : 'none',
      transition: 'transform 0.3s'
    }} />}
							</a>
						</div>}

					{}
					<div className="w-full h-0.5 transition-opacity duration-300" style={{
      background: `linear-gradient(to right, transparent, rgba(${maroonRgb}, 0.2), transparent)`,
      opacity: hover ? 1 : 0
    }} />
				</div>
			</div>;
  });
  if (isLoading) {
    return <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6 py-2">
				{Array.from({
      length: 4
    }).map((_, i) => <AppCardSkeleton key={`skeleton-${i}`} />)}
			</div>;
  }
  if (hasError) {
    return <div className="py-10 text-sm text-neutral-500 dark:text-neutral-400 italic">
				Couldn’t load {category} integrations right now. Please refresh to try again.
			</div>;
  }
  const apps = data.filter(app => app && app.fieldData && app.fieldData['docs-category'] === category);
  if (!apps || apps.length === 0) {
    return <div className="py-10 text-sm text-neutral-500 dark:text-neutral-400 italic">No {category} integrations published yet.</div>;
  }
  return <div className="sei-eco-grid grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6 py-2">
			{apps.map(app => <AppCard key={app.id} app={app} isDark={isDark} />)}
		</div>;
};

RPC providers offer endpoints for developers to interact with the Sei
blockchain, archive nodes, and more. Some notable providers
include:

<EcosystemAppGrid category="rpc-provider" />

---

URL: https://docs.sei.io/learn/explorers

# Sei Blockchain Explorers Guide

> A comprehensive overview of block explorers for the Sei Network across different environments. Access tools for tracking transactions, analyzing addresses, and monitoring network activity.

## What Is a Block Explorer?

Rather than downloading the entire blockchain ledger, using a block explorer is
the most common method to look up all kinds of useful on-chain information.

Most block explorers offer tools for viewing, and sometimes even interacting
with the network including:

* Transaction Tracking: View and track individual transactions on the
  blockchain. Typically includes information such as transaction hashes, input
  and output data, the address of other wallets or contracts a given wallet has
  interacted with, tokens transferred, fees paid and any error messages that may
  be associated with the transaction.

* Block Information: Details about each block like height (sequence), timestamp,
  total size, and details on transactions included in each block.

* Address Queries: Find specific wallet addresses, with token balances and
  transaction history, details on contract addresses and non-wallet accounts.

* Network Statistics: Statistics and analytics about the blockchain, such as
  total number of blocks, transaction throughput, network hash rate, staking and
  governance data, and much more.

* Smart Contracts: Query smart contract states, deployments and interactions
  with other wallets or addresses. Some may include the raw code for the
  contract.

<Info>
  Note: In rare cases, some information may be misinterpreted. Off-chain data should be used as a guide only.
</Info>

## Sei Explorers

<Tabs>
  <Tab title="mainnet (pacific-1)">
    * [Seiscan](https://seiscan.io) — A user-friendly block explorer for the Sei Pacific-1 mainnet.
    * [Mintscan](https://www.mintscan.io/sei) — Comprehensive blockchain explorer and analytics platform for Sei mainnet.
    * [Seistream](https://seistream.app/) — Real-time transaction streaming and monitoring tool for Sei mainnet.
    * [NG Explorer](https://sei.explorers.guru) — Comprehensive blockchain explorer provided by Nodes Guru for Sei mainnet.
  </Tab>

  <Tab title="testnet (atlantic-2)">
    * [Seiscan](https://testnet.seiscan.io) — A user-friendly block explorer for the Sei Atlantic-2 testnet.
    * [Seistream](https://testnet.seistream.app/) — Real-time transaction streaming and monitoring tool for Sei testnet.
    * [NG Explorer](https://testnet.sei.explorers.guru) — Comprehensive blockchain explorer provided by Nodes Guru for Sei testnet.
  </Tab>
</Tabs>

---

URL: https://docs.sei.io/learn/faucet

# Sei Network Testnet Faucet

> Request testnet tokens for development and testing on Sei Network. The faucet distributes test tokens with no real-world value.

<Warning>This faucet distributes testnet (atlantic-2) tokens only, which have no real-world value and are intended for testing purposes.</Warning>

## Request Tokens

Enter your wallet address below to receive testnet SEI.

<iframe src="https://sei-widgets.vercel.app/faucet" style={{ width: "100%", minHeight: "520px", border: "0" }} loading="lazy" title="Sei testnet faucet" />

## Usage Notes

* **Rate Limits** — Each address can request tokens once per day. Wait 24 hours between requests.
* **Testnet Only** — Tokens are distributed on `atlantic-2` and cannot be used on mainnet.
* **Gas Coverage** — A single request provides enough SEI to cover hundreds of testnet transactions.

## Testnet USDC

Need testnet USDC for testing ERC-20 workflows? Use the Circle Faucet to receive USDC on Sei's testnet.

* [Circle Faucet](https://faucet.circle.com)
* [USDC on Sei Guide](/evm/usdc-on-sei)

<Info>If the faucet is temporarily unavailable, try again later or reach out in the [Sei Discord](https://discord.gg/sei) or [Telegram](https://t.me/+KZdhZ1eE-G01NmZk) developer channels for assistance.</Info>

---

URL: https://docs.sei.io/learn/indexers

# Blockchain Indexers for Sei Network

> Comprehensive guide to Blockchain Indexers for Sei Network on Sei. Learn key concepts, commands, and best practices.

export const EcosystemAppGrid = props => {
  const category = props.category;
  const ECOSYSTEM_API_URL = 'https://app-api.seinetwork.io/sanity/ecosystem';
  const integrationGuideOverrides = {
    'The Graph': '/evm/indexer-providers/the-graph',
    Covalent: '/evm/indexer-providers/goldrush',
    Goldsky: '/evm/indexer-providers/goldsky',
    Alchemy: '/evm/indexer-providers/alchemy'
  };
  const [isDark, setIsDark] = useState(false);
  useEffect(() => {
    const el = document.documentElement;
    const update = () => setIsDark(el.classList.contains('dark'));
    update();
    const obs = new MutationObserver(update);
    obs.observe(el, {
      attributes: true,
      attributeFilter: ['class']
    });
    return () => obs.disconnect();
  }, []);
  const [data, setData] = useState([]);
  const [isLoading, setIsLoading] = useState(true);
  const [hasError, setHasError] = useState(false);
  useEffect(() => {
    let cancelled = false;
    fetch(ECOSYSTEM_API_URL, {
      headers: {
        Accept: 'application/json'
      }
    }).then(res => {
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return res.json();
    }).then(json => {
      if (cancelled) return;
      setData(Array.isArray(json && json.data) ? json.data : []);
      setIsLoading(false);
    }).catch(() => {
      if (cancelled) return;
      setHasError(true);
      setIsLoading(false);
    });
    return () => {
      cancelled = true;
    };
  }, []);
  const WorldIcon = ({size = 24, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<circle cx="12" cy="12" r="9" />
			<path d="M3 12h18" />
			<path d="M12 3a14 14 0 0 1 0 18a14 14 0 0 1 0-18" />
		</svg>;
  const ExternalLinkIcon = ({size = 14, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<path d="M15 3h6v6" />
			<path d="M10 14L21 3" />
			<path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" />
		</svg>;
  const ArrowRightIcon = ({size = 14, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<path d="M5 12h14" />
			<path d="M12 5l7 7-7 7" />
		</svg>;
  const AppCardSkeleton = () => <div className="animate-pulse border backdrop-blur-sm bg-neutral-50/80 dark:bg-neutral-900/80 border-neutral-200/50 dark:border-neutral-800/50 p-5 h-full flex flex-col">
			<div className="flex flex-col gap-4">
				<div className="w-12 h-12 bg-neutral-200 dark:bg-neutral-800 rounded" />
				<div className="flex flex-col gap-2">
					<div className="h-5 w-32 bg-neutral-200 dark:bg-neutral-800 rounded" />
					<div className="h-4 w-full bg-neutral-200/70 dark:bg-neutral-800/70 rounded" />
					<div className="h-4 w-2/3 bg-neutral-200/70 dark:bg-neutral-800/70 rounded" />
				</div>
				<div className="h-4 w-28 bg-neutral-200/50 dark:bg-neutral-800/50 rounded mt-auto pt-2" />
			</div>
		</div>;
  const [AppCard] = useState(() => ({app, isDark}) => {
    const [hover, setHover] = useState(false);
    const [linkHover, setLinkHover] = useState(false);
    const fieldData = app.fieldData;
    const appName = fieldData.name;
    const logo = fieldData.logo;
    const desc = fieldData['short-description'];
    const integration = fieldData['integration-guide-link'];
    const logoUrl = logo && logo.url;
    if (!logoUrl) return null;
    const finalIntegrationLink = integrationGuideOverrides[appName] || integration;
    const isExternalLink = finalIntegrationLink && !finalIntegrationLink.startsWith('/');
    const linkText = isExternalLink ? 'Documentation' : 'Integration Guide';
    const resolvedLink = finalIntegrationLink ? finalIntegrationLink : undefined;
    const titleColor = hover ? isDark ? 'var(--sei-maroon-25)' : 'var(--sei-maroon-200)' : undefined;
    const linkColor = isDark ? linkHover ? 'var(--sei-cream)' : 'var(--sei-maroon-25)' : 'var(--sei-maroon-200)';
    const maroonRgb = isDark ? '96, 0, 20' : '52, 5, 13';
    const decorativeGradient = `linear-gradient(to right, rgba(${maroonRgb}, 0.15), rgba(${maroonRgb}, 0.1), rgba(${maroonRgb}, 0.15))`;
    const logoTileBg = hover ? `rgba(${maroonRgb}, ${isDark ? 0.2 : 0.1})` : undefined;
    return <div onMouseEnter={() => setHover(true)} onMouseLeave={() => setHover(false)} className="group relative overflow-hidden transition-all duration-300 ease-out transform-gpu will-change-transform hover:scale-[1.02] hover:shadow-xl hover:shadow-black/10 dark:hover:shadow-black/30 border backdrop-blur-sm bg-neutral-50/80 dark:bg-neutral-900/80 border-neutral-200/50 dark:border-neutral-800/50 hover:bg-white dark:hover:bg-neutral-900 hover:border-neutral-300 dark:hover:border-neutral-700 p-5 h-full flex flex-col">
				{}
				<div className="absolute inset-0 opacity-0 group-hover:opacity-100 transition-opacity duration-500 bg-gradient-to-br from-white/10 via-transparent to-transparent dark:from-white/5 dark:via-transparent dark:to-transparent pointer-events-none" />

				{}
				<div className="absolute inset-0 transition-all duration-700 blur-sm -z-10 transform scale-105 pointer-events-none" style={{
      background: decorativeGradient,
      opacity: hover ? 1 : 0
    }} />

				<div className="flex flex-col gap-4 relative z-10">
					<div className="flex items-start justify-between">
						<figure className="w-12 h-12 overflow-hidden flex-shrink-0 bg-neutral-200/50 dark:bg-neutral-800/50 transition-all duration-300 group-hover:scale-110 group-hover:rotate-3 flex items-center justify-center" style={{
      backgroundColor: logoTileBg
    }}>
							{logoUrl ? <img src={logoUrl} alt={appName || ''} width={48} height={48} className="object-cover w-full h-full transform transition-all duration-300 group-hover:scale-110" /> : <WorldIcon size={24} style={{
      color: hover ? 'var(--sei-maroon-100)' : '#737373',
      transition: 'color 0.3s'
    }} />}
						</figure>
					</div>

					<div className="flex flex-col gap-2 flex-grow">
						<h3 className="text-base font-bold text-neutral-800 dark:text-neutral-200 transition-colors duration-300 leading-tight" style={{
      color: titleColor
    }}>
							{appName}
						</h3>
						{desc && <p className="text-sm text-neutral-600 dark:text-neutral-400 leading-relaxed line-clamp-2 flex-grow">{desc}</p>}
					</div>

					{resolvedLink && <div className="flex items-center mt-auto pt-2">
							<a href={resolvedLink} target={isExternalLink ? '_blank' : undefined} rel={isExternalLink ? 'noopener noreferrer' : undefined} onMouseEnter={() => setLinkHover(true)} onMouseLeave={() => setLinkHover(false)} style={{
      color: linkColor,
      transition: 'color 0.2s'
    }} className="inline-flex items-center gap-1.5 text-sm font-medium no-underline">
								<span>{linkText}</span>
								{isExternalLink ? <ExternalLinkIcon size={14} style={{
      marginLeft: linkHover ? '0.25rem' : 0,
      transform: linkHover ? 'scale(1.1)' : 'none',
      transition: 'all 0.3s'
    }} /> : <ArrowRightIcon size={14} style={{
      transform: linkHover ? 'translateX(0.25rem)' : 'none',
      transition: 'transform 0.3s'
    }} />}
							</a>
						</div>}

					{}
					<div className="w-full h-0.5 transition-opacity duration-300" style={{
      background: `linear-gradient(to right, transparent, rgba(${maroonRgb}, 0.2), transparent)`,
      opacity: hover ? 1 : 0
    }} />
				</div>
			</div>;
  });
  if (isLoading) {
    return <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6 py-2">
				{Array.from({
      length: 4
    }).map((_, i) => <AppCardSkeleton key={`skeleton-${i}`} />)}
			</div>;
  }
  if (hasError) {
    return <div className="py-10 text-sm text-neutral-500 dark:text-neutral-400 italic">
				Couldn’t load {category} integrations right now. Please refresh to try again.
			</div>;
  }
  const apps = data.filter(app => app && app.fieldData && app.fieldData['docs-category'] === category);
  if (!apps || apps.length === 0) {
    return <div className="py-10 text-sm text-neutral-500 dark:text-neutral-400 italic">No {category} integrations published yet.</div>;
  }
  return <div className="sei-eco-grid grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6 py-2">
			{apps.map(app => <AppCard key={app.id} app={app} isDark={isDark} />)}
		</div>;
};

**Query Sei Data at Scale**

Indexers collect and organize blockchain data, making it easily queryable for applications. They provide structured APIs, real-time updates, and significantly better performance than querying nodes directly.

## Why Use Indexers?

* **High Performance** — Query millions of transactions in milliseconds with optimized database structures.
* **Complex Queries** — Filter, sort, and aggregate blockchain data with GraphQL and REST APIs.
* **Real-time Updates** — Receive live blockchain data through WebSocket connections and webhooks.

## Available Indexers

Indexing solutions for querying Sei blockchain data with high performance and reliability.

<EcosystemAppGrid category="indexer" />

<Info>
  Projects listed here are developed by the Sei community. Inclusion on this site does not constitute endorsement. For questions related to each, please contact the project directly.
</Info>

* **Production Scale** — Sub-second query response times with GraphQL/REST APIs and real-time subscriptions.
* **Community Built** — Community-developed projects. Contact directly for support.

---

URL: https://docs.sei.io/learn/oracles

# Oracle Providers on Sei

> Directory of oracle providers for Sei blockchain. Access reliable price feeds and off-chain data for DeFi applications, smart contracts, and dApps.

export const EcosystemAppGrid = props => {
  const category = props.category;
  const ECOSYSTEM_API_URL = 'https://app-api.seinetwork.io/sanity/ecosystem';
  const integrationGuideOverrides = {
    'The Graph': '/evm/indexer-providers/the-graph',
    Covalent: '/evm/indexer-providers/goldrush',
    Goldsky: '/evm/indexer-providers/goldsky',
    Alchemy: '/evm/indexer-providers/alchemy'
  };
  const [isDark, setIsDark] = useState(false);
  useEffect(() => {
    const el = document.documentElement;
    const update = () => setIsDark(el.classList.contains('dark'));
    update();
    const obs = new MutationObserver(update);
    obs.observe(el, {
      attributes: true,
      attributeFilter: ['class']
    });
    return () => obs.disconnect();
  }, []);
  const [data, setData] = useState([]);
  const [isLoading, setIsLoading] = useState(true);
  const [hasError, setHasError] = useState(false);
  useEffect(() => {
    let cancelled = false;
    fetch(ECOSYSTEM_API_URL, {
      headers: {
        Accept: 'application/json'
      }
    }).then(res => {
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return res.json();
    }).then(json => {
      if (cancelled) return;
      setData(Array.isArray(json && json.data) ? json.data : []);
      setIsLoading(false);
    }).catch(() => {
      if (cancelled) return;
      setHasError(true);
      setIsLoading(false);
    });
    return () => {
      cancelled = true;
    };
  }, []);
  const WorldIcon = ({size = 24, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<circle cx="12" cy="12" r="9" />
			<path d="M3 12h18" />
			<path d="M12 3a14 14 0 0 1 0 18a14 14 0 0 1 0-18" />
		</svg>;
  const ExternalLinkIcon = ({size = 14, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<path d="M15 3h6v6" />
			<path d="M10 14L21 3" />
			<path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" />
		</svg>;
  const ArrowRightIcon = ({size = 14, style}) => <svg xmlns="http://www.w3.org/2000/svg" width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" style={style} aria-hidden="true">
			<path d="M5 12h14" />
			<path d="M12 5l7 7-7 7" />
		</svg>;
  const AppCardSkeleton = () => <div className="animate-pulse border backdrop-blur-sm bg-neutral-50/80 dark:bg-neutral-900/80 border-neutral-200/50 dark:border-neutral-800/50 p-5 h-full flex flex-col">
			<div className="flex flex-col gap-4">
				<div className="w-12 h-12 bg-neutral-200 dark:bg-neutral-800 rounded" />
				<div className="flex flex-col gap-2">
					<div className="h-5 w-32 bg-neutral-200 dark:bg-neutral-800 rounded" />
					<div className="h-4 w-full bg-neutral-200/70 dark:bg-neutral-800/70 rounded" />
					<div className="h-4 w-2/3 bg-neutral-200/70 dark:bg-neutral-800/70 rounded" />
				</div>
				<div className="h-4 w-28 bg-neutral-200/50 dark:bg-neutral-800/50 rounded mt-auto pt-2" />
			</div>
		</div>;
  const [AppCard] = useState(() => ({app, isDark}) => {
    const [hover, setHover] = useState(false);
    const [linkHover, setLinkHover] = useState(false);
    const fieldData = app.fieldData;
    const appName = fieldData.name;
    const logo = fieldData.logo;
    const desc = fieldData['short-description'];
    const integration = fieldData['integration-guide-link'];
    const logoUrl = logo && logo.url;
    if (!logoUrl) return null;
    const finalIntegrationLink = integrationGuideOverrides[appName] || integration;
    const isExternalLink = finalIntegrationLink && !finalIntegrationLink.startsWith('/');
    const linkText = isExternalLink ? 'Documentation' : 'Integration Guide';
    const resolvedLink = finalIntegrationLink ? finalIntegrationLink : undefined;
    const titleColor = hover ? isDark ? 'var(--sei-maroon-25)' : 'var(--sei-maroon-200)' : undefined;
    const linkColor = isDark ? linkHover ? 'var(--sei-cream)' : 'var(--sei-maroon-25)' : 'var(--sei-maroon-200)';
    const maroonRgb = isDark ? '96, 0, 20' : '52, 5, 13';
    const decorativeGradient = `linear-gradient(to right, rgba(${maroonRgb}, 0.15), rgba(${maroonRgb}, 0.1), rgba(${maroonRgb}, 0.15))`;
    const logoTileBg = hover ? `rgba(${maroonRgb}, ${isDark ? 0.2 : 0.1})` : undefined;
    return <div onMouseEnter={() => setHover(true)} onMouseLeave={() => setHover(false)} className="group relative overflow-hidden transition-all duration-300 ease-out transform-gpu will-change-transform hover:scale-[1.02] hover:shadow-xl hover:shadow-black/10 dark:hover:shadow-black/30 border backdrop-blur-sm bg-neutral-50/80 dark:bg-neutral-900/80 border-neutral-200/50 dark:border-neutral-800/50 hover:bg-white dark:hover:bg-neutral-900 hover:border-neutral-300 dark:hover:border-neutral-700 p-5 h-full flex flex-col">
				{}
				<div className="absolute inset-0 opacity-0 group-hover:opacity-100 transition-opacity duration-500 bg-gradient-to-br from-white/10 via-transparent to-transparent dark:from-white/5 dark:via-transparent dark:to-transparent pointer-events-none" />

				{}
				<div className="absolute inset-0 transition-all duration-700 blur-sm -z-10 transform scale-105 pointer-events-none" style={{
      background: decorativeGradient,
      opacity: hover ? 1 : 0
    }} />

				<div className="flex flex-col gap-4 relative z-10">
					<div className="flex items-start justify-between">
						<figure className="w-12 h-12 overflow-hidden flex-shrink-0 bg-neutral-200/50 dark:bg-neutral-800/50 transition-all duration-300 group-hover:scale-110 group-hover:rotate-3 flex items-center justify-center" style={{
      backgroundColor: logoTileBg
    }}>
							{logoUrl ? <img src={logoUrl} alt={appName || ''} width={48} height={48} className="object-cover w-full h-full transform transition-all duration-300 group-hover:scale-110" /> : <WorldIcon size={24} style={{
      color: hover ? 'var(--sei-maroon-100)' : '#737373',
      transition: 'color 0.3s'
    }} />}
						</figure>
					</div>

					<div className="flex flex-col gap-2 flex-grow">
						<h3 className="text-base font-bold text-neutral-800 dark:text-neutral-200 transition-colors duration-300 leading-tight" style={{
      color: titleColor
    }}>
							{appName}
						</h3>
						{desc && <p className="text-sm text-neutral-600 dark:text-neutral-400 leading-relaxed line-clamp-2 flex-grow">{desc}</p>}
					</div>

					{resolvedLink && <div className="flex items-center mt-auto pt-2">
							<a href={resolvedLink} target={isExternalLink ? '_blank' : undefined} rel={isExternalLink ? 'noopener noreferrer' : undefined} onMouseEnter={() => setLinkHover(true)} onMouseLeave={() => setLinkHover(false)} style={{
      color: linkColor,
      transition: 'color 0.2s'
    }} className="inline-flex items-center gap-1.5 text-sm font-medium no-underline">
								<span>{linkText}</span>
								{isExternalLink ? <ExternalLinkIcon size={14} style={{
      marginLeft: linkHover ? '0.25rem' : 0,
      transform: linkHover ? 'scale(1.1)' : 'none',
      transition: 'all 0.3s'
    }} /> : <ArrowRightIcon size={14} style={{
      transform: linkHover ? 'translateX(0.25rem)' : 'none',
      transition: 'transform 0.3s'
    }} />}
							</a>
						</div>}

					{}
					<div className="w-full h-0.5 transition-opacity duration-300" style={{
      background: `linear-gradient(to right, transparent, rgba(${maroonRgb}, 0.2), transparent)`,
      opacity: hover ? 1 : 0
    }} />
				</div>
			</div>;
  });
  if (isLoading) {
    return <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6 py-2">
				{Array.from({
      length: 4
    }).map((_, i) => <AppCardSkeleton key={`skeleton-${i}`} />)}
			</div>;
  }
  if (hasError) {
    return <div className="py-10 text-sm text-neutral-500 dark:text-neutral-400 italic">
				Couldn’t load {category} integrations right now. Please refresh to try again.
			</div>;
  }
  const apps = data.filter(app => app && app.fieldData && app.fieldData['docs-category'] === category);
  if (!apps || apps.length === 0) {
    return <div className="py-10 text-sm text-neutral-500 dark:text-neutral-400 italic">No {category} integrations published yet.</div>;
  }
  return <div className="sei-eco-grid grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6 py-2">
			{apps.map(app => <AppCard key={app.id} app={app} isDark={isDark} />)}
		</div>;
};

Oracles are the bridge between blockchain networks and real-world data. They provide a secure mechanism for bringing off-chain price data on-chain, enabling DeFi protocols, smart contracts, and dApps to access reliable external information.

## Use Cases

* **DeFi Developers:** Query real-time prices and TWAPs for liquidations and trading
* **dApp Builders:** Access reliable price feeds for any on-chain application
* **Infrastructure Providers:** Build enhanced oracle services on top of existing solutions

## Available Providers

<EcosystemAppGrid category="oracle" />

---

URL: https://docs.sei.io/learn/general-governance

# General Governance

> Learn about Sei's governance system and how to participate in the decision-making process

**Decentralized Decision Making**

Sei employs an on-chain governance system that enables SEI holders to participate in the decision-making process for the network. This system is built on the Cosmos SDK governance module with several enhancements specific to Sei's architecture.

## How Governance Works

1. **Proposal Submission** — Anyone can submit a governance proposal with an initial deposit.
2. **Deposit Period** — Community members can contribute to the proposal deposit.
3. **Voting Period** — Once minimum deposit is reached, voting begins.
4. **Execution** — Approved proposals are automatically executed.

### Governance Logic

* **Quorum Requirement** — A minimum percentage of bonded tokens must participate in voting for a proposal to be valid.
* **Approval Threshold** — A proposal must receive more than 50% approval (excluding abstain votes) to pass, or 66.7% for expedited proposals.
* **Veto Protection** — If more than 33.4% of votes are "NoWithVeto", the proposal is vetoed regardless of other vote counts.

## Network Parameters

### Production Network (Mainnet)

Live network parameters for pacific-1

| Parameter                 | Value    | Description                               |
| ------------------------- | -------- | ----------------------------------------- |
| Minimum Deposit           | 3500 SEI | Required to enter voting period           |
| Expedited Minimum Deposit | 7000 SEI | Required to enter expedited voting period |
| Deposit Period            | 2 days   | Time to collect minimum deposit           |
| Voting Period             | 3 days   | Duration for voting                       |
| Expedited Voting Period   | 24 hours | Duration for expedited voting             |
| Quorum                    | 33.4%    | Minimum participation required            |
| Expedited Quorum          | 66.7%    | Fast-track proposals                      |
| Approval Threshold        | 50%      | Standard proposals                        |
| Expedited Threshold       | 66.7%    | Fast-track proposals                      |
| Veto Threshold            | 33.4%    | Maximum veto votes allowed                |

### Development Networks (Testnet)

Changed testing parameters for atlantic-2

| Parameter                 | Value    | Description         |
| ------------------------- | -------- | ------------------- |
| Minimum Deposit           | 10 SEI   | Reduced for testing |
| Expedited Minimum Deposit | 20 SEI   | Reduced for testing |
| Voting Period             | 12 hours | Fast testing cycles |
| Expedited Voting Period   | 6 hours  | Fast testing cycles |

## Vote Types

### Voting Options

Understand the different voting options available.

1. **Yes** — Support the proposal as written. Counts toward approval threshold.
2. **No** — Oppose the proposal. Counts against approval threshold.
3. **Abstain** — Neutral position. Counts toward quorum but not approval threshold.
4. **NoWithVeto** — Strong opposition. Can veto a proposal if threshold is exceeded.

## Weighted Voting

**Advanced Voting**

Validators and delegators can split their voting power across multiple options using weighted voting.

* **Flexibility** — Distribute voting power across different options based on preference strength.
* **Precision** — Express nuanced positions on complex proposals with percentage allocations.

## Proposal Outcomes

| Outcome            | Conditions                                                                                                                                           |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| Passed             | Quorum met (≥33.4% participation) · Approval threshold met (≥50% or ≥66.7% for expedited) · Veto threshold not exceeded (less than 33.4% NoWithVeto) |
| Rejected           | Quorum met but approval threshold not met · Majority voted "No"                                                                                      |
| Failed (No Quorum) | Less than 33.4% of bonded tokens participated · Proposal automatically fails                                                                         |
| Vetoed             | More than 33.4% of votes were "NoWithVeto" · Indicates strong community opposition                                                                   |

## Best Practices

### Community Engagement

Guidelines for effective governance participation.

* **Research Thoroughly** — Read proposals and understand their implications before voting.
* **Engage in Discussion** — Participate in community forums and discussions to better understand different perspectives.
* **Vote Responsibly** — Consider the long-term implications of proposals for the network and ecosystem.
* **Stay Informed** — Follow governance updates and participate actively in the democratic process.

---

URL: https://docs.sei.io/learn/proposals

# Proposals

> Complete guide to Sei governance proposals. Learn about different proposal types and how to submit them.

Complete guide to creating and submitting governance proposals on Sei. Learn about different proposal types, requirements, and submission commands.

<Info>For governance parameters and voting requirements, see the [Overview](/learn/general-governance) section.</Info>

## Proposal Types & Submission

### Text Proposals

**Community Discussion** — Non-binding proposals for community input and consensus building on important topics.

**Common Uses**

* Strategic direction
* Policy agreements
* Network guidelines

**Examples**

* Community input and consensus building
* Non-binding governance decisions
* Foundation for policy discussions
* Protocol direction and priorities

```bash theme={"dark"}
seid tx gov submit-proposal \
  --title "Community Initiative Proposal" \
  --description "Detailed description of the initiative..." \
  --type Text \
  --deposit 3500000000usei \
  --from mykey \
  --chain-id pacific-1
```

### Parameter Change Proposals

**Network Configuration** — Modify network parameters without requiring a software upgrade.

**Common Changes**

* Governance parameters
* Staking parameters
* Fee structures

**Prerequisites**

* Valid JSON format
* Comprehensive change documentation
* Impact assessment
* Testing results

```bash theme={"dark"}
seid tx gov submit-proposal param-change proposal.json \
  --deposit 3500000000usei \
  --from mykey \
  --chain-id pacific-1
```

<Info>**Example `proposal.json`:**</Info>

```json theme={"dark"}
{
  "title": "Update Staking Parameters",
  "description": "This proposal updates the maximum number of validators from 100 to 125.",
  "changes": [
    {
      "subspace": "staking",
      "key": "MaxValidators",
      "value": 125
    }
  ]
}
```

### Software Upgrade Proposals

**Network Upgrades** — Coordinate network-wide software upgrades with automatic execution at specified block height.

**Common Uses**

* Protocol upgrades
* Security patches
* New features
* Performance improvements

**Prerequisites**

* Upgrade height specification
* Binary release info
* Migration documentation
* Validator coordination

```bash theme={"dark"}
seid tx gov submit-proposal software-upgrade v2.1.0 \
  --upgrade-height 15000000 \
  --upgrade-info "https://github.com/sei-protocol/sei-chain/releases/v2.1.0" \
  --title "Sei v2.1.0 Upgrade" \
  --description "Network upgrade to v2.1.0 with enhanced performance" \
  --deposit 3500000000usei \
  --from mykey \
  --chain-id pacific-1
```

## Expedited Proposals

**Fast-Track Process** — For urgent network changes requiring immediate attention. Higher deposit and approval requirements with accelerated timeline.

* Security patches and critical fixes
* Emergency parameter adjustments
* Time-sensitive network upgrades

```bash theme={"dark"}
seid tx gov submit-proposal software-upgrade emergency-patch \
  --upgrade-height 15100000 \
  --upgrade-info "https://github.com/sei-protocol/sei-chain/releases/emergency-patch" \
  --title "Emergency Security Patch" \
  --description "Critical security fix requiring immediate deployment" \
  --deposit 7000000000usei \
  --expedited \
  --from mykey \
  --chain-id pacific-1
```

## Proposal Management

### Query & Monitor

| Command                    | Purpose               | Example                  |
| -------------------------- | --------------------- | ------------------------ |
| `seid q gov proposals`     | List all proposals    | `--status voting_period` |
| `seid q gov proposal [id]` | Get specific proposal | `seid q gov proposal 42` |
| `seid q gov votes [id]`    | Check voting results  | `seid q gov votes 42`    |
| `seid q gov tally [id]`    | View vote tally       | `seid q gov tally 42`    |

### Voting

```bash theme={"dark"}
# Vote on a proposal
seid tx gov vote [proposal-id] [vote-option] \
  --from mykey \
  --chain-id pacific-1

# Vote options: yes, no, abstain, no_with_veto
seid tx gov vote 42 yes \
  --from mykey \
  --chain-id pacific-1
```

### Deposit Management

```bash theme={"dark"}
# Add deposit to proposal
seid tx gov deposit [proposal-id] [amount] \
  --from mykey \
  --chain-id pacific-1

# Example: Add 1000 SEI to proposal 42
seid tx gov deposit 42 1000000000usei \
  --from mykey \
  --chain-id pacific-1
```

---

URL: https://docs.sei.io/learn/general-staking

# Sei Blockchain Staking Guide

> Participate in Sei's proof-of-stake consensus by staking tokens with validators, with detailed explanations of delegation, rewards, slashing risks, and the unbonding process.

Staking is a fundamental aspect of the Sei blockchain, enabling network security
and consensus through a delegated proof-of-stake (dPoS) mechanism. By
participating in staking, both validators and delegators play a critical role in
maintaining and securing the network, ensuring its long-term stability,
performance, and success. PoS chains rely on staked economic value rather than
computational power, leading to a more energy-efficient and scalable system.
Engaging in staking allows developers and users to contribute to the health and
growth of the Sei ecosystem and participate in [governance](/learn/general-governance)
decisions by voting on proposals.

In a dPoS system, token holders secure the network by delegating their tokens to
validators. Validators produce new blocks and validate transactions. In return
for their support, delegators earn a portion of the staking rewards. A
validator's weight is based on the number of tokens delegated to them plus their
own stake.

The Sei protocol incentivizes validators and delegators with staking rewards
from gas and genesis token unlocks. All rewards are distributed
to delegators proportional to their delegation, and the validator keeps a percentage of this as commission.
Users can view a validator's commission rate on the Sei Dashboard, or by querying the validator information on-chain.

## How to Stake

Staking on Sei can be done through the Sei Dashboard, via the `seid` CLI, or even
through API calls.

* **Sei Dashboard**: [Staking](https://dashboard.sei.io/stake)
* **seid CLI**: `seid tx staking [command] [flags]`
* **REST/RPC**: `GET/POST /staking/*`

## Key Concepts

### Delegation

Delegating tokens to a validator allows you to earn a portion of the staking
rewards. By delegating, you add to the validator's total stake, which helps
secure the network.

### Delegators

Delegators are users who stake their Sei tokens to a validator, contributing to
the validator's total stake. Delegators earn a portion of the transaction fees
as staking rewards. Staked Sei remains under the control of the delegator and
cannot be traded freely during the staking period.

### Un-delegation

Un-delegation is the process of withdrawing your staked tokens. This involves a
21-day un-bonding period during which the tokens are not earning rewards and
cannot be transferred. After the un-bonding period, the tokens are returned to
your wallet and are available for transactions.

### Re-delegation

Re-delegation allows you to move staked tokens from one validator to another
without undergoing the un-bonding period. When re-delegating, the tokens are
instantly moved, but the new validator is barred from further re-delegations for
21 days to ensure stability and prevent abuse. Each account can re-delegate a
maximum of 7 times simultaneously, with a re-delegation not considered complete
until the 21-day period is up.

### Bonding

Bonding is the process of committing your Sei tokens to a validator. This can be
done through delegation. The tokens are locked and contribute to the validator's
stake, starting to earn rewards immediately.

### Un-Bonding

Delegators can un-bond or un-stake their Sei tokens, initiating a 21-day period
during which the tokens do not earn rewards and cannot be transferred. After
this period, the tokens return to the delegator's wallet and become available
for transactions. Users can re-delegate to another validator instantly without
waiting for the un-bonding period to end.

### Jailing

To ensure network uptime and overall security, validators must meet strict standards and consistently participate in the consensus process.
Jailing can occur if these standards are not met. Jailed validators are excluded from
participating consensus for a period and will not generate rewards during this time.

<Info>
  When a validator misbehaves and gets jailed, users can still perform all staking operations including claiming rewards, delegating, and undelegating from that validator. Note that misbehaviors are currently not penalized in the system, so there are no slashing consequences for validator misconduct.
</Info>

### Slashing

There is no slashing of funds in Sei.

## Common Questions

### How are staking rewards calculated?

Staking rewards are calculated based on the total amount of Sei staked and the validator's performance. Rewards are distributed proportionally to the amount staked by each delegator.

For more details, see [Delegators](#delegators).

### Can I change my validator without un-bonding?

Yes, you can use the re-delegation feature to move your stake from one validator to another without waiting for the un-bonding period to end.

For more details, see [Re-delegation](#re-delegation).

---

URL: https://docs.sei.io/learn/dev-interoperability

# Sei Network Interoperability Framework

> Understand how Sei enables seamless interaction between EVM and Cosmos ecosystems through its dual address system and precompiles.

<Info>
  **CosmWasm deployments are frozen, and inbound IBC is being disabled.** Per [Proposal 115](https://www.mintscan.io/sei/proposals/115), no new CosmWasm contracts can be uploaded or instantiated on Sei. [Proposal 116](https://www.mintscan.io/sei/proposals/116) additionally disables inbound IBC transfers, so IBC assets bridged from Cosmos chains can no longer arrive on Sei. The interoperability features described on this page apply to **already-deployed** CosmWasm contracts, native Bank Module assets, and Cosmos-SDK modules accessed via precompiles. For new smart contract development, build directly on the EVM. See [SIP-3](https://github.com/sei-protocol/sips/blob/main/sips/sip-3.md) for the full migration context.
</Info>

## Dual Address Support

Sei utilizes two distinct address types:

* **EVM (0x) address:** Ethereum-style addresses, with "0x" prefix.
* **Cosmos address:** Bech-32 addresses, with "sei1" prefix.

Both addresses are derived from the same public key, ensuring seamless asset
integration across formats. You can find your corresponding wallet addresses
directly in the Sei Dashboard.

For more details on interoperability, explore our article
[here](https://blog.sei.io/sei-v2-interoperability/).

## Virtual Machine Interoperability

EVM and existing CosmWasm-based smart contracts co-exist on Sei, but live in
different execution environments. This creates a challenge for users, who use
wallets that typically only support a single execution environment. Likewise for
developers, existing tooling and libraries can only interact with either EVM or
Wasm (Think EthersJS vs CosmJS).

To bridge the gap between EVM and Wasm, Sei exposes Cosmos-SDK modules and
already-deployed CosmWasm contracts to the EVM via precompiled contracts. New
smart contracts on Sei should be deployed on the EVM directly.

## Precompile Contracts

Sei precompiles are smart contracts embedded directly within the Sei EVM
environment. They provide a gateway for users and developers to access Cosmos-SDK functions through the EVM RPC interface.

For instructions on utilizing EVM precompiles, refer to the
[Example Usage](/evm/precompiles/example-usage) section.

## Example Diagram

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/interoperability.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=627916f13ccb6a95abd7ce56fabe2324" alt="Interoperability" width="1746" height="1168" data-path="assets/interoperability.png" />

*Enabling seamless access to all tokens and contracts on Sei*

---

URL: https://docs.sei.io/learn/pointers

# Sei Pointer Contracts: Bridging EVM and Cosmos Environments

> Understand how Sei's pointer contract system enables seamless asset movement between EVM and Cosmos environments, with implementation patterns for various token types.

<Info>
  **Pointer contracts are now primarily a legacy / migration tool.** Per [Proposal 115](https://www.mintscan.io/sei/proposals/115), no new CosmWasm contracts can be uploaded or instantiated on Sei, so the CW20 / CW721 / CW1155 → ERC20 / ERC721 / ERC1155 pointer flow only applies to already-deployed CosmWasm contracts. Native (Bank Module) pointers continue to work normally. For new tokens or NFTs, deploy ERC20 / ERC721 / ERC1155 contracts directly on the EVM.
</Info>

Pointer Contracts enable tokens to be used interoperably in both EVM and
Cosmos environments. Intended to be efficient and quick to deploy, a pointer
serves as an interpreter between the two "languages" used in either
execution environment.

## Why Pointer Contracts

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/pointer-contracts-without.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=08760d514ffc07aa7b28cc73d182928d" alt="Without Pointer Contracts" width="2800" height="1340" data-path="assets/pointer-contracts-without.png" />

*A world without pointer contracts*

Wallets and clients for feature-rich protocols typically support only a single
execution environment. EVM wallets handle ERC-20 coins and ERC-721 NFTs but
cannot interact with Cosmos-SDK based assets due to different token standards and
interaction methods. The same problem exists for clients built for other
protocols (like Cosmos and its various SDK modules) which cannot directly interact with Ethereum-based contracts or ERC tokens.

Pointer Contracts solve this by enabling interoperability of either protocol,
regardless of the client interface.

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/pointer-contracts-simplified.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=0bf1c5e2277bb9f00a60b57155bf305a" alt="With Pointer Contracts" width="1752" height="704" data-path="assets/pointer-contracts-simplified.png" />

*With pointer contracts, all tokens can be accessed by wallets of either environment*

## How Pointer Contracts Work

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/pointer-contracts-how-it-works.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=c0c0aa401f46a4ba779b7a33e26b3360" alt="How Pointer Contracts Work" width="1746" height="1026" data-path="assets/pointer-contracts-how-it-works.png" />

*Pointer contracts enable seamless interoperability*

Each smart contract is limited to **one** associated pointer contract, which
must be registered on chain when deploying. This prevents conflicts and provides
a reference point for verifying the authenticity of the paired contract itself.

---

URL: https://docs.sei.io/learn/sei-giga

# Sei Giga Overview: The Fastest EVM Blockchain

> A comprehensive technical overview of Sei Giga - a high-performance blockchain platform combining EVM compatibility with groundbreaking consensus, execution, and storage innovations for unprecedented throughput and sub-second finality.

## Introduction

Sei Giga represents a high-performance blockchain platform designed to address the persistent challenges of the "blockchain trilemma": the difficulty of simultaneously optimizing for security, decentralization, and performance. The platform combines current optimizations with upcoming architectural innovations to achieve exceptional performance while maintaining security guarantees and developer experience.

<Info>**Current Features**: Sei operates with Twin Turbo consensus optimizations, parallel execution capabilities, and SeiDB storage, delivering significant performance improvements over traditional blockchains.</Info>

<Warning>**Upcoming Features**: Advanced features including Autobahn consensus, multi-proposer architecture, and 5 gigagas throughput targets are in development and represent the next evolution of the platform.</Warning>

## Current Architecture

Sei's current system delivers significant performance improvements through three core components:

### 1. Twin Turbo Consensus

The current consensus mechanism achieves \~400ms block times through aggressive optimization of the Tendermint BFT consensus engine. Key features include:

* Pipelined block processing
* Optimistic transaction execution during consensus
* Aggressive timeout configurations
* Parallel transaction decoding and validation

[Learn more about Twin Turbo Consensus →](/learn/twin-turbo-consensus)

### 2. Parallel Execution Engine

Sei implements Optimistic Concurrency Control (OCC) for parallel transaction execution:

* Multiple CPU cores process non-conflicting transactions simultaneously
* Automatic conflict detection and resolution
* Maintains deterministic execution order
* Compatible with standard EVM semantics

[Learn more about the Parallelization Engine →](/learn/parallelization-engine)

### 3. SeiDB Storage System

A specialized database optimized for blockchain workloads:

* Multi-level caching for hot state data
* Optimized Merkle Patricia Trie structure
* Concurrent state access controls
* Efficient state versioning and pruning

[Learn more about SeiDB →](/learn/seidb)

## Upcoming Sei Giga Architecture

The next evolution of Sei Giga will introduce three key innovations designed to achieve target performance characteristics:

### 1. Asynchronous Execution Model (Upcoming)

A planned architectural enhancement will implement complete separation of consensus and execution. Unlike traditional blockchains where these processes are tightly coupled, the upcoming Sei Giga architecture will reach consensus solely on the ordering of transactions within a block, not the resulting state change.

**Asynchronous Execution Architecture**

<Columns cols={2}>
  <Card horizontal title="Traditional Blockchain">
    1. Order Transactions
    2. Execute & Compute State
    3. Reach Consensus on State
    4. Finalize Block

    ⚠️ Execution delays consensus
  </Card>

  <Card horizontal title="Sei Giga Model">
    1. Order Transactions
    2. Consensus on Order
    3. Finalize Block n

    **Parallel Process:**

    * Execute Block $n - 1$
    * Commit State in Block $n+x$

    ✓ Consensus proceeds independently
  </Card>
</Columns>

This approach leverages the key property of deterministic execution:

**Lemma 1 (Deterministic Execution)**: Given the same initial state ($S_{init}$) and the same ordered sequence of transactions (${tx}_1, {tx}_2, ..., {tx}_n$), all honest nodes executing these transactions will arrive at the exact same final state ($S_{final}$).

Key benefits of this model:

* **Non-blocking consensus**: Heavy computational blocks don't delay consensus
* **Pipelined processing**: Multiple blocks can be in different stages simultaneously
* **Optimized resource usage**: Consensus and execution use different hardware resources

### 2. Autobahn Consensus Protocol (Upcoming)

<Warning>**Future Features**: The Autobahn consensus protocol described here represents upcoming enhancements. The current system uses optimized Tendermint consensus (Twin Turbo).</Warning>

The upcoming Sei Giga will employ Autobahn, a Byzantine Fault Tolerant (BFT) consensus protocol designed for high performance blockchain networks. Unlike traditional single-proposer systems, Autobahn will enable multiple validators to propose blocks simultaneously, targeting significant throughput improvements while maintaining security guarantees.

**Autobahn Consensus Architecture**

<Columns cols={2}>
  <Card horizontal title="Data Dissemination Layer (Lanes)">
    * **Lane $\ell_1$**: ${Prop}_1$, ${Prop}_2$, ${Prop}_3$, $Tip$
    * **Lane $\ell_2$**: ${Prop}_1$, ${Prop}_2$, $Tip$, ...
    * **Lane $\ell_n$**: ${Prop}_1$, ${Prop}_2$, ${Prop}_3$, $Tip$

    Each validator maintains independent lane.
  </Card>

  <Card horizontal title="Consensus Layer (Cut Formation)">
    $Cut = [{Tip}_1, {Tip}_2, ..., {Tip}_n]$

    Periodic ordering of lane tips.

    1. **Prepare Phase** — Leader collects tips, forms Cut
    2. **Fast Path** ($n$ votes) — Immediate commit if all agree
    3. **Slow Path** ($2f+1$ votes) — Additional round if needed

    Global ordering through BFT agreement.
  </Card>
</Columns>

**Protocol Properties**

<Columns cols={3}>
  <Card horizontal title="Network Model">
    $n = 3f + 1$ replicas
  </Card>

  <Card horizontal title="Safety">
    Unconditional
  </Card>

  <Card horizontal title="Liveness">
    Eventual synchrony
  </Card>
</Columns>

The protocol operates through two complementary layers:

**Data Dissemination Layer (Lanes)**:

* Each validator maintains an independent lane for proposing transaction batches
* Three-step certification process: Propose → Vote → Proof of Availability (PoA)
* Chained proposals ensure availability of historical data

**Consensus Layer (Cut of Tips)**:

* Periodic ordering of latest certified tips from all lanes
* Two-phase BFT agreement with fast and slow paths
* Pipelined slots for minimal latency

### 3. Advanced Parallel Execution

The parallel execution architecture extends beyond current OCC capabilities to include:

**Parallel Execution Pipeline**

<Columns cols={4}>
  <Card horizontal title="Stage 1">
    **Transaction Parsing**

    Parallel decode
  </Card>

  <Card horizontal title="Stage 2">
    **Dependency Analysis**

    Conflict prediction
  </Card>

  <Card horizontal title="Stage 3">
    **Parallel Execution**

    Multi-core OCC
  </Card>

  <Card horizontal title="Stage 4">
    **State Commit**

    Batch writes
  </Card>
</Columns>

<Columns cols={2}>
  <Card horizontal title="Conflict Detection">
    * Read/Write set tracking
    * Optimistic execution
    * Automatic re-execution on conflict
    * Preserves deterministic ordering
  </Card>

  <Card horizontal title="Performance Stats">
    * \~65% of ETH txs parallelizable
    * Linear scaling with cores
    * Minimal conflict overhead
    * Zero-copy transaction handling
  </Card>
</Columns>

Key innovations in the execution model:

* **Flat encoding format**: Length-prefixed layout for fast, zero-copy decoding
* **Predictive conflict analysis**: ML-based prediction of transaction dependencies
* **Semantic understanding**: Special handling for common patterns (ERC-20 transfers)
* **Adaptive parallelism**: Dynamic adjustment based on conflict rates

## Storage Architecture Evolution

Beyond the current SeiDB capabilities, the Sei Giga architecture includes advanced storage innovations:

**Hybrid Storage Architecture**

<Columns cols={3}>
  <Card horizontal title="Hot Storage Tier">
    * **Recent Blocks** — High-speed NVMe SSDs
    * **Active State** — Memory-mapped files
    * **Access Pattern** — Sub-ms latency
  </Card>

  <Card horizontal title="Warm Storage Tier">
    * **Recent History** — Standard SSDs
    * **Compressed State** — LZ4 compression
    * **Access Pattern** — 1-10ms latency
  </Card>

  <Card horizontal title="Cold Storage Tier">
    * **Historical Data** — Distributed storage
    * **Columnar Format** — Analytics optimized
    * **Access Pattern** — Batch queries
  </Card>
</Columns>

**Cryptographic Layer**

<Columns cols={3}>
  <Card horizontal title="Flat KV Store">
    LSM-tree based
  </Card>

  <Card horizontal title="Cryptographic Accumulators">
    Compact proofs
  </Card>

  <Card horizontal title="Write-Ahead Log">
    Durability guarantee
  </Card>
</Columns>

## Economic Model

Sei operates with a native SEI token that serves multiple functions within the ecosystem:

### Token Distribution

* **Total Supply**: 10,000,000,000 (10 billion) SEI
* **Initial Distribution**: Allocated across ecosystem participants, validators, and development

### Token Utility

1. **Gas Fees**: All transactions require SEI for execution
2. **Staking**: Validators and delegators stake SEI to secure the network
3. **Governance**: SEI holders participate in protocol governance
4. **Rewards**: Block rewards and fee distribution to validators

### Staking Mechanics

**Staking & Validation**

<Columns cols={2}>
  <Card horizontal title="Validators">
    * **Self-Stake Requirement** — Minimum SEI to operate
    * **Commission Rate** — Set by validator
    * **Responsibilities** — Consensus & execution
  </Card>

  <Card horizontal title="Delegators">
    * **Delegation** — Stake with chosen validators
    * **Rewards** — Proportional to stake
    * **Unbonding** — 21-day period
  </Card>
</Columns>

**Slashing Conditions**

<Columns cols={2}>
  <Card horizontal title="Liveness Failures">
    Penalties for downtime
  </Card>

  <Card horizontal title="Safety Violations">
    Severe penalties for double-signing
  </Card>
</Columns>

## Developer Experience

Sei maintains full EVM compatibility while providing enhanced capabilities:

### Standard EVM Features

* Complete support for Solidity and Vyper
* Standard JSON-RPC endpoints
* Compatible with existing tools (Hardhat, Foundry, Remix)
* Familiar development workflow

### Enhanced Capabilities

* Sub-second transaction finality
* Predictable gas costs
* High throughput for complex applications
* Advanced storage access patterns

## Implementation Status

**Current & Upcoming Features**

<Card horizontal title="Current Implementation — Live on Mainnet" icon="check">
  <Columns cols={3}>
    <Card horizontal title="Twin Turbo Consensus">
      \~400ms blocks
    </Card>

    <Card horizontal title="Parallel Execution">
      Multi-core processing
    </Card>

    <Card horizontal title="SeiDB Storage">
      Optimized state access
    </Card>
  </Columns>
</Card>

<Card horizontal title="Upcoming Features — In Development" icon="clock">
  <Columns cols={3}>
    <Card horizontal title="Autobahn Consensus">
      Multi-proposer protocol
    </Card>

    <Card horizontal title="5 Gigagas Throughput">
      Performance target
    </Card>

    <Card horizontal title="Advanced Optimizations">
      Enhanced execution
    </Card>
  </Columns>
</Card>

## Learn More

Explore the technical components that make Sei's performance possible:

* [Twin Turbo Consensus →](/learn/twin-turbo-consensus)
* [Parallelization Engine →](/learn/parallelization-engine)
* [SeiDB Storage →](/learn/seidb)
* [Developer Guide →](/learn/sei-giga-developers)

---

URL: https://docs.sei.io/learn/sei-giga-specs

# Sei Giga Technical Specifications

> Comprehensive technical specifications for Sei Giga architecture, consensus protocols, and performance characteristics

## Introduction

This document provides comprehensive technical specifications for Sei Giga, covering both current features and upcoming architectural enhancements.

The specifications are organized to clearly distinguish between what is currently deployed and what is planned for future releases.

<Columns cols={2}>
  <Card horizontal title="Current Implementation" icon="circle-check">
    Features and specifications that are live on the Sei network today.
  </Card>

  <Card horizontal title="Upcoming Features" icon="clock">
    Planned features and specifications in development.
  </Card>
</Columns>

## Consensus Architecture

### Current: Twin Turbo Consensus

<Card horizontal title="Live Implementation" icon="circle-check">
  <Columns cols={2}>
    <Card horizontal title="Protocol Specifications">
      | Property          | Value                   |
      | ----------------- | ----------------------- |
      | Base Protocol     | Enhanced Tendermint BFT |
      | Marketing Name    | Twin Turbo Consensus    |
      | Target Block Time | \~400ms                 |
      | Finality          | Instant (1 block)       |
      | Safety Threshold  | ⅔ + 1 validators        |
    </Card>

    <Card horizontal title="Optimizations">
      * Pipelined block processing
      * Optimistic execution
      * Aggressive timeouts
      * Parallel validation
    </Card>
  </Columns>
</Card>

### Upcoming: Autobahn Consensus

<Card horizontal title="In Development" icon="clock">
  <Columns cols={2}>
    <Card horizontal title="Protocol Design">
      | Property          | Value                    |
      | ----------------- | ------------------------ |
      | Architecture      | Multi-proposer BFT       |
      | Target Block Time | Sub-second               |
      | Proposer Model    | Parallel lanes           |
      | Safety Model      | Byzantine Fault Tolerant |
    </Card>

    <Card horizontal title="Key Innovations">
      * Asynchronous execution
      * Data availability lanes
      * Consensus/execution separation
      * Optimized data dissemination
    </Card>
  </Columns>
</Card>

## Execution Engine

### Current: Parallel EVM Execution

<Card horizontal title="Live Implementation" icon="circle-check">
  <Columns cols={3}>
    <Card horizontal title="EVM Compatibility">
      Full Ethereum Virtual Machine compatibility with standard opcodes and gas metering.
    </Card>

    <Card horizontal title="OCC Parallel Execution">
      Optimistic Concurrency Control with multi-worker transaction processing and conflict resolution.
    </Card>

    <Card horizontal title="State Management">
      Optimized state access patterns with SeiDB storage backend.
    </Card>
  </Columns>

  **Execution Specifications**

  | Property            | Value                    |
  | ------------------- | ------------------------ |
  | VM Type             | Ethereum Virtual Machine |
  | Gas Model           | Ethereum-compatible      |
  | Execution Model     | Parallel with OCC        |
  | Supported Languages | Solidity, Vyper, YUL     |
  | Precompiles         | Standard + Sei Native    |
  | State Model         | Account-based            |
</Card>

## Storage Architecture

### Current: SeiDB

<Card horizontal title="Live Implementation" icon="circle-check">
  <Columns cols={2}>
    <Card horizontal title="Architecture">
      | Property      | Value                                  |
      | ------------- | -------------------------------------- |
      | Storage Type  | Key-Value Store                        |
      | State Storage | MemIAVL (Cosmos) + FlatKV/LtHash (EVM) |
      | Caching       | Multi-level                            |
      | Concurrency   | Thread-safe                            |
    </Card>

    <Card horizontal title="Optimizations">
      * Hot state caching
      * Efficient pruning
      * Parallel state access
      * Optimized serialization
    </Card>
  </Columns>
</Card>

## Network Specifications

### Protocol Parameters

**Network Configuration**

<Columns cols={2}>
  <Card horizontal title="Consensus Parameters">
    | Property         | Value              |
    | ---------------- | ------------------ |
    | Max Validators   | 100                |
    | Voting Power     | Stake-weighted     |
    | Unbonding Period | 21 days            |
    | Slashing         | Byzantine behavior |
  </Card>

  <Card horizontal title="Block Parameters">
    | Property       | Value                                                      |
    | -------------- | ---------------------------------------------------------- |
    | Max Block Size | 21 MB                                                      |
    | Max Gas Limit  | 12.5 M                                                     |
    | Base Fee       | Dynamic, on-chain param; no burn (validators receive fees) |
    | Priority Fee   | Supported                                                  |
  </Card>
</Columns>

## Performance Targets

<Warning>**Engineering Targets**: The following performance specifications represent engineering targets for the upcoming Sei Giga architecture with Autobahn consensus, not current network performance.</Warning>

### Upcoming: Target Performance Specifications

<Card horizontal title="Performance Targets" icon="gauge-high">
  <Columns cols={3}>
    <Card horizontal title="5B Gas per Second">
      Peak throughput target
    </Card>

    <Card horizontal title="<1s Finality">
      Transaction confirmation
    </Card>

    <Card horizontal title="200K+ TPS">
      Simple transfers
    </Card>
  </Columns>
</Card>

## Developer Interface

### JSON-RPC Compatibility

**Ethereum JSON-RPC Support**

<Columns cols={2}>
  <Card horizontal title="Standard Methods">
    * `eth_sendRawTransaction`
    * `eth_call`
    * `eth_getBalance`
    * `eth_getTransactionReceipt`
  </Card>

  <Card horizontal title="Enhanced Methods">
    * `debug_traceTransaction`
    * `eth_feeHistory`
    * `eth_maxPriorityFeePerGas`
  </Card>
</Columns>

## Related Resources

<Columns cols={2}>
  <Card horizontal title="Overview" icon="book" href="/learn/sei-giga">
    High-level introduction to Sei Giga architecture and features.
  </Card>

  <Card horizontal title="Developer Guide" icon="code" href="/learn/sei-giga-developers">
    Complete guide for building applications on Sei Giga.
  </Card>
</Columns>

---

URL: https://docs.sei.io/learn/sei-giga-developers

# Sei Giga Developer Guide

> Key patterns and techniques for building high-performance dApps on Sei Giga

<Info>This is a sneak peek at the patterns and optimizations developers should consider when building on Sei Giga. For current EVM development tutorials, check out the [EVM development guides](/evm/evm-general).</Info>

## Why Build on Sei Giga?

* **Familiar Tools:** Full EVM compatibility—use existing Ethereum tooling
* **Parallel Execution:** Transactions touching different state run simultaneously
* **Lower Costs:** Efficient architecture means cheaper transactions
* **Native Precompiles:** Access to staking, and more from Solidity

## Key Development Patterns

### Pattern 1: User-Isolated State

Sei Giga's parallel execution engine rewards contracts with isolated state. When users' operations don't touch shared state, they execute simultaneously.

```solidity theme={"dark"}
// GOOD: Each user has isolated state - transfers can run in parallel
contract OptimizedToken {
    mapping(address => uint256) private balances;

    function transfer(address to, uint256 amount) public {
        require(balances[msg.sender] >= amount);
        balances[msg.sender] -= amount;
        balances[to] += amount;
    }
}

// BAD: Global counter forces sequential execution
contract PoorToken {
    uint256 public totalTransfers; // Every transfer conflicts!

    function transfer(address to, uint256 amount) public {
        totalTransfers++; // Blocks parallelism
        // ... transfer logic
    }
}
```

### Pattern 2: Struct Packing

Pack struct variables to minimize storage slots and reduce gas costs.

```solidity theme={"dark"}
contract OptimizedStorage {
    // GOOD: Uses 1 storage slot (256 bits total)
    struct User {
        uint128 balance;    // 128 bits
        uint64 lastUpdate;  // 64 bits
        uint64 nonce;       // 64 bits
    }

    // BAD: Uses 3 storage slots
    struct InefficientUser {
        uint256 balance;    // 256 bits = 1 slot
        uint64 lastUpdate;  // 64 bits = 1 slot (wastes 192 bits)
        uint64 nonce;       // 64 bits = 1 slot (wastes 192 bits)
    }
}
```

### Pattern 3: Event-Driven Architecture

Store historical data in events instead of storage to reduce costs.

```solidity theme={"dark"}
contract EventDrivenAuction {
    mapping(uint256 => uint128) public highestBids;

    // Bid history stored in events, not storage
    event BidPlaced(uint256 indexed auctionId, address indexed bidder, uint256 amount);

    function bid(uint256 auctionId) external payable {
        require(msg.value > highestBids[auctionId], "Bid too low");
        highestBids[auctionId] = uint128(msg.value);
        emit BidPlaced(auctionId, msg.sender, msg.value); // Cheap!
    }
}
```

## Gas Optimization Tips

<Info>
  **Quick Wins:**

  * Use `memory` for temporary data, `calldata` for read-only parameters
  * Cache array lengths in loops: `uint256 len = arr.length;`
  * Use `unchecked { i++; }` in loops where overflow is impossible
  * Batch operations to amortize base transaction costs
</Info>

## Native Precompiles

Sei Giga will also provide precompiles for direct access to chain features from Solidity.

See the [Precompiles documentation](/evm/precompiles) for full details.

## Development Checklists

### Parallel Execution Checklist

* Isolate state by user/entity
* Avoid global counters and shared state
* Use mappings over arrays for lookups

### Gas Optimization Checklist

* Pack structs to minimize storage slots
* Use events for historical data
* Cache array lengths in loops
* Batch operations when possible

## Next Steps

1. **Full Tutorials** - Start with the [EVM development guides](/evm/evm-general)
2. **Architecture Details** - Review the [Sei Giga Overview](/learn/sei-giga)
3. **Precompiles** - Explore [native precompiles](/evm/precompiles) for advanced features

---

URL: https://docs.sei.io/learn/hardware-wallets

> Comprehensive guide to Hardware Wallets on Sei. Learn key concepts, commands, and best practices.

# Hardware Wallets

Signing transactions manually or using hardware wallets like Ledger ensures
secure transaction approval. To sign Sei transactions, install the Ethereum app
(or the dedicated Sei app) on your Ledger device and sign through an EVM wallet
such as MetaMask.

<Note>
  The legacy flow that used the Cosmos app with a Cosmos RPC endpoint is
  deprecated: per [SIP-03](/learn/sip-03-migration), Cosmos-native interfaces are
  slated for deprecation on June 15, 2026. If you still hold funds on a Ledger
  Cosmos-app (`sei1...`) account, see
  [Migrating a hardware or mnemonic-only wallet](/learn/sip-03-migration#migrating-a-hardware-or-mnemonic-only-wallet).
</Note>

## Using MetaMask with Ledger

To connect your Ledger device through MetaMask and sign transactions:

1. **Install MetaMask**: Ensure MetaMask is installed on your browser.

2. **Connect Ledger**: Open MetaMask, go to the account options, and select
   “Connect Hardware Wallet”.

3. **Follow Instructions**: Follow the on-screen instructions to connect your
   Ledger device and select the account you want to use.

4. **Sign Transactions**: Once connected, you can sign transactions directly
   through MetaMask using your Ledger device.

**Installing the Ethereum App on Ledger**

Before you can use your Ledger device to sign transactions through MetaMask,
ensure you have the Ethereum app installed. You can install it through Ledger
Live:

• [Ledger App Store - Ethereum App](https://www.ledger.com/coin/wallet/ethereum)

Alternatively, you can install the dedicated Sei app from the Ledger Live App
Catalog — see [Ledger Setup](/learn/ledger-setup) for step-by-step
instructions.

---

URL: https://docs.sei.io/learn/ledger-setup

# Ledger Hardware Wallet Setup Guide for Sei

> Configure your Ledger hardware wallet to securely manage Sei assets, with step-by-step instructions for installation, receiving and sending transactions, and security best practices.

## Introduction

The Sei network supports various crypto assets, including:

* Native tokens (\$SEI)
* ERC20 tokens
* ERC721 NFTs

Using a Ledger hardware wallet ensures secure key management for users interacting
with the Sei network.

## Requirements

Before proceeding, ensure you have:

* A Ledger wallet device
* [Ledger Live](https://www.ledger.com/ledger-live) app installed on your
  desktop or mobile device
* A compatible wallet application for Sei network (refer to Sei documentation
  for recommended wallets)
* USB cable for connecting your device (Bluetooth is an option for some models)
* Latest firmware installed on your Ledger device
* Active internet connection

## Installation Instructions

### Install Ledger Live

1. **Download Ledger Live**: Visit the
   [Ledger official website](https://www.ledger.com/start) and download Ledger
   Live for your operating system.

2. **Install Ledger Live**: Follow the installation instructions for your
   platform.

3. **Set Up Ledger Live**: Open Ledger Live and follow the on-screen
   instructions to set up your Ledger device.

4. **Install the Sei App on Ledger**:
   * In Ledger Live, go to **"My Ledger"**.
   * Connect and unlock your Ledger device.
   * Search for "Sei" in the App Catalog and click **Install**.

<Info>Linux users will need to add a `udev rule` to allow access to the device. You can find the script to add a rule in the Ledger repo [here](https://github.com/LedgerHQ/udev-rules).</Info>

## Setup Instructions

### Using a Compatible Wallet Application

1. **Connect Your Ledger Device**:

   * Open your compatible Sei network wallet application.
   * Connect your Ledger device to your computer.
   * Unlock your Ledger device and open the Sei app.

2. **Access the Sei Network**:

   * In your wallet application, select the option to connect with a Ledger
     device.
   * Follow the prompts to establish a connection with your Ledger device.

## Viewing Account Balance

1. Open your Sei network wallet application.
2. Ensure your Ledger device is connected and the Sei app is open.
3. Your account balance and asset details should be displayed on the main screen
   of the wallet application.

## How to Receive Crypto Assets

1. **Navigate to the Receive Section**:

   * Go to the **Receive** or similar section in your wallet application.
   * Select the crypto asset (if applicable) you wish to receive.

2. **Verify the Receiver Address**:

   * The wallet application will display the receiver address.
   * Verify that the address shown on the screen matches the one displayed on
     your Ledger device.
   * Confirm the address on your Ledger device by pressing the appropriate
     buttons.

<Warning>Always verify the receiver address on your Ledger device before sharing it. This prevents attacks like address spoofing.</Warning>

3. **Share the Address**:
   * Copy the verified address and share it with the sender or paste it into an
     exchange withdrawal form.

## How to Send Crypto Assets

1. **Navigate to the Send Section**:

   * Navigate to the **Send** section (or equivalent) in your wallet
     application.
   * Select the crypto asset you wish to send.

2. **Enter Transaction Details**:

   * Enter the recipient's address.
   * Input the amount you want to send.
   * (Optional) Add a memo if required.

3. **Submit the Transaction**:

   * Initiate the send process in your wallet application.

4. **Verify and Confirm on Ledger Device**:
   * Review the transaction details displayed on the Ledger device.
   * Verify that the recipient's address, amount, and other transaction details
     are correct.
   * Confirm and broadcast the transaction by pressing the appropriate buttons
     on your Ledger device.

<Warning>Always double-check the transaction details on your Ledger device before confirming. This is your last line of defense against potential attacks or errors.</Warning>

## Support

For further assistance, you can reach out to the following support channels:

* **Sei Network Community**: Join the official Sei network community
  [Telegram](https://t.me/seinetwork) or [Discord](https://discord.gg/sei).
* **Ledger Support**: For Ledger-specific issues, visit the
  [Ledger Support Center](https://support.ledger.com/).
* **Wallet Support**: For wallet-related questions, check the support resources
  provided by your chosen wallet application.

## Additional Resources

* **Ledger Academy**: Learn more about cryptocurrency security on the official
  [Ledger Academy](https://www.ledger.com/academy).

<Danger>Never share your recovery phrase with anyone. Keep it in a safe, offline location. Your recovery phrase is the only way to restore access to your funds if your device is lost or damaged.</Danger>

---

URL: https://docs.sei.io/learn/general-brand-kit

> Official Sei brand guidelines — logos, colors, typography, and usage rules for marketing communications, partners, and the broader ecosystem.

# Sei Brand Guidelines

<Info>
  Please adhere to these guidelines when featuring Sei in marketing communications, advertising, articles, websites, partner materials, and any printed assets.

  **Download the full brand kit:** [sei-brand-assets.zip](https://brand.sei.io/sei-brand-assets.zip) · Full interactive version at [brand.sei.io](https://brand.sei.io)
</Info>

Black and white carry the brand. Maroon and Gold are heritage accents — use them only for emphasis and legacy moments, never as the base palette.

Sei delivers breakthrough performance through the world's first multi-proposer EVM Layer 1, combining unmatched speed, security, and seamless execution. Every design decision communicates speed, trust, and uncompromising quality.

***

<div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '11px', letterSpacing: '0.08em', textTransform: 'uppercase', color: 'var(--sei-gold-100, #966f22)', marginTop: '2.5rem', marginBottom: '0.5rem' }}>
  01 — Logo
</div>

## Primary Logo

The Sei primary lock-up consists of two elements: the **symbol** and the **wordmark**. This lock-up is the main representation of the brand and should be used consistently as a combined unit.

<div className="not-prose" style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(260px, 1fr))', gap: '12px', marginTop: '1.25rem' }}>
  <div style={{ aspectRatio: '4 / 3', background: '#ffffff', border: '1px solid #ececee', position: 'relative' }}>
    <div style={{ position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '14% 14%' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/logo/sei-lockup-on-light.svg?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=3b454ed0765c5c7483cb3f1a1051b250" alt="Sei lockup on light background" style={{ width: '100%', maxWidth: '240px', height: 'auto', display: 'block', filter: 'none', pointerEvents: 'none' }} width="312" height="120" data-path="assets/brand/logo/sei-lockup-on-light.svg" />
    </div>

    <span style={{ position: 'absolute', bottom: '12px', left: '14px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#666' }}>Lockup · Light</span>
    <a href="/assets/brand/logo/sei-lockup-on-light.svg" download style={{ position: 'absolute', top: '10px', right: '12px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#600014', textDecoration: 'none', borderBottom: 'none' }}>↓ SVG</a>
  </div>

  <div style={{ aspectRatio: '4 / 3', background: '#000000', border: '1px solid #2a2a2a', position: 'relative' }}>
    <div style={{ position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '14% 14%' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/logo/sei-lockup-on-dark.svg?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=6b62fc8a79be1095f91cea94425afa3e" alt="Sei lockup on dark background" style={{ width: '100%', maxWidth: '240px', height: 'auto', display: 'block', filter: 'none', pointerEvents: 'none' }} width="312" height="120" data-path="assets/brand/logo/sei-lockup-on-dark.svg" />
    </div>

    <span style={{ position: 'absolute', bottom: '12px', left: '14px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#999' }}>Lockup · Dark</span>
    <a href="/assets/brand/logo/sei-lockup-on-dark.svg" download style={{ position: 'absolute', top: '10px', right: '12px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#d6c9ac', textDecoration: 'none', borderBottom: 'none' }}>↓ SVG</a>
  </div>
</div>

## Symbol

The **symbol** is the standalone Sei mark. Use it on its own only when the wordmark is already established elsewhere on the surface (favicons, app icons, watermarks).

<div className="not-prose" style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(260px, 1fr))', gap: '12px', marginTop: '1.25rem' }}>
  <div style={{ aspectRatio: '4 / 3', background: '#ffffff', border: '1px solid #ececee', position: 'relative' }}>
    <div style={{ position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '20%' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/logo/sei-mark.svg?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=32bdf147a3505c869caffa8c2d212f5a" alt="Sei symbol on light background" style={{ width: 'auto', height: '100%', maxHeight: '90px', display: 'block', filter: 'none', pointerEvents: 'none' }} width="240" height="240" data-path="assets/brand/logo/sei-mark.svg" />
    </div>

    <span style={{ position: 'absolute', bottom: '12px', left: '14px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#666' }}>Symbol · Light</span>
    <a href="/assets/brand/logo/sei-mark.svg" download style={{ position: 'absolute', top: '10px', right: '12px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#600014', textDecoration: 'none', borderBottom: 'none' }}>↓ SVG</a>
  </div>

  <div style={{ aspectRatio: '4 / 3', background: '#000000', border: '1px solid #2a2a2a', position: 'relative' }}>
    <div style={{ position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '20%' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/logo/sei-mark-white.svg?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=3649945bb794e01413c901eaa7a044fb" alt="Sei symbol on dark background" style={{ width: 'auto', height: '100%', maxHeight: '90px', display: 'block', filter: 'none', pointerEvents: 'none' }} width="240" height="240" data-path="assets/brand/logo/sei-mark-white.svg" />
    </div>

    <span style={{ position: 'absolute', bottom: '12px', left: '14px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#999' }}>Symbol · Dark</span>
    <a href="/assets/brand/logo/sei-mark-white.svg" download style={{ position: 'absolute', top: '10px', right: '12px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#d6c9ac', textDecoration: 'none', borderBottom: 'none' }}>↓ SVG</a>
  </div>
</div>

## Token

The **token mark** appears in Maroon. Black and white are fallbacks for constrained environments.

<div className="not-prose" style={{ position: 'relative', aspectRatio: '16 / 7', width: '100%', overflow: 'hidden', background: '#f5f5f7', border: '1px solid #ececee', marginTop: '1.25rem' }}>
  <div style={{ position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '6%' }}>
    <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/logo/sei-token-maroon.svg?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=cf73861a8f83845154e2c0f81824651c" alt="Sei token mark in Maroon" style={{ width: 'auto', height: '100%', maxHeight: '110px', display: 'block', filter: 'none', pointerEvents: 'none' }} width="240" height="240" data-path="assets/brand/logo/sei-token-maroon.svg" />
  </div>

  <a href="/assets/brand/logo/sei-token-maroon.svg" download style={{ position: 'absolute', bottom: '16px', right: '16px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#966f22', textDecoration: 'none', borderBottom: 'none' }}>↓ Download SVG</a>
</div>

## Powered by Sei

For ecosystem and partner surfaces. Keep the lockup intact and match the clearspace rules.

<div className="not-prose" style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(260px, 1fr))', gap: '12px', marginTop: '1.25rem' }}>
  <div style={{ aspectRatio: '4 / 3', background: '#ffffff', border: '1px solid #ececee', position: 'relative' }}>
    <div style={{ position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '14%' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/logo/sei-powered-by-vertical-on-light.svg?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=c7848336e51182186f8a480819b21d93" alt="Powered by Sei (vertical) on light" style={{ width: 'auto', height: '100%', maxHeight: '130px', display: 'block', filter: 'none', pointerEvents: 'none' }} width="244" height="85" data-path="assets/brand/logo/sei-powered-by-vertical-on-light.svg" />
    </div>

    <span style={{ position: 'absolute', bottom: '12px', left: '14px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#666' }}>Vertical · Light</span>
    <a href="/assets/brand/logo/sei-powered-by-vertical-on-light.svg" download style={{ position: 'absolute', top: '10px', right: '12px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#600014', textDecoration: 'none', borderBottom: 'none' }}>↓ SVG</a>
  </div>

  <div style={{ aspectRatio: '4 / 3', background: '#000000', border: '1px solid #2a2a2a', position: 'relative' }}>
    <div style={{ position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '14%' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/logo/sei-powered-by-vertical-on-dark.svg?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=f00a8b91e62047d740abbdbb0145cc4a" alt="Powered by Sei (vertical) on dark" style={{ width: 'auto', height: '100%', maxHeight: '130px', display: 'block', filter: 'none', pointerEvents: 'none' }} width="244" height="85" data-path="assets/brand/logo/sei-powered-by-vertical-on-dark.svg" />
    </div>

    <span style={{ position: 'absolute', bottom: '12px', left: '14px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#999' }}>Vertical · Dark</span>
    <a href="/assets/brand/logo/sei-powered-by-vertical-on-dark.svg" download style={{ position: 'absolute', top: '10px', right: '12px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#d6c9ac', textDecoration: 'none', borderBottom: 'none' }}>↓ SVG</a>
  </div>

  <div style={{ aspectRatio: '4 / 3', background: '#ffffff', border: '1px solid #ececee', position: 'relative' }}>
    <div style={{ position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '14%' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/logo/sei-powered-by-horizontal-on-light.svg?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=0beb6d4e8c6586c6cff8516d427d3725" alt="Powered by Sei (horizontal) on light" style={{ width: '100%', maxWidth: '240px', height: 'auto', display: 'block', filter: 'none', pointerEvents: 'none' }} width="304" height="45" data-path="assets/brand/logo/sei-powered-by-horizontal-on-light.svg" />
    </div>

    <span style={{ position: 'absolute', bottom: '12px', left: '14px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#666' }}>Horizontal · Light</span>
    <a href="/assets/brand/logo/sei-powered-by-horizontal-on-light.svg" download style={{ position: 'absolute', top: '10px', right: '12px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#600014', textDecoration: 'none', borderBottom: 'none' }}>↓ SVG</a>
  </div>

  <div style={{ aspectRatio: '4 / 3', background: '#000000', border: '1px solid #2a2a2a', position: 'relative' }}>
    <div style={{ position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '14%' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/logo/sei-powered-by-horizontal-on-dark.svg?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=92fbeb61ce11119537385c8e18f9f218" alt="Powered by Sei (horizontal) on dark" style={{ width: '100%', maxWidth: '240px', height: 'auto', display: 'block', filter: 'none', pointerEvents: 'none' }} width="304" height="45" data-path="assets/brand/logo/sei-powered-by-horizontal-on-dark.svg" />
    </div>

    <span style={{ position: 'absolute', bottom: '12px', left: '14px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#999' }}>Horizontal · Dark</span>
    <a href="/assets/brand/logo/sei-powered-by-horizontal-on-dark.svg" download style={{ position: 'absolute', top: '10px', right: '12px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#d6c9ac', textDecoration: 'none', borderBottom: 'none' }}>↓ SVG</a>
  </div>
</div>

***

<div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '11px', letterSpacing: '0.08em', textTransform: 'uppercase', color: 'var(--sei-gold-100, #966f22)', marginTop: '3rem', marginBottom: '0.5rem' }}>
  02 — Color
</div>

## Color

Black and white carry the brand. Maroon and Gold are heritage accents — use them only for emphasis and legacy moments, never as the base palette.

### Primary Palette

<div className="not-prose" style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: '12px', marginTop: '1.25rem' }}>
  <div style={{ aspectRatio: '4 / 5', background: '#000000', color: '#ffffff', padding: '20px', display: 'flex', flexDirection: 'column', justifyContent: 'space-between', border: '1px solid #ececee' }}>
    <span style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', opacity: 0.7 }}>Base Color</span>

    <div>
      <div style={{ fontFamily: 'var(--sei-font-display, "Lateral Condensed")', fontWeight: 700, fontSize: '28px', letterSpacing: '-0.015em' }}>Black</div>
      <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '12px', letterSpacing: '0.04em', opacity: 0.8, marginTop: '4px' }}>#000000</div>
    </div>
  </div>

  <div style={{ aspectRatio: '4 / 5', background: '#ffffff', color: '#000000', padding: '20px', display: 'flex', flexDirection: 'column', justifyContent: 'space-between', border: '1px solid #ececee' }}>
    <span style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', opacity: 0.7 }}>Base Color</span>

    <div>
      <div style={{ fontFamily: 'var(--sei-font-display, "Lateral Condensed")', fontWeight: 700, fontSize: '28px', letterSpacing: '-0.015em' }}>White</div>
      <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '12px', letterSpacing: '0.04em', opacity: 0.8, marginTop: '4px' }}>#FFFFFF</div>
    </div>
  </div>

  <div style={{ aspectRatio: '4 / 5', background: '#600014', color: '#ffffff', padding: '20px', display: 'flex', flexDirection: 'column', justifyContent: 'space-between', border: '1px solid #ececee' }}>
    <span style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', opacity: 0.85 }}>Headlines · CTAs · Accents</span>

    <div>
      <div style={{ fontFamily: 'var(--sei-font-display, "Lateral Condensed")', fontWeight: 700, fontSize: '28px', letterSpacing: '-0.015em' }}>Maroon</div>
      <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '12px', letterSpacing: '0.04em', opacity: 0.85, marginTop: '4px' }}>#600014</div>
    </div>
  </div>

  <div style={{ aspectRatio: '4 / 5', background: '#966F22', color: '#ffffff', padding: '20px', display: 'flex', flexDirection: 'column', justifyContent: 'space-between', border: '1px solid #ececee' }}>
    <span style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', opacity: 0.85 }}>Data stats · Highlights</span>

    <div>
      <div style={{ fontFamily: 'var(--sei-font-display, "Lateral Condensed")', fontWeight: 700, fontSize: '28px', letterSpacing: '-0.015em' }}>Gold</div>
      <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '12px', letterSpacing: '0.04em', opacity: 0.85, marginTop: '4px' }}>#966F22</div>
    </div>
  </div>
</div>

### Neutral Ramp

<div className="not-prose" style={{ display: 'grid', gridTemplateColumns: 'repeat(8, 1fr)', gap: '4px', marginTop: '1.25rem' }}>
  <div style={{ aspectRatio: '1 / 1.4', background: '#FFFFFF', color: '#000', padding: '10px 8px', display: 'flex', flexDirection: 'column', justifyContent: 'flex-end', border: '1px solid #ececee', fontSize: '11px' }}>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontWeight: 500 }}>White</div>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', opacity: 0.7, fontSize: '10px', marginTop: '2px' }}>#FFFFFF</div>
  </div>

  <div style={{ aspectRatio: '1 / 1.4', background: '#F5F5F7', color: '#000', padding: '10px 8px', display: 'flex', flexDirection: 'column', justifyContent: 'flex-end', border: '1px solid #ececee', fontSize: '11px' }}>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontWeight: 500 }}>25</div>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', opacity: 0.7, fontSize: '10px', marginTop: '2px' }}>#F5F5F7</div>
  </div>

  <div style={{ aspectRatio: '1 / 1.4', background: '#CCCCCC', color: '#000', padding: '10px 8px', display: 'flex', flexDirection: 'column', justifyContent: 'flex-end', fontSize: '11px' }}>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontWeight: 500 }}>50</div>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', opacity: 0.7, fontSize: '10px', marginTop: '2px' }}>#CCCCCC</div>
  </div>

  <div style={{ aspectRatio: '1 / 1.4', background: '#999999', color: '#fff', padding: '10px 8px', display: 'flex', flexDirection: 'column', justifyContent: 'flex-end', fontSize: '11px' }}>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontWeight: 500 }}>100</div>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', opacity: 0.85, fontSize: '10px', marginTop: '2px' }}>#999999</div>
  </div>

  <div style={{ aspectRatio: '1 / 1.4', background: '#666666', color: '#fff', padding: '10px 8px', display: 'flex', flexDirection: 'column', justifyContent: 'flex-end', fontSize: '11px' }}>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontWeight: 500 }}>200</div>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', opacity: 0.85, fontSize: '10px', marginTop: '2px' }}>#666666</div>
  </div>

  <div style={{ aspectRatio: '1 / 1.4', background: '#333333', color: '#fff', padding: '10px 8px', display: 'flex', flexDirection: 'column', justifyContent: 'flex-end', fontSize: '11px' }}>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontWeight: 500 }}>400</div>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', opacity: 0.85, fontSize: '10px', marginTop: '2px' }}>#333333</div>
  </div>

  <div style={{ aspectRatio: '1 / 1.4', background: '#131313', color: '#fff', padding: '10px 8px', display: 'flex', flexDirection: 'column', justifyContent: 'flex-end', fontSize: '11px' }}>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontWeight: 500 }}>600</div>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', opacity: 0.85, fontSize: '10px', marginTop: '2px' }}>#131313</div>
  </div>

  <div style={{ aspectRatio: '1 / 1.4', background: '#000000', color: '#fff', padding: '10px 8px', display: 'flex', flexDirection: 'column', justifyContent: 'flex-end', fontSize: '11px' }}>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontWeight: 500 }}>Black</div>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', opacity: 0.85, fontSize: '10px', marginTop: '2px' }}>#000000</div>
  </div>
</div>

<div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '11px', letterSpacing: '0.08em', textTransform: 'uppercase', color: 'var(--sei-gold-100, #966f22)', marginTop: '3rem', marginBottom: '0.5rem' }}>
  03 — Typography
</div>

## Primary Typeface

**Lateral** is our primary typeface. Use it for headlines, product UI, and anything that needs presence. Give it room when setting editorially.

<div className="not-prose" style={{ marginTop: '1.25rem', padding: '32px', border: '1px solid #ececee', background: '#ffffff' }}>
  <div style={{ display: 'flex', flexDirection: 'column', gap: '24px' }}>
    <div style={{ fontFamily: 'var(--sei-font-display, "Lateral Condensed")', fontWeight: 700, fontSize: 'clamp(48px, 9vw, 120px)', lineHeight: 1, letterSpacing: '-0.02em', color: '#111' }}>
      Lateral
    </div>

    <div style={{ fontFamily: 'var(--sei-font-body, "Lateral Variable")', color: '#111', display: 'flex', flexDirection: 'column', gap: '4px', fontSize: '14px' }}>
      <div style={{ fontFamily: 'var(--sei-font-body, "Lateral Variable")', fontWeight: 400 }}>ABCDEFGHIJKLMNOPQRSTUVWXYZ</div>
      <div style={{ fontFamily: 'var(--sei-font-body, "Lateral Variable")', fontWeight: 400 }}>abcdefghijklmnopqrstuvwxyz</div>
      <div style={{ fontFamily: 'var(--sei-font-body, "Lateral Variable")', fontWeight: 400 }}>0123456789 .,:;!?&@\*</div>
    </div>

    <div style={{ display: 'flex', flexWrap: 'wrap', gap: '24px', paddingTop: '16px', borderTop: '1px solid #ececee', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '11px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#666' }}>
      <span><strong style={{ color: '#111', fontWeight: 500 }}>Condensed Bold</strong> · Display</span>
      <span><strong style={{ color: '#111', fontWeight: 500 }}>Regular</strong> · Body</span>
      <span><strong style={{ color: '#111', fontWeight: 500 }}>Light</strong> · Subtext</span>
    </div>

    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.08em', textTransform: 'uppercase', color: '#966f22' }}>
      Primary font · Headlines · Body · Copy
    </div>
  </div>
</div>

## Secondary Typefaces

<div className="not-prose" style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(300px, 1fr))', gap: '12px', marginTop: '1.25rem' }}>
  <div style={{ padding: '24px', border: '1px solid #ececee', background: '#ffffff', display: 'flex', flexDirection: 'column', gap: '20px' }}>
    <div style={{ fontFamily: 'var(--sei-font-serif, "Items Text")', fontWeight: 400, fontSize: 'clamp(40px, 6vw, 64px)', lineHeight: 1, letterSpacing: '-0.01em', color: '#111' }}>
      Items Text
    </div>

    <div style={{ fontFamily: 'var(--sei-font-serif, "Items Text")', color: '#111', display: 'flex', flexDirection: 'column', gap: '2px', fontSize: '13px' }}>
      <div>ABCDEFGHIJKLMNOPQRSTUVWXYZ</div>
      <div>abcdefghijklmnopqrstuvwxyz</div>
      <div>0123456789 .,:;!?&@\*</div>
    </div>

    <div style={{ paddingTop: '12px', borderTop: '1px solid #ececee', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#666' }}>
      <strong style={{ color: '#111', fontWeight: 500 }}>Book</strong>
    </div>

    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.08em', textTransform: 'uppercase', color: '#966f22' }}>
      Secondary font · Editorial · Quotes · Foundation
    </div>
  </div>

  <div style={{ padding: '24px', border: '1px solid #ececee', background: '#ffffff', display: 'flex', flexDirection: 'column', gap: '20px' }}>
    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontWeight: 400, fontSize: 'clamp(36px, 5.5vw, 56px)', lineHeight: 1, letterSpacing: '-0.01em', color: '#111' }}>
      ABC Repro Mono
    </div>

    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', color: '#111', display: 'flex', flexDirection: 'column', gap: '2px', fontSize: '12px' }}>
      <div>ABCDEFGHIJKLMNOPQRSTUVWXYZ</div>
      <div>abcdefghijklmnopqrstuvwxyz</div>
      <div>0123456789 .,:;!?&@\*</div>
    </div>

    <div style={{ paddingTop: '12px', borderTop: '1px solid #ececee', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#666' }}>
      <strong style={{ color: '#111', fontWeight: 500 }}>Regular</strong>
    </div>

    <div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '10px', letterSpacing: '0.08em', textTransform: 'uppercase', color: '#966f22' }}>
      Tertiary font · Data · Tickers · Captions
    </div>
  </div>
</div>

***

<div style={{ fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '11px', letterSpacing: '0.08em', textTransform: 'uppercase', color: 'var(--sei-gold-100, #966f22)', marginTop: '3rem', marginBottom: '0.5rem' }}>
  04 — Usage
</div>

## Clearspace

To maintain the logo's clarity and prominence, follow the clearspace guidelines. A certain amount of space is required around the lockup to prevent surrounding artwork, imagery, or the edge of a page from crowding it.

<div className="not-prose" style={{ border: '1px solid #ececee', marginTop: '1.25rem', background: '#ffffff' }}>
  <div style={{ display: 'flex', aspectRatio: '16 / 6', width: '100%', alignItems: 'center', justifyContent: 'center', background: '#ffffff', padding: '32px', borderBottom: '1px solid #ececee' }}>
    <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/clearspace.png?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=10217762ad382a592c4d1608bf8555b4" alt="Sei lockup with X-unit clearspace markers" style={{ width: '100%', maxWidth: '460px', height: 'auto', display: 'block', filter: 'none', pointerEvents: 'none' }} width="1277" height="695" data-path="assets/brand/clearspace.png" />
  </div>

  <ul style={{ padding: '24px 28px', display: 'flex', flexDirection: 'column', gap: '10px', listStyle: 'none', margin: 0, fontSize: '14px', lineHeight: 1.55, color: '#111' }}>
    <li><strong>Use only approved colors.</strong> <span style={{ color: '#666' }}>Black, white, Maroon 100, or Gold 100 — nothing else.</span></li>
    <li><strong>Keep proportions locked.</strong> <span style={{ color: '#666' }}>Symbol and wordmark ship as one unit. Don't rescale their relationship.</span></li>
    <li><strong>Respect clearspace and minimum size.</strong> <span style={{ color: '#666' }}>X on all sides, 25 px tall minimum.</span></li>
  </ul>
</div>

## Cobranding

Our lockup for brand partnerships is dictated by the clearspace rule, which should also be applied to the partner brand. Ensure both lockups are the same height.

<div className="not-prose" style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(280px, 1fr))', gap: '12px', marginTop: '1.25rem' }}>
  <div style={{ position: 'relative', display: 'flex', flexDirection: 'column', aspectRatio: '5 / 4', width: '100%', background: '#ffffff', border: '1px solid #ececee' }}>
    <div style={{ display: 'flex', flex: 1, alignItems: 'center', justifyContent: 'center', padding: '24px 24px 64px' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/cobranding-horizontal-lockup.png?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=0a79fbc917f7b77a01686dff5ff22320" alt="Sei + partner horizontal co-branding lockup with clearspace" style={{ width: '100%', maxWidth: '350px', height: 'auto', display: 'block', filter: 'none', pointerEvents: 'none' }} width="1331" height="353" data-path="assets/brand/cobranding-horizontal-lockup.png" />
    </div>

    <span style={{ position: 'absolute', bottom: '20px', left: '24px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '11px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#666' }}>Horizontal Lockup</span>
  </div>

  <div style={{ position: 'relative', display: 'flex', flexDirection: 'column', aspectRatio: '5 / 4', width: '100%', background: '#ffffff', border: '1px solid #ececee' }}>
    <div style={{ display: 'flex', flex: 1, alignItems: 'center', justifyContent: 'center', padding: '24px 24px 64px' }}>
      <img src="https://mintcdn.com/seilabs/MHnOpYb4aHDlXyvi/assets/brand/cobranding-vertical-lockup.png?fit=max&auto=format&n=MHnOpYb4aHDlXyvi&q=85&s=7caa54c99728085f70ace68ffbdc3aa8" alt="Sei + partner vertical co-branding lockup with clearspace" style={{ width: '100%', maxWidth: '200px', height: 'auto', display: 'block', filter: 'none', pointerEvents: 'none' }} width="491" height="560" data-path="assets/brand/cobranding-vertical-lockup.png" />
    </div>

    <span style={{ position: 'absolute', bottom: '20px', left: '24px', fontFamily: 'var(--sei-font-mono, "ABC Repro Mono")', fontSize: '11px', letterSpacing: '0.06em', textTransform: 'uppercase', color: '#666' }}>Vertical Lockup</span>
  </div>
</div>

***

<Note>
  Need something not listed here? See the full interactive brand site at [brand.sei.io](https://brand.sei.io) or download the [complete brand kit zip](https://brand.sei.io/sei-brand-assets.zip).
</Note>

---

URL: https://docs.sei.io/evm

# Sei EVM - High Performance Ethereum Virtual Machine

> Build on the fastest EVM with 400ms finality, 100 MGas/s throughput, and full Ethereum tooling compatibility.

## Why Choose Sei EVM?

| Feature                   | Sei EVM            | Ethereum   | Other Layer 1s |
| ------------------------- | ------------------ | ---------- | -------------- |
| Blocktime                 | 400 ms             | \~12 s     | 1 - 3 seconds  |
| Transaction Throughput    | 100 MGas/s         | \~5 MGas/s | \< 50 MGas/s   |
| Parallelized Execution    | Yes                | No         | Limited/No     |
| EVM Tooling Compatibility | 100%               | 100%       | Varies         |
| EVM Version               | Pectra (w/o blobs) | Fusaka     | Varies         |

<Card horizontal title="Detailed Ethereum comparison" icon="arrow-right" href="/evm/differences-with-ethereum">
  View detailed Ethereum comparison
</Card>

## Quick Start

<Steps>
  <Step title="Add Sei to Wallet">
    * [Install Sei Global Wallet](/evm/sei-global-wallet)
    * [Sei EVM Network Information](/evm/networks)
  </Step>

  <Step title="Get Test Tokens">
    * [Visit Sei Faucet](/learn/faucet)
    * [View Token Information](/evm/tokens)
  </Step>

  <Step title="Start Building">
    * [EVM General Guide](/evm/evm-general)
    * [Project Templates](https://github.com/sei-protocol/sei-chain/tree/main/example)
  </Step>
</Steps>

## Ready-to-Deploy Examples

<CardGroup cols={3}>
  <Card horizontal title="EVM Contract Wizard" icon="wand-magic-sparkles" href="/evm/evm-wizard">
    Generate ERC-20, ERC-721, and more contracts in minutes. Configure, copy, deploy.
  </Card>

  <Card horizontal title="Frontend Integration" icon="window" href="/evm/building-a-frontend">
    Connect ethers.js, viem, or wagmi to your Sei EVM smart contracts.
  </Card>

  <Card horizontal title="Solidity Resources" icon="screwdriver-wrench" href="/evm/solidity-resources">
    Tools and best practices for Solidity development on Sei.
  </Card>
</CardGroup>

## Development Tools

<CardGroup cols={3}>
  <Card horizontal title="Deploy with Hardhat" icon="terminal" href="/evm/evm-hardhat">
    Deploy smart contracts on Sei EVM using Hardhat. Simple setup, fast results.
  </Card>

  <Card horizontal title="Deploy with Foundry" icon="cube" href="/evm/evm-foundry">
    Use Foundry to build and deploy on Sei EVM. Fast testing, simple deployment.
  </Card>

  <Card horizontal title="JSON-RPC Explorer" icon="compass" href="/evm/reference">
    Browse every Sei EVM JSON-RPC method, run live requests, and copy ready-to-use code.
  </Card>
</CardGroup>

## Use Cases

<CardGroup cols={2}>
  <Card horizontal title="x402 Payments" icon="credit-card" href="/ai/x402">
    Implement HTTP 402 Payment Required for API monetization and premium content.
  </Card>

  <Card horizontal title="USDC on Sei" icon="dollar-sign" href="/evm/usdc-on-sei">
    Native USDC integration guide for seamless stablecoin transactions.
  </Card>
</CardGroup>

## RPC Endpoints

Choose from official Sei Foundation endpoints or community-maintained alternatives. All endpoints support standard EVM JSON-RPC methods. Public endpoints have rate limits — for production apps, use a [dedicated RPC provider](/learn/rpc-providers) or [run your own node](/node).

<Tabs>
  <Tab title="Mainnet (pacific-1)">
    | Endpoint                                   | Provider       | Type                                                                                                                                                                                | Rate limit | Notes                       |
    | ------------------------------------------ | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | --------------------------- |
    | `https://evm-rpc.sei-apis.com`             | Sei Foundation | <span style={{ backgroundColor: 'rgba(34,197,94,0.15)', color: '#16a34a', padding: '0.125rem 0.5rem', borderRadius: '9999px', fontSize: '0.75rem', fontWeight: 600 }}>public</span> | 10 req/s   | Recommended for development |
    | `https://evm-rpc-sei.stingray.plus`        | Staketab       | <span style={{ backgroundColor: 'rgba(34,197,94,0.15)', color: '#16a34a', padding: '0.125rem 0.5rem', borderRadius: '9999px', fontSize: '0.75rem', fontWeight: 600 }}>public</span> | —          | Community maintained        |
    | `https://sei-evm-rpc.publicnode.com`       | PublicNode     | <span style={{ backgroundColor: 'rgba(34,197,94,0.15)', color: '#16a34a', padding: '0.125rem 0.5rem', borderRadius: '9999px', fontSize: '0.75rem', fontWeight: 600 }}>public</span> | 5 req/s    | Community maintained        |
    | `https://seievm-rpc.polkachu.com`          | Polkachu       | <span style={{ backgroundColor: 'rgba(34,197,94,0.15)', color: '#16a34a', padding: '0.125rem 0.5rem', borderRadius: '9999px', fontSize: '0.75rem', fontWeight: 600 }}>public</span> | —          | Community maintained        |
    | `https://jsonrpc.lavenderfive.com:443/sei` | LavenderFive   | <span style={{ backgroundColor: 'rgba(34,197,94,0.15)', color: '#16a34a', padding: '0.125rem 0.5rem', borderRadius: '9999px', fontSize: '0.75rem', fontWeight: 600 }}>public</span> | —          | Community maintained        |
  </Tab>

  <Tab title="Testnet (atlantic-2)">
    | Endpoint                                    | Provider       | Type                                                                                                                                                                                | Rate limit | Notes                   |
    | ------------------------------------------- | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | ----------------------- |
    | `https://evm-rpc-testnet.sei-apis.com`      | Sei Foundation | <span style={{ backgroundColor: 'rgba(34,197,94,0.15)', color: '#16a34a', padding: '0.125rem 0.5rem', borderRadius: '9999px', fontSize: '0.75rem', fontWeight: 600 }}>public</span> | 20 req/s   | Recommended for testing |
    | `https://evm-rpc-testnet-sei.stingray.plus` | Staketab       | <span style={{ backgroundColor: 'rgba(34,197,94,0.15)', color: '#16a34a', padding: '0.125rem 0.5rem', borderRadius: '9999px', fontSize: '0.75rem', fontWeight: 600 }}>public</span> | —          | Community maintained    |
    | `https://seievm-testnet-rpc.polkachu.com`   | Polkachu       | <span style={{ backgroundColor: 'rgba(34,197,94,0.15)', color: '#16a34a', padding: '0.125rem 0.5rem', borderRadius: '9999px', fontSize: '0.75rem', fontWeight: 600 }}>public</span> | —          | Community maintained    |
    | `https://sei-testnet.drpc.org`              | dRPC           | <span style={{ backgroundColor: 'rgba(34,197,94,0.15)', color: '#16a34a', padding: '0.125rem 0.5rem', borderRadius: '9999px', fontSize: '0.75rem', fontWeight: 600 }}>public</span> | —          | Community maintained    |
  </Tab>
</Tabs>

<Card horizontal title="Interactive JSON-RPC Explorer" icon="code" href="/evm/reference">
  Search every Sei EVM JSON-RPC method with Sei-specific behavior notes, switch between mainnet, testnet, and custom endpoints, run live requests, and generate ready-to-use client code.
</Card>

---

URL: https://docs.sei.io/evm/networks

# Sei EVM Networks

> Discover network information for Sei EVM across all environments including mainnet and testnet. Access RPC endpoints, chain IDs, and blockchain explorers.

export const NetworkTabs = props => {
  const {network = 'mainnet'} = props || ({});
  const ChevronRightIcon = ({className}) => <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
			<path d="M9 6l6 6l-6 6" />
		</svg>;
  const CheckIcon = ({className}) => <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
			<path d="M5 12l5 5l10 -10" />
		</svg>;
  const CopyIcon = ({className}) => <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
			<path d="M7 7m0 2.667a2.667 2.667 0 0 1 2.667 -2.667h8.666a2.667 2.667 0 0 1 2.667 2.667v8.666a2.667 2.667 0 0 1 -2.667 2.667h-8.666a2.667 2.667 0 0 1 -2.667 -2.667z" />
			<path d="M4.012 16.737a2.005 2.005 0 0 1 -1.012 -1.737v-10c0 -1.1 .9 -2 2 -2h10c.75 0 1.158 .385 1.5 1" />
		</svg>;
  const CopyButton = ({textToCopy}) => {
    const [copied, setCopied] = useState(false);
    const handleCopy = () => {
      navigator.clipboard.writeText(textToCopy);
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    return <button type="button" onClick={handleCopy} className="p-1  text-neutral-500 hover:text-neutral-700 dark:text-neutral-400 dark:hover:text-neutral-200 hover:bg-neutral-200/50 dark:hover:bg-neutral-700/50 transition-colors" title="Copy to clipboard" aria-label="Copy to clipboard">
				{copied ? <CheckIcon className="h-4 w-4 text-green-500" /> : <CopyIcon className="h-4 w-4" />}
			</button>;
  };
  const validTabs = ['mainnet', 'testnet', 'localnet'];
  const initialTab = validTabs.includes(network) ? network : 'mainnet';
  const [activeTab, setActiveTab] = useState(() => {
    if (typeof window !== 'undefined') {
      const hash = window.location.hash.substring(1);
      if (validTabs.includes(hash)) return hash;
    }
    return initialTab;
  });
  useEffect(() => {
    const handleHashChange = () => {
      const h = window.location.hash.substring(1);
      if (validTabs.includes(h)) {
        setActiveTab(h);
      }
    };
    handleHashChange();
    window.addEventListener('hashchange', handleHashChange);
    return () => window.removeEventListener('hashchange', handleHashChange);
  }, []);
  const selectTab = tab => {
    setActiveTab(tab);
    if (typeof window !== 'undefined' && window.history && window.history.replaceState) {
      window.history.replaceState(null, '', `#${tab}`);
    }
  };
  const tabButtonClass = tab => `px-3 py-1.5 text-sm transition-colors ${activeTab === tab ? 'bg-neutral-200 dark:bg-neutral-800/80 text-neutral-900 dark:text-white border border-neutral-300 dark:border-neutral-700' : 'bg-neutral-100 dark:bg-neutral-800/50 text-neutral-600 dark:text-neutral-400 border border-neutral-200 dark:border-neutral-700/50 hover:bg-neutral-200 dark:hover:bg-neutral-700/70 hover:text-neutral-900 dark:hover:text-white'}`;
  const sectionTitleClass = 'font-medium text-neutral-900 dark:text-white';
  const statusIndicatorClass = 'w-2 h-2 rounded-full';
  const labelClass = 'text-neutral-500 dark:text-neutral-500 mb-1';
  const valueClass = 'text-neutral-700 dark:text-neutral-300';
  const linkClass = 'text-neutral-700 hover:text-neutral-900 dark:text-neutral-300 dark:hover:text-white transition-colors';
  const visitLinkClass = 'text-neutral-700 hover:text-neutral-900 dark:text-neutral-300 dark:hover:text-white flex items-center transition-colors';
  const renderTabContent = (tab, isVisible = true) => {
    const contentClass = isVisible ? 'tab-content' : 'sr-only';
    const ariaHidden = !isVisible;
    switch (tab) {
      case 'mainnet':
        return <div key={tab} className={contentClass} aria-hidden={ariaHidden} data-search-content data-tab-value="mainnet">
						<div className="w-full">
							<div>
								<div className="flex items-center gap-2 mb-4">
									<div className={`${statusIndicatorClass} bg-green-500`}></div>
									<h3 className={sectionTitleClass}>EVM</h3>
								</div>

								<div className="space-y-3">
									<div className="flex flex-col">
										<div className={labelClass}>Chain ID:</div>
										<div className="flex items-center justify-between">
											<span className={valueClass}>1329 (0x531)</span>
											<CopyButton textToCopy="1329" />
										</div>
									</div>

									<div className="flex flex-col">
										<div className={labelClass}>RPC URL:</div>
										<div className="flex items-center justify-between">
											<a href="https://evm-rpc.sei-apis.com" target="_blank" rel="noopener noreferrer" className={linkClass}>
												https://evm-rpc.sei-apis.com
											</a>
											<CopyButton textToCopy="https://evm-rpc.sei-apis.com" />
										</div>
									</div>

									<div className="flex flex-col">
										<div className={labelClass}>Explorer:</div>
										<div className="flex items-center justify-between">
											<span className={valueClass}>seiscan.io</span>
											<a href="https://seiscan.io" target="_blank" rel="noopener noreferrer" className={visitLinkClass}>
												Visit
												<ChevronRightIcon className="w-4 h-4 ml-1" />
											</a>
										</div>
									</div>
								</div>
							</div>
						</div>
					</div>;
      case 'testnet':
        return <div key={tab} className={contentClass} aria-hidden={ariaHidden} data-search-content data-tab-value="testnet">
						<div className="grid grid-cols-1 gap-6 w-full">
							<div>
								<div className="flex items-center gap-2 mb-4">
									<div className={`${statusIndicatorClass} bg-blue-500`}></div>
									<h3 className={sectionTitleClass}>EVM</h3>
								</div>

								<div className="space-y-3">
									<div className="flex flex-col">
										<div className={labelClass}>Chain ID:</div>
										<div className="flex items-center justify-between">
											<span className={valueClass}>1328 (0x530)</span>
											<CopyButton textToCopy="1328" />
										</div>
									</div>

									<div className="flex flex-col">
										<div className={labelClass}>RPC URL:</div>
										<div className="flex items-center justify-between">
											<a href="https://evm-rpc-testnet.sei-apis.com" target="_blank" rel="noopener noreferrer" className={linkClass}>
												https://evm-rpc-testnet.sei-apis.com
											</a>
											<CopyButton textToCopy="https://evm-rpc-testnet.sei-apis.com" />
										</div>
									</div>

									<div className="flex flex-col">
										<div className={labelClass}>Explorer:</div>
										<div className="flex items-center justify-between">
											<span className={valueClass}>testnet.seiscan.io</span>
											<a href="https://testnet.seiscan.io" target="_blank" rel="noopener noreferrer" className={visitLinkClass}>
												Visit
												<ChevronRightIcon className="w-4 h-4 ml-1" />
											</a>
										</div>
									</div>
									<div className="flex flex-col">
										<div className={labelClass}>Faucet:</div>
										<div className="flex items-center justify-between">
											<span className={valueClass}>Testnet faucet</span>
											<a href="https://docs.sei.io/learn/faucet" target="_blank" rel="noopener noreferrer" className={visitLinkClass}>
												Visit
												<ChevronRightIcon className="w-4 h-4 ml-1" />
											</a>
										</div>
									</div>
								</div>
							</div>
						</div>
					</div>;
      case 'localnet':
        return <div key={tab} className={contentClass} aria-hidden={ariaHidden} data-search-content data-tab-value="localnet">
						<div className="grid grid-cols-1 gap-6 w-full">
							<div>
								<div className="flex items-center gap-2 mb-4">
									<div className={`${statusIndicatorClass} bg-purple-500`}></div>
									<h3 className={sectionTitleClass}>EVM</h3>
								</div>

								<div className="space-y-3">
									<div className="flex flex-col">
										<div className={labelClass}>Chain ID:</div>
										<div className="flex items-center justify-between">
											<span className={valueClass}>713714 (0xAE3F2)</span>
											<CopyButton textToCopy="713714" />
										</div>
									</div>

									<div className="flex flex-col">
										<div className={labelClass}>RPC URL:</div>
										<div className="flex items-center justify-between">
											<span className={valueClass}>http://localhost:8545</span>
											<CopyButton textToCopy="http://localhost:8545" />
										</div>
									</div>

									<div className="flex flex-col">
										<div className={labelClass}>Explorer:</div>
										<div className="flex items-center justify-between">
											<span className={valueClass}>N/A</span>
										</div>
									</div>
								</div>
							</div>
						</div>
					</div>;
      default:
        return null;
    }
  };
  return <div className="network-tabs w-full">
			<div className="flex flex-wrap gap-2 mb-6">
				<button type="button" onClick={() => selectTab('mainnet')} className={tabButtonClass('mainnet')}>
					Mainnet (pacific-1)
				</button>
				<button type="button" onClick={() => selectTab('testnet')} className={tabButtonClass('testnet')}>
					Testnet (atlantic-2)
				</button>
				<button type="button" onClick={() => selectTab('localnet')} className={tabButtonClass('localnet')}>
					Local Environment
				</button>
			</div>

			{renderTabContent(activeTab, true)}

			{['mainnet', 'testnet', 'localnet'].map(tab => tab !== activeTab ? renderTabContent(tab, false) : null)}
		</div>;
};

<NetworkTabs />

The panel above is interactive. For plain-text endpoints you can copy directly — plus additional provider options — see:

* [Chains & endpoints](/learn/dev-chains) — RPC URLs and chain IDs in plain text
* [RPC providers](/learn/rpc-providers) — additional public and commercial RPC endpoints

---

URL: https://docs.sei.io/evm/differences-with-ethereum

# Sei EVM vs Ethereum: Key Differences

> A comparison of Sei EVM and Ethereum, highlighting Sei's advantages in blocktime, throughput, finality, and execution environment, as well as technical differences in opcodes, state storage, and other features.

export const SstoreGasLive = ({network = 'mainnet'}) => {
  const COLD = '0x50025cb2';
  const PARAM = '0x095f88b9';
  const RPC = {
    mainnet: {
      url: 'https://evm-rpc.sei-apis.com',
      chain: 'pacific-1',
      id: 1329,
      probe: '0xeeB428bcf499D0A1c401f123F64BFf754a5de57A',
      explorer: 'https://seiscan.io/address/0xeeB428bcf499D0A1c401f123F64BFf754a5de57A'
    },
    testnet: {
      url: 'https://evm-rpc-testnet.sei-apis.com',
      chain: 'atlantic-2',
      id: 1328,
      probe: '0xE5A35b2457E1C3cfF2F6527fAA32DE0B2a8e28E0',
      explorer: 'https://testnet.seiscan.io/address/0xE5A35b2457E1C3cfF2F6527fAA32DE0B2a8e28E0'
    }
  };
  const [net, setNet] = useState(network === 'testnet' ? 'testnet' : 'mainnet');
  const [data, setData] = useState(null);
  const [err, setErr] = useState(null);
  const [loading, setLoading] = useState(true);
  const ethCall = async (url, to, data) => {
    const res = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: 1,
        method: 'eth_call',
        params: [{
          to,
          data
        }, 'latest']
      })
    });
    const json = await res.json();
    if (json.error) throw new Error(json.error.message || 'eth_call failed');
    return parseInt(json.result, 16);
  };
  const load = async which => {
    setLoading(true);
    setErr(null);
    try {
      const {url, probe} = RPC[which];
      const [param, cold] = await Promise.all([ethCall(url, probe, PARAM), ethCall(url, probe, COLD)]);
      setData({
        param,
        cold
      });
    } catch (e) {
      setErr(e && e.message ? e.message : 'Failed to query RPC');
      setData(null);
    } finally {
      setLoading(false);
    }
  };
  useEffect(() => {
    load(net);
  }, [net]);
  const fmt = n => n == null ? '—' : n.toLocaleString('en-US');
  const TabButton = ({value, children}) => {
    const active = net === value;
    return <button type="button" onClick={() => setNet(value)} className="px-3 py-1 transition-colors" style={{
      fontFamily: 'var(--sei-font-mono)',
      fontSize: '11px',
      textTransform: 'uppercase',
      letterSpacing: '0.04em',
      color: active ? '#ffffff' : 'var(--sei-maroon-100)',
      backgroundColor: active ? 'var(--sei-maroon-100)' : 'transparent',
      border: '1px solid var(--sei-maroon-100)',
      cursor: active ? 'default' : 'pointer'
    }}>
        {children}
      </button>;
  };
  const Stat = ({label, value, sub}) => <div className="flex flex-col gap-0.5">
      <span className="text-[11px] uppercase tracking-wide text-neutral-500 dark:text-neutral-400" style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>
        {label}
      </span>
      <span className="text-2xl font-semibold text-neutral-900 dark:text-neutral-50 tabular-nums" style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>
        {loading ? '…' : value}
        <span className="text-sm font-normal text-neutral-500 dark:text-neutral-400"> gas</span>
      </span>
      {sub && <span className="text-[11px] text-neutral-500 dark:text-neutral-400">{sub}</span>}
    </div>;
  return <div className="not-prose w-full rounded-lg border border-neutral-200 dark:border-neutral-700 p-4" style={{
    backgroundColor: 'rgba(127,127,127,0.04)'
  }}>
      <div className="flex items-center justify-between gap-3 mb-3">
        <span className="text-[12px] font-semibold text-neutral-700 dark:text-neutral-200" style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>
          Live SSTORE gas — measured on-chain
        </span>
        <div className="inline-flex">
          <TabButton value="mainnet">Mainnet</TabButton>
          <TabButton value="testnet">Testnet</TabButton>
        </div>
      </div>

      {err ? <div className="text-[12px] text-red-600 dark:text-red-400" style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>
          Could not reach {RPC[net].chain} RPC: {err}{' '}
          <button type="button" onClick={() => load(net)} className="underline">
            retry
          </button>
        </div> : <div className="flex flex-wrap gap-x-10 gap-y-3">
          <Stat label="SSTORE_SET parameter" value={fmt((data && data.param) - 8)} sub="governance value (≈ 72,000)" />
          <Stat label="Cold first write" value={fmt((data && data.cold) - 7)} sub="SSTORE_SET + EIP-2929 cold access (2,100)" />
        </div>}

      <div className="mt-3 text-[11px] text-neutral-500 dark:text-neutral-400">
        {RPC[net].chain} ({RPC[net].id}) · read via <code>eth_call</code> from the verified{' '}
        <a href={RPC[net].explorer} target="_blank" rel="noopener noreferrer" className="underline">
          SstoreGasProbe
        </a>{' '}
        contract. Governance-adjustable — set by{' '}
        <a href="https://www.mintscan.io/sei/proposals/109" target="_blank" rel="noopener noreferrer" className="underline">
          Proposal #109
        </a>
        .
      </div>
    </div>;
};

While Sei features full EVM compatibility, there are some distinctions between
Sei's EVM and Ethereum itself:

| Feature                   | Sei EVM                                                                           | Ethereum                                                       |
| ------------------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------- |
| Blocktime                 | 400 ms                                                                            | 12 s                                                           |
| Gas per Second            | \~ 100 MegaGas/s                                                                  | \~ 5 MegaGas/s                                                 |
| Finality                  | Instant (\~400 ms)                                                                | Various commitment levels (safe, latest, justified, finalized) |
| Parallelized Execution    | Yes                                                                               | No                                                             |
| EVM Tooling Compatibility | 100%                                                                              | 100%                                                           |
| EVM Version               | Pectra (w/o blobs)                                                                | Fusaka                                                         |
| Gas Limit                 | 12.5 M (block cap)                                                                | 60 M (block); \~16.7 M per-tx (EIP-7825)                       |
| Per-Tx Gas Cap            | 12.5 M (block limit)                                                              | \~16.7 M (EIP-7825)                                            |
| Byte Size Limit           | 21 MB                                                                             | No byte-denominated limits                                     |
| Execution Environment     | EVM and Cosmos-SDK                                                                | EVM                                                            |
| Address Space             | Dual ECDSA-derived addresses; Cosmos Bech32 (sei…) + EVM-compatible address (0x…) | ECDSA-derived address (0x…)                                    |
| State Storage             | AVL-tree (global root)                                                            | Merkle Patricia Trie (MPT)                                     |
| SSTORE Gas Cost           | 72k (on-chain param, governance-adjustable)                                       | 20k (fixed)                                                    |

* Sei uses the Pectra (Prague + Electra) version of EVM, excluding blob transactions. Ethereum has since upgraded to Fusaka (December 2025), which introduced PeerDAS for enhanced data availability.
* Sei's gas limit is 12.5 M as opposed to Ethereum's 60 M (increased from 45 M in the Fusaka upgrade via EIP-7935). Sei also has a byte size limit of 21MB.
* Sei has instant finality — a transaction is final as soon as its block is committed (\~400 ms). This means the various commitment levels typical for Ethereum (i.e., safe, latest, justified) do not apply on Sei.

<Danger>
  **Deprecation Notice**

  Cosmos SDK and CosmWasm functionality is being deprecated in favor of EVM-only. For more details, see [SIP-3](https://github.com/sei-protocol/sips/blob/main/sips/sip-3.md) and [Proposal 99](https://www.mintscan.io/sei/proposals/99).

  [Proposal 115](https://www.mintscan.io/sei/proposals/115) further disables CosmWasm code uploads and contract instantiations chain-wide — no new CosmWasm contracts can be deployed. Only `execute` and `query` against pre-existing CosmWasm contracts remain available.

  [Proposal 116](https://www.mintscan.io/sei/proposals/116) additionally disables inbound IBC transfers — IBC assets bridged from Cosmos chains can no longer arrive on Sei after this passes and is activated. See the [SIP-03 Migration Guide](/learn/sip-03-migration) for affected assets and migration routes.
</Danger>

* **Sei is a dual-execution environment (EVM and Cosmos-SDK).** This means:
  * Non-EVM transactions can update EVM-accessible state.
    * For example, an account's SEI balance can be affected by both Cosmos (bank send, wasm execute) transactions as well as EVM send transactions
  * Sei assets can exist as EVM tokens (ERC20/721/1155), as legacy CosmWasm tokens (CW20/CW721/CW1155, no longer deployable per Prop 115), or as "native" Bank Module assets (Sei).
  * User accounts on Sei have [two addresses](/learn/accounts) derived from the same public key (Cosmos Bech32 and EVM-compatible 0x…)
  * Interoperability between EVM and Cosmos-SDK modules is governed and navigated via [precompiles](/evm/precompiles/example-usage) and [pointer contracts](/learn/pointers)

## Sei EVM Release

Sei EVM was originally deployed at the following block heights and versions:

### Testnet

* **Name:** `v5.5.1`
* **Height:** `90526031`
* **Changelog:** [https://github.com/sei-protocol/sei-chain/blob/main/CHANGELOG.md#v5.5.1](https://github.com/sei-protocol/sei-chain/blob/main/CHANGELOG.md#v5.5.1)

### Mainnet

* **Name:** `v5.5.2`
* **Height:** `79123881`
* **Changelog:** [https://github.com/sei-protocol/sei-chain/blob/main/CHANGELOG.md#v552](https://github.com/sei-protocol/sei-chain/blob/main/CHANGELOG.md#v552)

## Opcode Differences

| Opcode               | Sei EVM                                             | Ethereum                                                 | Notes                                                                                                                      |
| -------------------- | --------------------------------------------------- | -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| PREVRANDAO           | Returns a value derived from the current block time | Returns the RANDAO mix (EIP‑4399)                        | Not a randomness source; use an oracle/VRF. `DIFFICULTY` aliases to this.                                                  |
| COINBASE             | Always the global fee collector address             | Block proposer (miner) address                           | Do not assume it is the validator address.                                                                                 |
| BASEFEE              | Returns current base fee; no burn                   | Returns current base fee; a portion is burned (EIP‑1559) | Legacy tx must meet Sei's governance-set minimum gas price (currently `50 gwei`); query `eth_gasPrice` for the live value. |
| BLOCKHASH            | Hash of the Tendermint header; different encoding   | Keccak of the Ethereum block header                      | Usable for recent blocks only; values are not interchangeable across chains.                                               |
| GASLIMIT             | = 12,500,000 per block                              | = 60,000,000 per block                                   | Represents block gas limit in both chains.                                                                                 |
| TIMESTAMP            | Tendermint block time                               | Proposer-chosen block time                               | Same semantics; do not use as randomness.                                                                                  |
| DIFFICULTY           | Alias of PREVRANDAO                                 | Alias of PREVRANDAO (EIP‑4399)                           | Returns the same value as PREVRANDAO.                                                                                      |
| Blob‑related opcodes | Not supported (Pectra without blobs)                | Supported post‑Cancun (EIP‑4844)                         | Blob transactions are not enabled on Sei.                                                                                  |

### PREVRANDAO

Since Sei doesn't rely on the same pseudo‑randomness way of determining the next
validator like Proof of Stake (PoS) Ethereum does, it doesn't have the
"randomness" artifact that can be set as `PREVRANDAO`'s return value. On Sei,
`PREVRANDAO` returns a value derived from the current block time. For strong
randomness needs in contract logic, use a verifiable randomness oracle (as is
advised on Ethereum itself).

### COINBASE

Coinbase address on Sei is always set to (the EVM address of) the global fee
collector.

## State Root

Since Sei uses AVL-tree instead of Merkle Patricia Trie (MPT) for data storage,
Sei doesn't have per-account state root. The global state root is the AVL-tree
root which is also not equivalent to Ethereum's overall state root (which is a
MPT root)

## Block Hash

The block hash on Sei is computed based on the block header in Tendermint data
format, and is different from Ethereum's block Hash as a result.

## Base Fee & Tips

Sei supports all non‑blob transaction types, including the Pectra `SetCode` transaction (EIP‑7702). However for a legacy (non EIP‑1559) type
transaction, you must specify a gas price at or above Sei's governance-set minimum gas price (currently `50 gwei` on mainnet). Query the live value with `eth_gasPrice` rather than hard-coding it. In addition to this, excess
"gas wanted/gas limit" beyond the actual "gas used" may not be refunded in full
or in part.

Current EIP1559 parameters can be fetched from the `seid` SDK tool:

```sh theme={"dark"}
seid q params subspace evm KeyTargetGasUsedPerBlock

key: KeyTargetGasUsedPerBlock
subspace: evm
value: '"850000"'
```

```sh theme={"dark"}
seid q params subspace evm KeyMaxDynamicBaseFeeUpwardAdjustment

key: KeyMaxDynamicBaseFeeUpwardAdjustment
subspace: evm
value: '"0.007500000000000000"'
```

## Non-EVM Transactions

On Sei there exists non-EVM transactions which may update states accessible by
EVM transactions. The simplest example would be bank balances, which may be
updated by both native Cosmos bank send transactions and EVM send transactions.
As a result, if certain offchain applications only parse EVM transactions, they
may find certain state changes unattributable to any EVM transaction.

## Finality

Sei has instant finality — a transaction is final as soon as its block is
committed (\~400 ms) — meaning that commitment levels of "safe", "latest",
"justified", and "finalized" on Ethereum are all the same thing on Sei.

## Pending State

On Ethereum the block proposer would execute its proposed block first (and
update its local state) before broadcasting the proposal to others (the updated
state would be marked "pending" until the node is accepted by other nodes).

However, on Sei, the block proposer would broadcast first and only execute the
proposal if it's accepted (i.e. every node would execute the block at roughly
the same time), so Sei does not have a window when "pending state"
exists.

## Gas Model & Fees

Sei does not implement base‑fee burning. There is no base‑fee burn; all transaction fees accrue to validators. Fees are calculated as:

Transaction Fee = Gas Used × Gas Price

**Practical implications**

* **Simpler fee handling:** Use `gasPrice` (you can omit `maxFeePerGas` / `maxPriorityFeePerGas`).
* **More stable fees:** Higher throughput reduces fee spikes during busy periods.
* **Typically lower cost:** Many workloads that are costly on Ethereum become economical on Sei.

<Info>
  **Useful Infos**

  * **Does Sei burn a base fee (EIP‑1559)?** No.
  * **Who receives fees?** Validators.
  * **Are Sei fees lower?** Yes, due to higher throughput and parallel execution.
</Info>

## SSTORE Gas Cost

On Sei, the `SSTORE` opcode gas cost is configurable as an on-chain parameter, meaning it can be adjusted via governance proposal without requiring a chain upgrade. This provides flexibility to tune storage costs based on EVM state size and network conditions.

Currently, the `SSTORE` gas cost is set to the non-standard value of **72,000 gas**. This value is the same on both mainnet (`pacific-1`) and testnet (`atlantic-2`). It was set by governance [Proposal #109](https://www.mintscan.io/sei/proposals/109) ("Update EVM SSTORE set gas to 72000"), which changed the `evm` module parameter `KeySeiSstoreSetGasEIP2200` to `72000`.

The values below are read **live** from the Sei EVM:

<SstoreGasLive network="mainnet" />

To confirm the real cost yourself, use a live `eth_estimateGas` call against a Sei RPC. Note that a Foundry `forge test --gas-report --fork-url <sei rpc>` report forks chain *state* but applies revm's standard EVM gas schedule, so it reports the Ethereum cost (\~22,100) rather than Sei's — it is useful for relative profiling of your own logic, not for the absolute storage-write cost.

<Info>Since `SSTORE` is a governance-controlled parameter, this value may change in the future through a governance proposal.</Info>

## ERC Token Standards Compatibility

Sei’s EVM fully supports the common token standards:

* **ERC‑20** (fungible tokens)
* **ERC‑721** (NFTs)
* **ERC‑1155** (multi‑token)

Existing OpenZeppelin contracts and tools work unchanged.

## Testing & Migration Checklist

* ✅ Re‑deploy your Solidity code to Sei testnet; most contracts need no changes.
* ✅ If you used SELFDESTRUCT, refactor to a soft‑close pattern.
* ✅ Remove EIP‑1559 fee UI complexity; use a single `gasPrice` input in frontends.
* ✅ If you rely on on‑chain “randomness,” integrate an oracle/VRF.
* ✅ Size your `gasLimit` with a modest buffer (parallel execution can slightly vary estimates).

---

URL: https://docs.sei.io/evm/evm-parity/evm-compatibility

# EVM Compatibility

> EVM feature support on Sei — what works, what differs from Ethereum, and what is not available

# EVM Compatibility

This page documents Sei's EVM feature support. Each row shows whether a capability works as on standard Ethereum, behaves differently in a documented way, or is not available on Sei.

Standard EVM tooling — viem, wagmi, ethers, Foundry, Hardhat — works on Sei for all rows marked **Supported**. Where Sei differs from Ethereum, the difference is noted so you can account for it in your application.

## Status Legend

| Status                  | Meaning                                                                   |
| ----------------------- | ------------------------------------------------------------------------- |
| Supported               | Works on Sei EVM with standard Ethereum behavior.                         |
| Supported — differences | Available on Sei, but intentionally differs from Ethereum. See the notes. |
| Sei extension           | A Sei-specific capability with no standard Ethereum equivalent.           |
| Not supported           | Not available on Sei EVM.                                                 |

## Transactions

| Feature                                    | Sei status              | Notes                                                                                                                       |
| ------------------------------------------ | ----------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| Legacy transactions (type 0)               | Supported — differences | Minimum gas price is set by Sei governance parameters, not a fixed floor. [See Gas and Fees.](/evm/evm-parity/gas-and-fees) |
| EIP-2930 access list transactions (type 1) | Supported               |                                                                                                                             |
| EIP-1559 fee market transactions (type 2)  | Supported — differences | No base-fee burning. Fees go to validators rather than being burned. [See Gas and Fees.](/evm/evm-parity/gas-and-fees)      |
| EIP-4844 blob transactions (type 3)        | Not supported           | Sei runs Pectra without blob transactions. [See Transaction Types.](/evm/evm-parity/transaction-types)                      |
| EIP-7702 set-code transactions (type 4)    | Supported               |                                                                                                                             |

## Account and State

| Feature                           | Sei status              | Notes                                                                                                                                                                       |
| --------------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `eth_getBalance`                  | Supported               |                                                                                                                                                                             |
| `eth_getTransactionCount` (nonce) | Supported               |                                                                                                                                                                             |
| `eth_getCode`                     | Supported               |                                                                                                                                                                             |
| `eth_getStorageAt`                | Supported — differences | SSTORE cost is governance-adjustable; do not hard-code gas assumptions. [See Gas and Fees.](/evm/evm-parity/gas-and-fees)                                                   |
| `eth_getProof`                    | Supported — differences | Returns IAVL proof data rather than Ethereum Merkle Patricia Trie proofs. Proof verification logic must account for this. [See State Proofs.](/evm/evm-parity/state-proofs) |

## Blocks and Finality

| Feature                                       | Sei status              | Notes                                                                                                                                             |
| --------------------------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `eth_getBlockByHash`, `eth_getBlockByNumber`  | Supported               |                                                                                                                                                   |
| `eth_blockNumber`                             | Supported               |                                                                                                                                                   |
| Finality tags (`latest`, `safe`, `finalized`) | Supported — differences | Sei has instant finality. All three tags refer to the same commitment level. [See Finality.](/evm/evm-parity/finality)                            |
| Pending block state                           | Supported — differences | Ethereum-style pending state visibility is not guaranteed. Do not rely on pending transaction ordering. [See Finality.](/evm/evm-parity/finality) |

## Logs, Filters, and Subscriptions

| Feature                                                                                                | Sei status | Notes                                                   |
| ------------------------------------------------------------------------------------------------------ | ---------- | ------------------------------------------------------- |
| `eth_getLogs`                                                                                          | Supported  |                                                         |
| Filter lifecycle (`eth_newFilter`, `eth_getFilterChanges`, `eth_getFilterLogs`, `eth_uninstallFilter`) | Supported  |                                                         |
| WebSocket subscriptions (`eth_subscribe`)                                                              | Supported  | [See WebSocket Connections.](/evm/evm-parity/websocket) |

## Execution and Simulation

| Feature                  | Sei status | Notes |
| ------------------------ | ---------- | ----- |
| `eth_call`               | Supported  |       |
| `eth_estimateGas`        | Supported  |       |
| `debug_traceTransaction` | Supported  |       |
| Block-level tracing      | Supported  |       |

## Signing

| Feature                                             | Sei status | Notes                                                                                        |
| --------------------------------------------------- | ---------- | -------------------------------------------------------------------------------------------- |
| EIP-155 replay protection                           | Supported  |                                                                                              |
| Personal sign (`personal_sign`, `eth_sign`)         | Supported  | Depends on the connected wallet exposing the method. [See Signing.](/evm/evm-parity/signing) |
| EIP-712 typed data signing (`eth_signTypedData_v4`) | Supported  | Depends on the connected wallet exposing the method. [See Signing.](/evm/evm-parity/signing) |
| EIP-1271 contract signature validation              | Supported  | [See Signing.](/evm/evm-parity/signing)                                                      |

## Token Standards

| Feature  | Sei status | Notes |
| -------- | ---------- | ----- |
| ERC-20   | Supported  |       |
| ERC-721  | Supported  |       |
| ERC-1155 | Supported  |       |

## Account Abstraction

| Feature  | Sei status | Notes                                                          |
| -------- | ---------- | -------------------------------------------------------------- |
| ERC-4337 | Supported  | Requires a compatible bundler. Sei EVM is ERC-4337 compatible. |

## Name Services

| Feature | Sei status    | Notes                                                                                                |
| ------- | ------------- | ---------------------------------------------------------------------------------------------------- |
| ENS     | Not supported | Sei does not run Ethereum mainnet ENS. Application-level name services can be deployed as contracts. |

## Sei Extensions

These capabilities are Sei-specific and have no standard Ethereum equivalent. They are exposed through `@sei-js` packages layered on top of standard EVM tooling.

| Feature                                                                                  | Notes                                                                                                                                                |
| ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| Sei precompiles (staking, governance, distribution, oracle, P256, JSON, CosmWasm bridge) | EVM contracts at deterministic addresses. ABIs and contract addresses are exported from `@sei-js/precompiles` for use with any standard EVM library. |
| Pointer contracts (CW20 ↔ ERC-20, CW721 ↔ ERC-721)                                       | Bridge between CosmWasm and EVM token standards. Standard ERC interfaces work against pointer contracts.                                             |
| Native address association (EVM ↔ Cosmos address)                                        | Links an EVM address and a Cosmos address for the same account. Required before some Sei-native flows.                                               |
| TokenFactory native token creation                                                       | Create native Sei tokens that are usable across EVM and CosmWasm without a wrapper contract.                                                         |

## Unsupported RPC Methods

The following JSON-RPC methods are either not available on Sei or will return errors:

### Blob / EIP-4844

| Method              | Reason                                                                               |
| ------------------- | ------------------------------------------------------------------------------------ |
| `eth_blobBaseFee`   | Sei runs Pectra without blob transaction support. This method does not exist on Sei. |
| `engine_getBlobsV1` | Blob data availability endpoints are not supported.                                  |

### Pending State

| Method                                        | Behavior on Sei                                                                                                                               |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `eth_getBlockByNumber("pending")`             | Returns `null` or the latest committed block. Sei does not maintain an Ethereum-style pending block.                                          |
| `eth_getTransactionCount(address, "pending")` | Returns the same value as `"latest"`. Pending nonce does not differ from confirmed nonce on Sei.                                              |
| `eth_newPendingTransactionFilter`             | The filter can be created but will not reliably emit pending transactions. Use `eth_newBlockFilter` or WebSocket block subscriptions instead. |
| `eth_subscribe("newPendingTransactions")`     | Supported at the RPC level but Sei does not guarantee Ethereum-style pending transaction visibility. Treat results as best-effort.            |

### Proof Verification

| Method         | Behavior on Sei                                                                                                                                                                                                           |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `eth_getProof` | Returns IAVL tree proofs, not Ethereum Merkle Patricia Trie proofs. The method itself works, but the proof format is incompatible with standard Ethereum MPT verifiers. [See State Proofs.](/evm/evm-parity/state-proofs) |

### Deprecated / Removed Opcodes

| Method         | Reason                                                                                                                                          |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `eth_accounts` | Returns an empty array on Sei RPC nodes. Use a wallet library (`eth_requestAccounts`) to get accounts from the connected user's wallet instead. |

---

URL: https://docs.sei.io/evm/evm-parity/finality

# Finality and Block Tags

> How Sei instant finality affects block tag behavior and pending state

# Finality and Block Tags

Sei uses Twin Turbo Consensus, which provides instant finality. Every committed block is final immediately — there is no period where a block could be reorganized away.

This changes how block tags behave compared to Ethereum.

## Block Tags

On Ethereum, `latest`, `safe`, and `finalized` refer to different points in the chain:

* `latest` — the most recent block, possibly not yet safe
* `safe` — a block unlikely to be reorganized
* `finalized` — a block that is permanently committed

On Sei, all three tags resolve to the same block. There is no reorg risk at any point after a block is committed, so the distinction does not exist.

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, http } from 'viem';
  import { sei } from 'viem/chains';

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

  // All three return the same block on Sei
  const latest    = await client.getBlock({ blockTag: 'latest' });
  const safe      = await client.getBlock({ blockTag: 'safe' });
  const finalized = await client.getBlock({ blockTag: 'finalized' });
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');

  // All three return the same block on Sei
  const latest    = await provider.getBlock('latest');
  const safe      = await provider.getBlock('safe');
  const finalized = await provider.getBlock('finalized');
  ```
</CodeGroup>

## Waiting for Confirmation

Because finality is instant, you do not need to wait for multiple confirmations. `waitForTransactionReceipt` resolves as soon as the transaction is included in a block.

<CodeGroup>
  ```ts viem theme={"dark"}
  const receipt = await client.waitForTransactionReceipt({ hash });
  // receipt is already final — no further confirmation needed
  ```

  ```ts ethers theme={"dark"}
  const tx = await signer.sendTransaction({ /* ... */ });
  const receipt = await tx.wait(1); // 1 confirmation is final on Sei
  ```
</CodeGroup>

## Pending State

Sei does not expose Ethereum-style pending state. Do not rely on:

* Reading pending transactions from the mempool
* `eth_getBlockByNumber` with `'pending'`
* Pending nonce differing from the confirmed nonce

If your application polls pending transactions or depends on pending state visibility, replace that pattern with confirmed-block polling or WebSocket subscriptions on committed blocks.

## Practical Impact

| Pattern                  | On Ethereum        | On Sei              |
| ------------------------ | ------------------ | ------------------- |
| Wait for `finalized` tag | Waits \~13 minutes | Returns immediately |
| Check `safe` vs `latest` | Different blocks   | Same block          |
| Read pending mempool     | Supported          | Not reliable        |
| Confirmation count       | Meaningful         | 1 is sufficient     |

---

URL: https://docs.sei.io/evm/evm-parity/gas-and-fees

# Gas and Fees

> Sei gas price floor, EIP-1559 fee model differences, and SSTORE cost

# Gas and Fees

Sei supports both legacy and EIP-1559 transactions, but the fee model differs from Ethereum in three ways that affect how you estimate and set gas.

## Legacy Gas Price Floor

Legacy transactions (type 0) on Sei must meet a minimum gas price set by on-chain governance. This floor can change via governance proposals — do not hard-code a specific value.

Use `eth_gasPrice` to read the current minimum:

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, http } from 'viem';
  import { sei } from 'viem/chains';

  const client = createPublicClient({ chain: sei, transport: http() });
  const gasPrice = await client.getGasPrice();
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
  const feeData = await provider.getFeeData();
  const gasPrice = feeData.gasPrice;
  ```
</CodeGroup>

## EIP-1559 Fee Model

Sei supports EIP-1559 transactions (type 2), but does not burn the base fee. Fees go entirely to validators rather than being partially burned as on Ethereum.

This does not affect how you construct or send transactions — `maxFeePerGas` and `maxPriorityFeePerGas` work as expected. It is relevant only if your application models token supply or displays fee-burn information to users.

<CodeGroup>
  ```ts viem theme={"dark"}
  const fees = await client.estimateFeesPerGas();
  // fees.maxFeePerGas and fees.maxPriorityFeePerGas are usable as-is
  ```

  ```ts ethers theme={"dark"}
  const feeData = await provider.getFeeData();
  // feeData.maxFeePerGas and feeData.maxPriorityFeePerGas are usable as-is
  ```
</CodeGroup>

## SSTORE Cost

The gas cost of `SSTORE` (writing to contract storage) is governance-adjustable on Sei. It is currently **72,000 gas** — the same on mainnet and testnet (see [Divergence from Ethereum](/evm/differences-with-ethereum#sstore-gas-cost)) — but treat that as the current value, not a constant: do not hard-code storage write estimates in your application.

Always use `eth_estimateGas` for any transaction that writes to storage:

<CodeGroup>
  ```ts viem theme={"dark"}
  const gas = await client.estimateGas({
    account,
    to: contractAddress,
    data: encodedCalldata,
  });

  // Add a buffer for governance changes during high-activity periods
  const gasWithBuffer = (gas * 120n) / 100n; // 20% buffer
  ```

  ```ts ethers theme={"dark"}
  const gas = await provider.estimateGas({
    from: signer.address,
    to: contractAddress,
    data: encodedCalldata,
  });
  ```
</CodeGroup>

<Warning>A Foundry `forge test --gas-report --fork-url <sei rpc>` report forks chain *state* but runs revm's standard EVM gas schedule, so it shows `SSTORE` at the Ethereum cost (\~22,100) rather than Sei's \~72,000. Use it for relative profiling of your own logic; estimate the absolute storage-write cost with a live `eth_estimateGas` against a Sei RPC.</Warning>

## Summary

| Behavior         | Ethereum              | Sei                                       |
| ---------------- | --------------------- | ----------------------------------------- |
| Legacy gas floor | Protocol minimum      | Governance-set, can change                |
| Base fee         | Burned                | Paid to validators                        |
| SSTORE cost      | Fixed by EIP          | Governance-adjustable                     |
| `estimateGas`    | Always correct to use | Required — do not hard-code storage costs |

---

URL: https://docs.sei.io/evm/evm-parity/transaction-types

# Transaction Types

> Which Ethereum transaction types are supported on Sei

# Transaction Types

Sei supports most Ethereum transaction types. The one notable exception is blob transactions.

## Supported Types

| Type | EIP      | Name        | Sei support                                          |
| ---- | -------- | ----------- | ---------------------------------------------------- |
| 0    | —        | Legacy      | Supported — governance-set minimum gas price applies |
| 1    | EIP-2930 | Access list | Supported                                            |
| 2    | EIP-1559 | Fee market  | Supported — base fee is not burned                   |
| 4    | EIP-7702 | Set code    | Supported                                            |

## Not Supported

| Type | EIP      | Name | Notes                                                     |
| ---- | -------- | ---- | --------------------------------------------------------- |
| 3    | EIP-4844 | Blob | Not supported — Sei runs Pectra without blob transactions |

## Blob Transactions

Sei runs the Pectra hardfork without blob transaction support. Attempting to send a type 3 transaction will be rejected at the RPC level.

If you are porting code from Ethereum that uses blob transactions (e.g. rollup data availability), that path does not apply to Sei.

## Sending Transactions

Standard library defaults work correctly. viem, wagmi, and ethers all default to type 2 (EIP-1559) transactions on chains that support it, which Sei does.

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createWalletClient, http, parseEther } from 'viem';
  import { privateKeyToAccount } from 'viem/accounts';
  import { sei } from 'viem/chains';

  const account = privateKeyToAccount('0xYourPrivateKey');
  const client = createWalletClient({ account, chain: sei, transport: http() });

  // Sends a type 2 transaction — correct default for Sei
  const hash = await client.sendTransaction({
    to: '0xRecipient',
    value: parseEther('1'),
  });
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
  const wallet = new ethers.Wallet('0xYourPrivateKey', provider);

  // ethers defaults to EIP-1559 where supported — correct for Sei
  const tx = await wallet.sendTransaction({
    to: '0xRecipient',
    value: ethers.parseEther('1'),
  });
  ```
</CodeGroup>

---

URL: https://docs.sei.io/evm/evm-parity/state-proofs

# State Proofs

> How eth_getProof differs on Sei due to IAVL tree storage

# State Proofs

Sei supports `eth_getProof` but returns a different proof format from Ethereum. If your application verifies proofs on-chain or off-chain, you need to account for this difference.

## The Difference

Ethereum stores state in a Merkle Patricia Trie (MPT) and `eth_getProof` returns MPT inclusion proofs. Sei stores state in an IAVL tree and returns IAVL proofs instead.

The RPC method exists and responds correctly, but the proof data structure is not compatible with Ethereum MPT proof verifiers.

## What This Affects

Most applications do not call `eth_getProof` directly. It is primarily used by:

* Light clients verifying state without trusting an RPC node
* Cross-chain bridges proving inclusion of state on Sei
* Applications verifying contract storage values trustlessly

If you are doing standard contract reads, event queries, or transaction lookups, this difference does not affect you.

## Calling eth\_getProof

The call works through standard libraries:

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, http } from 'viem';
  import { sei } from 'viem/chains';

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

  const proof = await client.getProof({
    address: '0xContractAddress',
    storageKeys: ['0xStorageSlot'],
  });

  // proof.accountProof and proof.storageProof contain IAVL proof data,
  // not Ethereum MPT proofs — do not pass to an MPT verifier
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');

  const proof = await provider.send('eth_getProof', [
    '0xContractAddress',
    ['0xStorageSlot'],
    'latest',
  ]);

  // Same caveat — proof data is IAVL format
  ```
</CodeGroup>

## Verifying Proofs

To verify Sei state proofs, use an IAVL-compatible verifier. Standard Ethereum MPT verifier libraries (e.g. those used in Solidity or in Ethereum bridge contracts) will reject Sei proofs.

Refer to the [Sei RPC reference](/evm/reference) for the exact proof schema returned.

---

URL: https://docs.sei.io/evm/evm-parity/websocket

# WebSocket Connections

> Connecting to Sei via WebSocket for real-time block and event subscriptions

# WebSocket Connections

Sei supports `eth_subscribe` over WebSocket. You can subscribe to new blocks, event logs, and pending transactions using standard library WebSocket transports.

## Endpoints

| Network | WebSocket endpoint                   |
| ------- | ------------------------------------ |
| Mainnet | `wss://evm-ws.sei-apis.com`          |
| Testnet | `wss://evm-ws-testnet.sei-apis.com`  |
| Devnet  | `wss://evm-ws-arctic-1.sei-apis.com` |

## Connecting

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, webSocket } from 'viem';
  import { sei } from 'viem/chains';

  const client = createPublicClient({
    chain: sei,
    transport: webSocket('wss://evm-ws.sei-apis.com'),
  });
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.WebSocketProvider('wss://evm-ws.sei-apis.com');
  ```
</CodeGroup>

## Watching New Blocks

<CodeGroup>
  ```ts viem theme={"dark"}
  const unwatch = client.watchBlocks({
    onBlock: (block) => {
      console.log('New block:', block.number);
    },
  });

  // Stop watching
  unwatch();
  ```

  ```ts ethers theme={"dark"}
  provider.on('block', (blockNumber) => {
    console.log('New block:', blockNumber);
  });

  // Stop watching
  provider.off('block');
  ```
</CodeGroup>

## Watching Contract Events

<CodeGroup>
  ```ts viem theme={"dark"}
  import { parseAbiItem } from 'viem';

  const unwatch = client.watchEvent({
    address: '0xContractAddress',
    event: parseAbiItem('event Transfer(address indexed from, address indexed to, uint256 value)'),
    onLogs: (logs) => {
      console.log('Transfer events:', logs);
    },
  });
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const ERC20_ABI = ['event Transfer(address indexed from, address indexed to, uint256 value)'];
  const contract = new ethers.Contract('0xContractAddress', ERC20_ABI, provider);

  contract.on('Transfer', (from, to, value, event) => {
    console.log('Transfer:', { from, to, value });
  });

  // Stop watching
  contract.off('Transfer');
  ```
</CodeGroup>

## Watching ERC-20 Transfers Across All Contracts

```ts viem theme={"dark"}
import { parseAbiItem } from 'viem';

const unwatch = client.watchEvent({
  event: parseAbiItem('event Transfer(address indexed from, address indexed to, uint256 value)'),
  onLogs: (logs) => {
    logs.forEach((log) => {
      console.log(`Transfer on ${log.address}:`, log.args);
    });
  },
});
```

## Notes

* Sei's instant finality means every block emitted over WebSocket is already final — no need to wait for additional confirmations before acting on an event.
* Pending transaction subscriptions (`newPendingTransactions`) are supported at the RPC level but Sei does not guarantee Ethereum-style pending state visibility.

---

URL: https://docs.sei.io/evm/evm-parity/signing

# Signing

> Wallet signing method support and EIP-712 typed data on Sei

# Signing

Signing on Sei works through standard EVM libraries and wallet standards. The methods available depend on which wallet the user has connected.

## Wallet Signing Support

| Method                 | Standard | Sei Global Wallet | MetaMask  | WalletConnect wallets |
| ---------------------- | -------- | ----------------- | --------- | --------------------- |
| `personal_sign`        | EIP-191  | Supported         | Supported | Wallet-dependent      |
| `eth_signTypedData_v4` | EIP-712  | Supported         | Supported | Wallet-dependent      |
| `eth_sign`             | Legacy   | Not recommended   | Supported | Wallet-dependent      |
| Transaction signing    | —        | Supported         | Supported | Supported             |

Do not assume all wallets support all methods. Always handle rejection gracefully.

## Personal Sign

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createWalletClient, custom } from 'viem';
  import { sei } from 'viem/chains';

  const client = createWalletClient({
    chain: sei,
    transport: custom(window.ethereum),
  });

  const [account] = await client.getAddresses();

  const signature = await client.signMessage({
    account,
    message: 'Hello Sei',
  });
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();

  const signature = await signer.signMessage('Hello Sei');
  ```
</CodeGroup>

## EIP-712 Typed Data

<CodeGroup>
  ```ts viem theme={"dark"}
  const [account] = await client.getAddresses();

  const signature = await client.signTypedData({
    account,
    domain: {
      name: 'My App',
      version: '1',
      chainId: 1329, // Sei mainnet
      verifyingContract: '0xContractAddress',
    },
    types: {
      Order: [
        { name: 'maker', type: 'address' },
        { name: 'amount', type: 'uint256' },
        { name: 'expiry', type: 'uint256' },
      ],
    },
    primaryType: 'Order',
    message: {
      maker: account,
      amount: 1000000n,
      expiry: BigInt(Math.floor(Date.now() / 1000) + 3600),
    },
  });
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();

  const domain = {
    name: 'My App',
    version: '1',
    chainId: 1329,
    verifyingContract: '0xContractAddress',
  };

  const types = {
    Order: [
      { name: 'maker', type: 'address' },
      { name: 'amount', type: 'uint256' },
      { name: 'expiry', type: 'uint256' },
    ],
  };

  const value = {
    maker: await signer.getAddress(),
    amount: 1000000n,
    expiry: BigInt(Math.floor(Date.now() / 1000) + 3600),
  };

  const signature = await signer.signTypedData(domain, types, value);
  ```
</CodeGroup>

## Verifying Signatures

```ts viem theme={"dark"}
import { verifyMessage, verifyTypedData } from 'viem';

// Verify personal sign
const valid = await verifyMessage({
  address: '0xSignerAddress',
  message: 'Hello Sei',
  signature,
});

// Verify EIP-712
const validTyped = await verifyTypedData({
  address: '0xSignerAddress',
  domain,
  types,
  primaryType: 'Order',
  message: value,
  signature,
});
```

## EIP-1271 Contract Signatures

Smart contract wallets on Sei can validate signatures via EIP-1271 (`isValidSignature`). Use viem's `verifyMessage` with a contract address — it automatically uses EIP-1271 when the address is a contract.

```ts viem theme={"dark"}
const valid = await verifyMessage({
  address: '0xSmartContractWallet',
  message: 'Hello Sei',
  signature,
});
// viem calls isValidSignature if the address is a contract
```

---

URL: https://docs.sei.io/evm/migrate-from-other-evms

# Migrate Your EVM dApp to Sei

> Step-by-step checklist for teams that already run on another EVM chain and want to redeploy on Sei, including environment prep, contract migration, liquidity planning, and chain-specific guidance for Ethereum, Arbitrum, Base, Polygon, and Avalanche.

Sei offers full EVM bytecode compatibility plus instant finality and sub-second blocks. This guide distills what product teams need to do when they already run on Polygon, Base, Ethereum, Arbitrum, Avalanche or another EVM chain and want to bring your dApp stack to Sei.

<Info>
  **Why Migrate to Sei?**

  * **400ms block times** – 30× faster than Ethereum, 2-5× faster than most L2s
  * **\~100 MGas/s throughput** – 20× higher than Ethereum mainnet
  * **Instant finality (\~400 ms)** – No waiting for confirmations or safe/finalized states
  * **Parallelized execution** – Higher throughput without code changes
  * **Full EVM compatibility** – Deploy your existing Solidity contracts unchanged
</Info>

## Chain Comparison Overview

Before diving into migration steps, understand how Sei compares to your source chain:

| Feature            | Sei                     | Ethereum             | Arbitrum                 | Base                     | Polygon PoS         | Avalanche C-Chain |
| ------------------ | ----------------------- | -------------------- | ------------------------ | ------------------------ | ------------------- | ----------------- |
| Chain ID           | 1329                    | 1                    | 42161                    | 8453                     | 137                 | 43114             |
| Block Time         | 400 ms                  | \~12 s               | \~250 ms                 | \~2 s                    | \~2 s               | \~2 s             |
| Finality           | Instant (\~400 ms)      | \~15 min (finalized) | \~7 days (L1 settlement) | \~7 days (L1 settlement) | \~5 s (Heimdall v2) | \~1 s             |
| Gas Limit          | 12.5 M                  | 60M                  | 32M                      | 375M                     | 45M                 | Dynamic           |
| Per-Tx Gas Cap     | 12.5 M                  | \~16.7 M             | 32 M                     | \~25 M                   | 45 M                | Dynamic           |
| Native Token       | SEI                     | ETH                  | ETH                      | ETH                      | POL (MATIC)         | AVAX              |
| Parallel Execution | Yes                     | No                   | No                       | No                       | No                  | No                |
| Base Fee Burn      | No (100% to validators) | Yes (EIP-1559)       | Yes                      | Yes                      | Yes                 | Yes               |
| EVM Version        | Pectra (w/o blobs)      | Fusaka               | Fusaka                   | Pectra                   | Pectra              | Cancun            |

## Chain-Specific Migration Guides

Select your source chain to see specific migration considerations:

<Tabs>
  <Tab title="Ethereum">
    ### Migrating from Ethereum Mainnet

    **Key Differences:**

    | Aspect        | Ethereum                  | Sei                       | Migration Impact                              |
    | ------------- | ------------------------- | ------------------------- | --------------------------------------------- |
    | Block time    | \~12 seconds              | 400 ms                    | Reduce `deadline` buffers in DEX swaps by 30× |
    | Finality      | \~15 min for finalized    | Instant (\~400 ms)        | Remove confirmation polling logic             |
    | Gas limit     | \~16.7M per TX (EIP-7825) | 12.5 M per block/TX       | Split large batch deployments                 |
    | Fee model     | EIP-1559 with burn        | EIP-1559 different params | Update fee estimation UIs                     |
    | Pending state | Yes                       | No                        | Remove pending transaction logic              |

    **What to Update:**

    1. **Time-based logic:** If your contracts use block timestamps for deadlines, reduce timeouts proportionally. A 30-minute deadline on Ethereum (\~150 blocks) should be \~45 seconds on Sei (\~112 blocks).

    2. **Confirmation requirements:** Remove any logic that waits for multiple confirmations or checks "safe" vs "finalized" states—Sei has instant finality.

    3. **Gas estimation:** Sei's parallelized execution can slightly vary gas estimates. Add a modest buffer (10-15%) to your `gasLimit` calculations.

    4. **Fee UI:** Simplify your frontend—you can use a single `gasPrice` input instead of `maxFeePerGas` / `maxPriorityFeePerGas`.

    ```ts theme={"dark"}
    // Before (Ethereum EIP-1559)
    const tx = await contract.method({
      maxFeePerGas: ethers.parseUnits('50', 'gwei'),
      maxPriorityFeePerGas: ethers.parseUnits('2', 'gwei')
    });

    // After (Sei - simplified)
    const tx = await contract.method({
      gasPrice: ethers.parseUnits('50', 'gwei') // Sei minimum gas price is 50 gwei (live on mainnet — query with eth_gasPrice)
    });
    ```

    <Note>Sei enforces a 50 gwei minimum gas price; transactions below this are rejected by the mempool. Query the live value with `eth_gasPrice` (returns base fee + suggested tip).</Note>

    5. **PREVRANDAO/DIFFICULTY:** If you use these for any randomness, integrate a VRF oracle instead—Sei's values are derived from block time, not true randomness.
  </Tab>

  <Tab title="Arbitrum">
    ### Migrating from Arbitrum

    **Key Differences:**

    | Aspect       | Arbitrum                   | Sei                      | Migration Impact                        |
    | ------------ | -------------------------- | ------------------------ | --------------------------------------- |
    | Architecture | Optimistic Rollup (L2)     | L1                       | No L1 data availability concerns        |
    | Finality     | \~7 days for L1 settlement | Instant (\~400 ms)       | Simplify withdrawal flows               |
    | Sequencer    | Centralized sequencer      | Decentralized validators | No sequencer downtime risk              |
    | Block time   | \~250 ms                   | 400 ms                   | Slightly slower, but with true finality |
    | L1 gas       | Pays L1 data costs         | No L1 dependency         | Simpler fee structure                   |

    **What to Update:**

    1. **Remove L1 interactions:** Any logic that posts data to or reads from Ethereum L1 should be removed or replaced with Sei-native alternatives.

    2. **Sequencer assumptions:** Remove any sequencer uptime checks or fallback logic—Sei uses decentralized consensus.

    3. **Withdrawal delays:** If your protocol has 7-day withdrawal windows for "L1 finality," you can remove these—Sei settles instantly.

    4. **ArbOS precompiles:** Replace any Arbitrum-specific precompiles:

    ```solidity theme={"dark"}
    // Arbitrum-specific (remove)
    // import { ArbSys } from "@arbitrum/nitro-contracts/src/precompiles/ArbSys.sol";
    // uint256 blockNum = ArbSys(0x64).arbBlockNumber();

    // Sei equivalent
    uint256 blockNum = block.number; // Standard EVM
    ```

    5. **Cross-chain messaging:** Replace Arbitrum's native bridge with [LayerZero V2](/evm/bridging/layerzero) for omnichain connectivity.
  </Tab>

  <Tab title="Base">
    ### Migrating from Base

    **Key Differences:**

    | Aspect         | Base                       | Sei                      | Migration Impact                 |
    | -------------- | -------------------------- | ------------------------ | -------------------------------- |
    | Architecture   | OP Stack Rollup (L2)       | L1                       | No L1 data availability concerns |
    | Finality       | \~7 days for L1 settlement | Instant (\~400 ms)       | Simplify withdrawal flows        |
    | Block time     | \~2 seconds                | 400 ms                   | 5× faster block production       |
    | Sequencer      | Coinbase-operated          | Decentralized validators | No single point of failure       |
    | EIP-4844 blobs | Supported                  | Not supported            | Remove blob transaction logic    |

    **What to Update:**

    1. **Remove blob transactions:** Sei doesn't support EIP-4844 blob transactions. If you're using them for data availability, store data differently or use Sei's native mechanisms.

    2. **OP Stack precompiles:** Remove any Optimism/Base-specific precompile calls:

    ```solidity theme={"dark"}
    // Base-specific (remove)
    // L1Block(0x4200000000000000000000000000000000000015).number();

    // Use standard EVM on Sei
    uint256 blockNum = block.number;
    ```

    3. **Fault proof assumptions:** Remove any logic that accounts for the 7-day challenge period—Sei has instant finality.

    4. **Sequencer fee logic:** Base has a separate L1 data fee component. On Sei, fees are simpler: `Gas Used × Gas Price`.

    5. **Coinbase Wallet integrations:** Update wallet connection logic to use Sei network parameters:

    ```ts theme={"dark"}
    // Update network config
    const seiMainnet = {
      chainId: '0x531', // 1329 in hex
      chainName: 'Sei',
      nativeCurrency: { name: 'Sei', symbol: 'SEI', decimals: 18 },
      rpcUrls: ['https://evm-rpc.sei-apis.com'],
      blockExplorerUrls: ['https://seiscan.io']
    };
    ```
  </Tab>

  <Tab title="Polygon">
    ### Migrating from Polygon PoS

    **Key Differences:**

    | Aspect       | Polygon PoS          | Sei                | Migration Impact               |
    | ------------ | -------------------- | ------------------ | ------------------------------ |
    | Native token | POL (MATIC)          | SEI                | Update all token references    |
    | Block time   | \~2 seconds          | 400 ms             | 5× faster blocks               |
    | Finality     | \~5 s (Heimdall v2)  | Instant (\~400 ms) | Remove finality delay handling |
    | Checkpoints  | Periodic to Ethereum | None               | Simpler architecture           |
    | Reorgs       | Possible (rare)      | Never              | Remove reorg handling          |

    **What to Update:**

    1. **Token references:** Replace all MATIC/POL references with SEI:

    ```solidity theme={"dark"}
    // Before (Polygon)
    // IERC20(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270).transfer(...); // WMATIC

    // After (Sei) - use native SEI or wrapped version
    // Check ecosystem contracts for canonical WSEI address
    ```

    2. **Checkpoint logic:** Remove any logic that waits for Polygon checkpoints to Ethereum—Sei has instant finality.

    3. **Heimdall/Bor assumptions:** Remove any Polygon-specific validator or sidechain logic.

    4. **Reorg handling:** You can safely remove block reorganization handling code—Sei's consensus prevents reorgs.

    5. **Gas price oracles:** Polygon's gas prices can spike significantly. Sei's fees are more stable due to higher throughput:

    ```ts theme={"dark"}
    // Polygon - needed aggressive gas price management
    const gasPrice = await provider.getGasPrice();
    const boostedPrice = gasPrice.mul(120).div(100); // 20% buffer

    // Sei - simpler approach works
    const gasPrice = await provider.getGasPrice(); // Usually sufficient as-is
    ```

    6. **Bridge integrations:** Replace Polygon Bridge with [LayerZero](/evm/bridging/layerzero) or other Sei-supported bridges.
  </Tab>

  <Tab title="Avalanche">
    ### Migrating from Avalanche C-Chain

    **Key Differences:**

    | Aspect       | Avalanche C-Chain     | Sei                | Migration Impact                                |
    | ------------ | --------------------- | ------------------ | ----------------------------------------------- |
    | Native token | AVAX                  | SEI                | Update all token references                     |
    | Block time   | \~2 seconds           | 400 ms             | 5× faster blocks                                |
    | Finality     | \~1 second            | Instant (\~400 ms) | Similar, slightly faster                        |
    | Subnets      | Supported             | N/A                | Remove subnet logic                             |
    | Gas limit    | Dynamic (post-Octane) | 12.5 M             | Large tx headroom varies; benchmark deployments |

    **What to Update:**

    1. **Token references:** Replace AVAX with SEI:

    ```solidity theme={"dark"}
    // Before (Avalanche)
    // IERC20(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7).transfer(...); // WAVAX

    // After (Sei)
    // Use native SEI or check ecosystem contracts for WSEI
    ```

    2. **Subnet interactions:** If your dApp uses Avalanche Subnets, you'll need to redesign that architecture for Sei's single-chain model or use cross-chain messaging.

    3. **Avalanche-specific precompiles:** Remove C-Chain precompile calls:

    ```solidity theme={"dark"}
    // Avalanche-specific (remove)
    // INativeMinter(0x0200000000000000000000000000000000000001).mintNativeCoin(...)

    // Use standard EVM patterns on Sei
    ```

    4. **Gas limit adjustments:** Avalanche now uses a dynamic gas model after Octane, while Sei has a fixed `12.5M` block/tx cap. If you have large transactions, benchmark them on Sei and split them when needed:

    ```ts theme={"dark"}
    // If deploying large contracts, batch by gas
    const MAX_GAS_PER_BATCH = 11_500_000; // Leave buffer under 12.5M
    ```

    5. **TWAP calculations:** Both chains have fast blocks, but adjust your observation windows if migrating oracle logic:

    ```solidity theme={"dark"}
    // Avalanche: 1 hour = ~1800 blocks
    // Sei: 1 hour = ~9000 blocks
    uint32 constant TWAP_PERIOD = 9000; // Adjust for Sei's block time
    ```
  </Tab>
</Tabs>

## Step 1: Evaluate Compatibility

Revisit the [Divergence from Ethereum](/evm/differences-with-ethereum) doc and confirm every assumption your contracts/frontends make still holds.

| Dimension      | Sei EVM                      | Practical Effect                                                           |
| -------------- | ---------------------------- | -------------------------------------------------------------------------- |
| Block time     | 400 ms                       | Faster TX inclusion → smaller `deadline` buffers and quicker price oracles |
| Finality       | Instant (\~400 ms)           | No separate "safe/latest" commitment levels to poll                        |
| Gas limit      | 12.5M gas + 21 MB byte limit | Batch contract deployments by 12.5M gas blocks                             |
| Base fee       | Dynamic but never burned     | Validators receive 100% of fees                                            |
| Execution      | Parallelized EVM             | No changes to your Solidity code are necessary                             |
| Address format | Dual (0x + sei1...)          | Same private key derives both addresses                                    |

<Warning>
  **Features Requiring Attention:**

  * **Pending state:** Sei doesn't have pending state — transactions are either included or not
  * **Blob opcodes:** EIP-4844 blob transactions are not supported
  * **PREVRANDAO entropy:** Returns block-time-derived value, not true randomness — use VRF oracles here
  * **SELFDESTRUCT:** Deprecated; refactor to "soft close" patterns
</Warning>

## Step 2: Prepare Your Development Environment

### Add Sei Network Configuration

**Hardhat Configuration:**

```ts title="hardhat.config.ts" theme={"dark"}
import { defineConfig, configVariable } from 'hardhat/config';
import hardhatToolboxMochaEthers from '@nomicfoundation/hardhat-toolbox-mocha-ethers';

export default defineConfig({
  networks: {
    seiMainnet: {
      type: 'http',
      chainId: 1329,
      url: 'https://evm-rpc.sei-apis.com',
      accounts: [configVariable('SEI_PRIVATE_KEY')]
    },
    seiTestnet: {
      type: 'http',
      chainId: 1328,
      url: 'https://evm-rpc-testnet.sei-apis.com',
      accounts: [configVariable('SEI_PRIVATE_KEY')]
    }
  },
  plugins: [hardhatToolboxMochaEthers]
});
```

Store your deployer key in Hardhat's encrypted keystore with `npx hardhat keystore set SEI_PRIVATE_KEY`. Contract verification via Sourcify is enabled by default in Hardhat 3's `hardhat-verify` (bundled with the toolbox).

**Foundry Configuration:**

```toml title="foundry.toml" theme={"dark"}
[profile.default]
src = "src"
out = "out"
libs = ["lib"]

[rpc_endpoints]
sei_mainnet = "https://evm-rpc.sei-apis.com"
sei_testnet = "https://evm-rpc-testnet.sei-apis.com"

# Verification uses Sourcify (no API key needed)
# Run: forge verify-contract --verifier sourcify --chain-id <CHAIN_ID> <ADDRESS> <PATH:CONTRACT>
```

See the [Hardhat tutorial](/evm/evm-hardhat) and [Foundry guide](/evm/evm-foundry) for complete setup instructions.

### Wallet Configuration

Pre-configure MetaMask or other wallets with Sei chain params:

```ts theme={"dark"}
const seiMainnet = {
  chainId: '0x531', // 1329
  chainName: 'Sei',
  nativeCurrency: { name: 'Sei', symbol: 'SEI', decimals: 18 },
  rpcUrls: ['https://evm-rpc.sei-apis.com'],
  blockExplorerUrls: ['https://seiscan.io']
};

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [seiMainnet]
});
```

## Step 3: Bootstrap Common Infrastructure

Sei already exposes canonical helper contracts—reference them instead of redeploying:

| Component               | Address                                      | Notes                                             |
| ----------------------- | -------------------------------------------- | ------------------------------------------------- |
| Permit2                 | `0xB952578f3520EE8Ea45b7914994dcf4702cEe578` | Shared allowance manager for DEX and wallet flows |
| Multicall3              | `0xcA11bde05977b3631167028862bE2a173976CA11` | Enables batching and view aggregation             |
| ImmutableCreate2Factory | `0x0000000000FFe8B47B3e2130213B802212439497` | Deterministic deployments with `CREATE2`          |
| SingletonFactory        | `0xce0042B868300000d44A59004Da54A005ffdcf9f` | EIP-2470 singleton factory                        |

For third-party contracts (LayerZero, Safe, etc.), consult the full [Ecosystem Contracts page](/evm/ecosystem-contracts).

## Step 4: Port Contracts and Configuration

### Parameterize Chain-Specific Constants

```solidity theme={"dark"}
// Example: Chain-aware deadline calculation
function getDeadline(uint256 secondsFromNow) internal view returns (uint256) {
    if (block.chainid == 1329) { // Sei mainnet
        // ~2.5 blocks per second on Sei
        return block.timestamp + secondsFromNow;
    } else if (block.chainid == 1) { // Ethereum
        // ~1 block per 12 seconds on Ethereum
        return block.timestamp + secondsFromNow;
    }
    return block.timestamp + secondsFromNow;
}
```

### Adjust Gas and Size Assumptions

* Keep `gasLimit` buffers modest but ensure calldata stays under 21 MB
* Sei's 12.5M gas limit per block means large deployments may need batching

### Refactor Deprecated Patterns

```solidity theme={"dark"}
// Before: SELFDESTRUCT (deprecated)
function destroy() external onlyOwner {
    selfdestruct(payable(owner));
}

// After: Soft close pattern
bool public closed;

function close() external onlyOwner {
    closed = true;
    // Transfer remaining funds
    payable(owner).transfer(address(this).balance);
}

modifier notClosed() {
    require(!closed, "Contract is closed");
    _;
}
```

## Step 5: Plan Bridging and Cross-Chain Connectivity

### LayerZero V2

Sei's LayerZero Endpoint ID is `30280`. See the complete [LayerZero integration guide](/evm/bridging/layerzero).

```ts title="layerzero.config.ts" theme={"dark"}
import { EndpointId } from '@layerzerolabs/lz-definitions';

const seiContract = {
  eid: EndpointId.SEI_V2_MAINNET, // 30280
  contractName: 'MyOFT'
};
```

### Other Bridge Options

* **Circle CCTP:** For USDC bridging (check availability)

## Step 6: Handle Assets and Oracles

### Oracle Integration

Sei supports multiple oracle solutions:

| Provider     | Use Case                       | Documentation                              |
| ------------ | ------------------------------ | ------------------------------------------ |
| Pyth Network | High-frequency price feeds     | [Pyth Network](https://docs.pyth.network/) |
| Chainlink    | Industry-standard data feeds   | [Chainlink on Sei](/evm/oracles/chainlink) |
| RedStone     | Modular oracle with push model | [RedStone on Sei](/evm/oracles/redstone)   |
| API3         | First-party oracle data        | [API3 on Sei](/evm/oracles/api3)           |

<Info>**TWAP Adjustments:** Because Sei blocks arrive \~30× faster than Ethereum, shorten your TWAP observation windows to maintain comparable time-weighted calculations.</Info>

## Step 7: Launch Checklist

### Testnet Deployment (atlantic-2)

* [ ] Deploy all contracts to testnet (chain ID: `1328`)
* [ ] Run full integration test suite
* [ ] Verify contracts via [Sourcify](/evm/evm-verify-contracts)
* [ ] Test wallet connections and transaction flows
* [ ] Validate oracle integrations
* [ ] Test cross-chain messaging if applicable

### Mainnet Deployment (pacific-1)

* [ ] Deploy contracts to mainnet (chain ID: `1329`)
* [ ] Re-run smoke tests
* [ ] Verify all contracts on Sourcify
* [ ] Update frontend configurations
* [ ] Prepare user migration documentation

<Warning>**Fee Redistribution Warning:** Fees on Sei are not burned. If your protocol redistributes "burn rebates" to users, redesign that logic so it does not expect a base-fee burn component.</Warning>

## Step 8: Operational Readiness

### Contract Verification

Automate verification through CI using [Sourcify](/evm/evm-verify-contracts):

```bash theme={"dark"}
# Foundry verification
forge verify-contract --watch \
  --verifier sourcify \
  --chain-id 1329 \
  <CONTRACT_ADDRESS> \
  <CONTRACT_NAME>
```

### RPC and Indexer Health

* **Primary RPC:** `https://evm-rpc.sei-apis.com`
* **Testnet RPC:** `https://evm-rpc-testnet.sei-apis.com`
* For mission-critical paths, consider self-hosted nodes or [premium RPC providers](/learn/rpc-providers)

### Monitoring Gas Parameters

Periodically query fee data to keep dashboards aligned:

```ts theme={"dark"}
// Monitor current gas prices
const feeHistory = await provider.send('eth_feeHistory', ['0x5', 'latest', []]);
const gasPrice = await provider.getGasPrice();
```

## Example: Uniswap V3-Style Deployment

Here's how to mirror a Uniswap V3 experience on Sei:

1. **Routers & Factories:** Deploy your own or fork the existing DragonSwap stack:
   * Router: `0xdD489C75be1039ec7d843A6aC2Fd658350B067Cf`
   * V3 Factory: `0x75FC67473A91335B5b8F8821277262a13B38c9b3`
   * Position Manager: `0x8B3c541c30f9b29560f56B9E44b59718916B69EF`

2. **Permit and Multicall:** Point your frontend SDK to the shared `Permit2` and `Multicall3` addresses above.

3. **Liquidity Migration Script:** Build a helper that:
   * Withdraws LP on source chain
   * Bridges underlying tokens to Sei
   * Mints new Sei LP positions
   * Include gas estimations tuned for Sei's 12.5M block cap

4. **Price Oracles:** Reuse TWAP/Chainlink logic but shorten observation windows for Sei's faster blocks.

5. **Verification:** Submit to [Sourcify](/evm/evm-verify-contracts) and the [Ecosystem Contracts registry](/evm/ecosystem-contracts).

## Helpful References

* [Divergence from Ethereum](/evm/differences-with-ethereum) – Opcode, gas, and state nuances
* [EVM Networks](/evm/networks) – RPCs, explorers, and MetaMask payloads
* [Precompiles](/evm/precompiles/example-usage) – Interoperability patterns
* [Ecosystem Contracts](/evm/ecosystem-contracts) – Canonical addresses
* [LayerZero Integration](/evm/bridging/layerzero) – Cross-chain messaging
* [Contract Verification](/evm/evm-verify-contracts) – Contract verification guide

---

URL: https://docs.sei.io/evm/migrate-from-solana

# Migrate from Solana to Sei EVM

> A comprehensive guide for Solana developers transitioning to Sei EVM, covering architectural differences, concept mapping, code translation patterns, and step-by-step migration strategies.

Sei offers a unique value proposition for Solana developers: the parallelized execution model you're familiar with, combined with full EVM compatibility and the extensive Ethereum tooling ecosystem. This guide helps Rust/Anchor developers translate their mental models and codebases to Solidity on Sei.

<Info>
  **Why Solana Developers Choose Sei**

  * **Familiar parallelization** – Sei uses optimistic parallel execution similar to Solana's Sealevel
  * **400ms block times** – Comparable to Solana's speed, with instant finality
  * **\~100 MGas/s throughput** – High performance without sacrificing EVM compatibility
  * **EVM ecosystem access** – Leverage Ethereum's mature tooling, audited contracts, and developer resources
  * **No dependency declarations** – Unlike Solana, Sei handles parallelization automatically
</Info>

## Understanding the Paradigm Shift

Before diving into code, it's essential to understand the fundamental architectural differences between Solana and EVM-based chains like Sei.

### Execution Model Comparison

| Aspect                  | Solana                                        | Sei EVM                                   |
| ----------------------- | --------------------------------------------- | ----------------------------------------- |
| Language                | Rust (with Anchor framework)                  | Solidity                                  |
| Account Model           | Programs + Accounts (separated code and data) | Contracts (code and storage unified)      |
| State Storage           | Flat account data with owner programs         | Contract storage slots (key-value)        |
| Parallelization         | Explicit (declare accounts upfront)           | Optimistic (automatic conflict detection) |
| Block Time              | \~400ms                                       | 400ms                                     |
| Finality                | \~2.5-4.5 seconds (32 confirmations)          | Instant (single block)                    |
| Fee Model               | Compute units + priority fees + rent          | Gas × Gas Price (no rent)                 |
| Cross-Contract Calls    | CPI (Cross-Program Invocation)                | Internal/External function calls          |
| Deterministic Addresses | PDAs (Program Derived Addresses)              | CREATE2 / ImmutableCreate2Factory         |
| Token Standard          | SPL Token                                     | ERC-20 / ERC-721 / ERC-1155               |
| Dev Tooling             | Anchor, Solana CLI, solana-web3.js            | Hardhat, Foundry, ethers.js, viem         |

## Core Concept Mapping

### Programs → Smart Contracts

On Solana, you write **programs** that are stateless executables. Data lives in separate **accounts** that programs can read and modify. On Sei EVM, **smart contracts** combine code and state in a single entity.

<Tabs>
  <Tab title="Solana (Anchor)">
    ```rust theme={"dark"}
    // Solana: Program is stateless, data in accounts
    #[program]
    pub mod counter {
        use super::*;

        pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
            let counter = &mut ctx.accounts.counter;
            counter.count = 0;
            counter.authority = ctx.accounts.authority.key();
            Ok(())
        }

        pub fn increment(ctx: Context<Increment>) -> Result<()> {
            let counter = &mut ctx.accounts.counter;
            counter.count += 1;
            Ok(())
        }
    }

    #[account]
    pub struct Counter {
        pub count: u64,
        pub authority: Pubkey,
    }

    #[derive(Accounts)]
    pub struct Initialize<'info> {
        #[account(init, payer = authority, space = 8 + 8 + 32)]
        pub counter: Account<'info, Counter>,
        #[account(mut)]
        pub authority: Signer<'info>,
        pub system_program: Program<'info, System>,
    }
    ```
  </Tab>

  <Tab title="Sei EVM (Solidity)">
    ```solidity theme={"dark"}
    // Sei EVM: Contract holds both code and state
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    contract Counter {
        uint256 public count;
        address public authority;

        constructor() {
            count = 0;
            authority = msg.sender;
        }

        function increment() external {
            count += 1;
        }
    }
    ```
  </Tab>
</Tabs>

**Key differences:**

* No account space allocation needed—storage grows dynamically
* No explicit `Signer` validation—`msg.sender` is always authenticated
* No system program imports—native operations are built into the EVM

### PDAs → CREATE2 Deterministic Addresses

Solana's **Program Derived Addresses (PDAs)** let you create deterministic addresses from seeds. On EVM, you achieve similar functionality with `CREATE2`.

<Tabs>
  <Tab title="Solana PDA">
    ```rust theme={"dark"}
    // Solana: PDA derivation
    let (pda, bump) = Pubkey::find_program_address(
        &[
            b"vault",
            user.key().as_ref(),
        ],
        &program_id,
    );

    // In Anchor account validation
    #[account(
        seeds = [b"vault", user.key().as_ref()],
        bump,
    )]
    pub vault: Account<'info, Vault>,
    ```
  </Tab>

  <Tab title="Sei EVM CREATE2">
    ```solidity theme={"dark"}
    // Sei EVM: CREATE2 for deterministic addresses
    // Using ImmutableCreate2Factory at 0x0000000000FFe8B47B3e2130213B802212439497

    function computeAddress(
        bytes32 salt,
        bytes32 bytecodeHash
    ) public view returns (address) {
        return address(uint160(uint256(keccak256(abi.encodePacked(
            bytes1(0xff),
            address(this),
            salt,
            bytecodeHash
        )))));
    }

    // Or use a mapping pattern for user-specific data
    mapping(address => Vault) public vaults;
    ```
  </Tab>
</Tabs>

### CPI → Contract Calls

Solana's **Cross-Program Invocation (CPI)** becomes simple function calls in Solidity:

<Tabs>
  <Tab title="Solana CPI">
    ```rust theme={"dark"}
    // Solana: CPI to token program
    use anchor_spl::token::{self, Transfer};

    let cpi_accounts = Transfer {
        from: ctx.accounts.from_token_account.to_account_info(),
        to: ctx.accounts.to_token_account.to_account_info(),
        authority: ctx.accounts.authority.to_account_info(),
    };
    let cpi_program = ctx.accounts.token_program.to_account_info();
    let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);

    token::transfer(cpi_ctx, amount)?;
    ```
  </Tab>

  <Tab title="Sei EVM Contract Call">
    ```solidity theme={"dark"}
    // Sei EVM: Direct contract call
    import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

    function transferTokens(
        address token,
        address to,
        uint256 amount
    ) external {
        // Direct interface call - no account setup needed
        IERC20(token).transferFrom(msg.sender, to, amount);
    }
    ```
  </Tab>
</Tabs>

### SPL Token → ERC-20

<Tabs>
  <Tab title="SPL Token (Rust)">
    ```rust theme={"dark"}
    // Solana SPL Token - requires token accounts
    #[derive(Accounts)]
    pub struct TransferTokens<'info> {
        #[account(mut)]
        pub from: Account<'info, TokenAccount>,
        #[account(mut)]
        pub to: Account<'info, TokenAccount>,
        pub authority: Signer<'info>,
        pub token_program: Program<'info, Token>,
    }
    ```
  </Tab>

  <Tab title="ERC-20 (Solidity)">
    ```solidity theme={"dark"}
    // Sei EVM ERC-20 - balances stored in contract
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

    contract MyToken is ERC20 {
        constructor() ERC20("MyToken", "MTK") {
            _mint(msg.sender, 1000000 * 10**18);
        }
    }
    ```
  </Tab>
</Tabs>

**Key ERC-20 differences from SPL:**

* No Associated Token Accounts (ATAs)—balances are stored directly in the contract
* Approvals use `approve()` / `transferFrom()` pattern
* No mint/freeze authorities in basic implementation (add via `Ownable`)

## Fee Model Translation

Understanding the fee differences is crucial for accurate cost estimation:

| Solana Concept     | Sei EVM Equivalent | Notes                                 |
| ------------------ | ------------------ | ------------------------------------- |
| Compute Units (CU) | Gas                | Both measure computational work       |
| Priority Fee       | Gas Price          | Higher price = faster inclusion       |
| Rent               | None               | Sei has no rent; storage is permanent |
| Rent Exemption     | N/A                | No minimum balance requirements       |
| Base Fee           | Dynamic Base Fee   | Sei doesn't burn base fee             |

```ts theme={"dark"}
// Solana fee estimation
const computeUnits = 200_000;
const priorityFee = 1_000; // microlamports per CU
const rentExempt = await connection.getMinimumBalanceForRentExemption(accountSize);

// Sei EVM fee estimation
const gasLimit = 200_000n;
const gasPrice = await provider.getGasPrice(); // ~50–55 gwei on Sei (mainnet floor is 50 gwei)
const fee = gasLimit * gasPrice; // No rent to consider
```

<Info>
  **No Rent on Sei!**

  Unlike Solana where accounts can be garbage collected if rent isn't paid, Sei EVM storage is permanent. This simplifies your application logic—no need to track rent-exempt minimums or worry about account closure.
</Info>

## Parallelization: Automatic vs Explicit

One of the biggest advantages of Sei for Solana developers is that parallelization is **automatic**.

### Solana: Explicit Account Declaration

On Solana, you must declare all accounts a transaction will touch upfront:

```rust theme={"dark"}
// Solana: Must declare all accounts for parallelization
#[derive(Accounts)]
pub struct Swap<'info> {
    #[account(mut)]
    pub user_token_a: Account<'info, TokenAccount>,
    #[account(mut)]
    pub user_token_b: Account<'info, TokenAccount>,
    #[account(mut)]
    pub pool_token_a: Account<'info, TokenAccount>,
    #[account(mut)]
    pub pool_token_b: Account<'info, TokenAccount>,
    #[account(mut)]
    pub pool_state: Account<'info, PoolState>,
    // ... more accounts
}
```

### Sei: Optimistic Parallelization

On Sei, you write normal Solidity—the runtime handles parallelization:

```solidity theme={"dark"}
// Sei EVM: Just write normal code
function swap(
    address tokenIn,
    address tokenOut,
    uint256 amountIn
) external returns (uint256 amountOut) {
    // Sei's parallelization engine automatically:
    // 1. Estimates which storage slots will be accessed
    // 2. Runs non-conflicting transactions in parallel
    // 3. Re-executes conflicts sequentially

    IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);
    amountOut = calculateOutput(amountIn);
    IERC20(tokenOut).transfer(msg.sender, amountOut);
}
```

<Warning>
  **Optimizing for Parallelization**

  While Sei handles parallelization automatically, you can still optimize your contracts for better parallel performance. Avoid global counters updated on every transaction—use user-partitioned storage instead. See [Optimizing for Parallelization](/evm/best-practices/optimizing-for-parallelization) for detailed patterns.
</Warning>

## Step 1: Set Up Your Development Environment

### Install Required Tools

```bash theme={"dark"}
# Install Node.js (if not already installed)
# https://nodejs.org/

# Install Hardhat (recommended for Solana devs transitioning)
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox-mocha-ethers

# Or install Foundry (Rust-based, may feel more familiar)
curl -L https://foundry.paradigm.xyz | bash
foundryup
```

### Configure for Sei

<Tabs>
  <Tab title="Hardhat">
    ```ts title="hardhat.config.ts" theme={"dark"}
    import { defineConfig, configVariable } from 'hardhat/config';
    import hardhatToolboxMochaEthers from '@nomicfoundation/hardhat-toolbox-mocha-ethers';

    export default defineConfig({
      solidity: '0.8.22',
      networks: {
        seiMainnet: {
          type: 'http',
          chainId: 1329,
          url: 'https://evm-rpc.sei-apis.com',
          accounts: [configVariable('SEI_PRIVATE_KEY')]
        },
        seiTestnet: {
          type: 'http',
          chainId: 1328,
          url: 'https://evm-rpc-testnet.sei-apis.com',
          accounts: [configVariable('SEI_PRIVATE_KEY')]
        }
      },
      plugins: [hardhatToolboxMochaEthers]
    });
    ```

    Store your deployer key in Hardhat's encrypted keystore (no plaintext `.env` file needed):

    ```bash theme={"dark"}
    npx hardhat keystore set SEI_PRIVATE_KEY
    ```
  </Tab>

  <Tab title="Foundry">
    ```toml title="foundry.toml" theme={"dark"}
    [profile.default]
    src = "src"
    out = "out"
    libs = ["lib"]
    solc_version = "0.8.22"

    [rpc_endpoints]
    sei_mainnet = "https://evm-rpc.sei-apis.com"
    sei_testnet = "https://evm-rpc-testnet.sei-apis.com"

    # Verification uses Sourcify (no API key needed)
    # Run: forge verify-contract --verifier sourcify --chain-id <CHAIN_ID> <ADDRESS> <PATH:CONTRACT>
    ```
  </Tab>
</Tabs>

### Wallet Setup

Configure MetaMask or any EVM wallet with Sei:

```ts theme={"dark"}
const seiMainnet = {
  chainId: '0x531', // 1329 in hex
  chainName: 'Sei',
  nativeCurrency: { name: 'Sei', symbol: 'SEI', decimals: 18 },
  rpcUrls: ['https://evm-rpc.sei-apis.com'],
  blockExplorerUrls: ['https://seiscan.io']
};
```

## Step 2: Translate Your Solana Program

### Common Pattern Translations

#### Initializing State

<Tabs>
  <Tab title="Solana">
    ```rust theme={"dark"}
    pub fn initialize(ctx: Context<Initialize>, initial_value: u64) -> Result<()> {
        let state = &mut ctx.accounts.state;
        state.value = initial_value;
        state.authority = ctx.accounts.authority.key();
        state.bump = ctx.bumps.state;
        Ok(())
    }

    #[account]
    pub struct State {
        pub value: u64,
        pub authority: Pubkey,
        pub bump: u8,
    }
    ```
  </Tab>

  <Tab title="Sei EVM">
    ```solidity theme={"dark"}
    contract MyContract {
        uint256 public value;
        address public authority;

        constructor(uint256 initialValue) {
            value = initialValue;
            authority = msg.sender;
        }
    }
    ```
  </Tab>
</Tabs>

#### Access Control

<Tabs>
  <Tab title="Solana">
    ```rust theme={"dark"}
    // Solana: Check signer matches authority
    pub fn restricted_action(ctx: Context<RestrictedAction>) -> Result<()> {
        require!(
            ctx.accounts.authority.key() == ctx.accounts.state.authority,
            ErrorCode::Unauthorized
        );
        // ... action
        Ok(())
    }

    #[derive(Accounts)]
    pub struct RestrictedAction<'info> {
        #[account(mut)]
        pub state: Account<'info, State>,
        pub authority: Signer<'info>,
    }
    ```
  </Tab>

  <Tab title="Sei EVM">
    ```solidity theme={"dark"}
    // Sei EVM: Use modifier pattern
    import "@openzeppelin/contracts/access/Ownable.sol";

    contract MyContract is Ownable {
        constructor() Ownable(msg.sender) {}

        function restrictedAction() external onlyOwner {
            // ... action
        }
    }

    // Or manual check
    contract MyContract {
        address public authority;

        modifier onlyAuthority() {
            require(msg.sender == authority, "Unauthorized");
            _;
        }

        function restrictedAction() external onlyAuthority {
            // ... action
        }
    }
    ```
  </Tab>
</Tabs>

#### Error Handling

<Tabs>
  <Tab title="Solana">
    ```rust theme={"dark"}
    // Solana: Custom error enum
    #[error_code]
    pub enum ErrorCode {
        #[msg("Insufficient balance")]
        InsufficientBalance,
        #[msg("Invalid amount")]
        InvalidAmount,
        #[msg("Unauthorized")]
        Unauthorized,
    }

    // Usage
    require!(amount > 0, ErrorCode::InvalidAmount);
    ```
  </Tab>

  <Tab title="Sei EVM">
    ```solidity theme={"dark"}
    // Sei EVM: Custom errors (gas efficient)
    error InsufficientBalance(uint256 available, uint256 required);
    error InvalidAmount();
    error Unauthorized();

    // Usage
    if (amount == 0) revert InvalidAmount();
    if (balance < required) revert InsufficientBalance(balance, required);
    ```
  </Tab>
</Tabs>

#### Events/Logs

<Tabs>
  <Tab title="Solana">
    ```rust theme={"dark"}
    // Solana: Emit event macro
    use anchor_lang::prelude::*;

    #[event]
    pub struct TransferEvent {
        pub from: Pubkey,
        pub to: Pubkey,
        pub amount: u64,
    }

    // Emit
    emit!(TransferEvent {
        from: ctx.accounts.from.key(),
        to: ctx.accounts.to.key(),
        amount,
    });
    ```
  </Tab>

  <Tab title="Sei EVM">
    ```solidity theme={"dark"}
    // Sei EVM: Event declaration and emission
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 amount
    );

    // Emit
    emit Transfer(from, to, amount);
    ```
  </Tab>
</Tabs>

## Step 3: Frontend Migration

### SDK Comparison

| Solana                   | Sei EVM                   | Notes                          |
| ------------------------ | ------------------------- | ------------------------------ |
| `@solana/web3.js`        | `ethers.js` / `viem`      | Core blockchain interaction    |
| `@coral-xyz/anchor`      | `typechain`               | Type-safe contract interaction |
| `@solana/wallet-adapter` | `wagmi` / `RainbowKit`    | Wallet connection              |
| Phantom, Solflare        | MetaMask, Rabby, Backpack | Popular wallets                |

### Code Translation

<Tabs>
  <Tab title="Solana (web3.js)">
    ```ts theme={"dark"}
    import { Connection, PublicKey } from '@solana/web3.js';
    import { Program, AnchorProvider } from '@coral-xyz/anchor';

    // Connect
    const connection = new Connection('https://api.mainnet-beta.solana.com');
    const provider = new AnchorProvider(connection, wallet, {});
    const program = new Program(idl, programId, provider);

    // Read state
    const state = await program.account.state.fetch(stateAddress);

    // Send transaction
    const tx = await program.methods
      .increment()
      .accounts({
        state: stateAddress,
        authority: wallet.publicKey
      })
      .rpc();
    ```
  </Tab>

  <Tab title="Sei EVM (ethers.js)">
    ```ts theme={"dark"}
    import { ethers } from 'ethers';

    // Connect
    const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
    const signer = new ethers.Wallet(privateKey, provider);
    const contract = new ethers.Contract(contractAddress, abi, signer);

    // Read state
    const value = await contract.value();

    // Send transaction
    const tx = await contract.increment();
    await tx.wait();
    ```
  </Tab>
</Tabs>

## Step 4: Testing Your Migrated Code

### Test Framework Comparison

<Tabs>
  <Tab title="Anchor Tests">
    ```ts theme={"dark"}
    import * as anchor from '@coral-xyz/anchor';
    import { Program } from '@coral-xyz/anchor';
    import { Counter } from '../target/types/counter';

    describe('counter', () => {
      const provider = anchor.AnchorProvider.env();
      anchor.setProvider(provider);
      const program = anchor.workspace.Counter as Program<Counter>;

      it('Initializes', async () => {
        const counter = anchor.web3.Keypair.generate();
        await program.methods.initialize().accounts({ counter: counter.publicKey }).signers([counter]).rpc();

        const account = await program.account.counter.fetch(counter.publicKey);
        expect(account.count.toNumber()).to.equal(0);
      });
    });
    ```
  </Tab>

  <Tab title="Hardhat Tests">
    ```ts theme={"dark"}
    import { expect } from 'chai';
    import { network } from 'hardhat';

    // Hardhat 3 exposes ethers through a network connection rather than a global import
    const { ethers } = await network.create();

    describe('Counter', function () {
      it('Initializes', async function () {
        const Counter = await ethers.getContractFactory('Counter');
        const counter = await Counter.deploy();

        expect(await counter.count()).to.equal(0);
      });

      it('Increments', async function () {
        const Counter = await ethers.getContractFactory('Counter');
        const counter = await Counter.deploy();

        await counter.increment();
        expect(await counter.count()).to.equal(1);
      });
    });
    ```
  </Tab>
</Tabs>

## Step 5: Deploy and Verify

### Deploy to Testnet

```bash theme={"dark"}
# Hardhat
npx hardhat run scripts/deploy.ts --network seiTestnet

# Foundry
forge create --rpc-url https://evm-rpc-testnet.sei-apis.com \
  --private-key $PRIVATE_KEY \
  src/Counter.sol:Counter
```

### Verify Contract

```bash theme={"dark"}
# Hardhat
npx hardhat verify --network seiTestnet <CONTRACT_ADDRESS>

# Foundry
forge verify-contract \
  --chain-id 1328 \
  --verifier sourcify \
  <CONTRACT_ADDRESS> \
  src/Counter.sol:Counter
```

## Common Migration Pitfalls

### 1. Expecting Rent

```solidity theme={"dark"}
// ❌ Wrong: No need to check rent exemption
require(address(this).balance >= rentExempt, "Not rent exempt");

// ✅ Correct: Just use the contract normally
// Storage persists without rent payments
```

### 2. Manual Account Validation

```solidity theme={"dark"}
// ❌ Wrong: Over-engineering account checks (Solana habit)
require(accountOwner == expectedOwner, "Invalid account owner");

// ✅ Correct: EVM handles this via contract addresses
// msg.sender is already authenticated
```

### 3. Expecting Explicit Parallelization

```solidity theme={"dark"}
// ❌ Wrong: Trying to declare "accounts" for parallelization
function swap(address[] memory accounts) external { ... }

// ✅ Correct: Write normal code, Sei handles parallelization
function swap(address tokenIn, address tokenOut, uint256 amount) external { ... }
```

### 4. Using Lamports Mental Model

```solidity theme={"dark"}
// ❌ Wrong: Solana-style lamports
uint256 amount = 1_000_000_000; // 1 SOL in lamports

// ✅ Correct: Use wei (18 decimals for SEI)
uint256 amount = 1 ether; // 1 SEI = 1e18 wei
uint256 amount = 1e18;    // Same thing
```

## Ecosystem Infrastructure

### Available on Sei

| Component       | Solana Equivalent         | Sei Address/Info                                                                                          |
| --------------- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
| Multicall3      | N/A                       | `0xcA11bde05977b3631167028862bE2a173976CA11`                                                              |
| Permit2         | N/A                       | `0xB952578f3520EE8Ea45b7914994dcf4702cEe578`                                                              |
| CREATE2 Factory | N/A                       | `0x0000000000FFe8B47B3e2130213B802212439497`                                                              |
| Oracle          | Pyth Network, Switchboard | [Pyth](/evm/oracles/pyth-network), [Redstone](/evm/oracles/redstone), [Chainlink](/evm/oracles/chainlink) |
| Bridge          | Wormhole                  | [LayerZero](/evm/bridging/layerzero), Wormhole, many more..                                               |

## Helpful Resources

### Learning Solidity

* [EVM with Foundry](/evm/evm-foundry) – Foundry setup guide and starter tutorial
* [EVM with Hardhat](/evm/evm-hardhat) – Hardhat setup guide and starter tutorial
* [Solidity Resources](/evm/solidity-resources) – Curated solidity learning resources
* [CryptoZombies](https://cryptozombies.io) – Interactive Solidity tutorial
* [Solidity by Example](https://solidity-by-example.org) – Pattern reference

### Sei-Specific

* [Divergence from Ethereum](/evm/differences-with-ethereum) – Technical differences
* [Optimizing for Parallelization](/evm/best-practices/optimizing-for-parallelization) – Performance patterns
* [Ecosystem Contracts](/evm/ecosystem-contracts) – Canonical addresses

<Info>
  **Need Help?**

  Join the [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk) on Telegram for developer support. The community is active and helpful for migration questions.
</Info>

---

URL: https://docs.sei.io/evm/installing-seid-cli

# Installing seid CLI

> Complete guide to installing and setting up the Sei CLI (seid) tool, including wallet creation, EVM imports, and troubleshooting common installation issues.

export const VersionTable = () => {
  const networks = [{
    label: 'Mainnet',
    chainId: 'pacific-1',
    rpcEndpoint: 'https://rpc.sei-apis.com',
    evmChainId: '1329'
  }, {
    label: 'Testnet',
    chainId: 'atlantic-2',
    rpcEndpoint: 'https://rpc-testnet.sei-apis.com',
    evmChainId: '1328'
  }];
  const [versions, setVersions] = useState({});
  useEffect(() => {
    const oneHour = 3600000;
    const setVersionFor = (chainId, version) => {
      setVersions(prev => ({
        ...prev,
        [chainId]: version
      }));
    };
    const fetchVersion = async (chainId, rpcEndpoint) => {
      try {
        const response = await fetch(`${rpcEndpoint}/abci_info`);
        const data = await response.json();
        const info = data && data.result && data.result.response || data && data.response || ({});
        const version = info.version;
        if (typeof version === 'string' && version) {
          setVersionFor(chainId, version);
          localStorage.setItem(`${chainId}-version`, version);
          localStorage.setItem(`${chainId}-version-timestamp`, Date.now().toString());
          return;
        }
        throw new Error('abci_info response had no version field');
      } catch (error) {
        console.error('Error fetching version:', error);
        if (!localStorage.getItem(`${chainId}-version`)) {
          setVersionFor(chainId, 'Unavailable');
        }
      }
    };
    networks.forEach(({chainId, rpcEndpoint}) => {
      const storedVersion = localStorage.getItem(`${chainId}-version`);
      const storedTimestamp = localStorage.getItem(`${chainId}-version-timestamp`);
      const isFresh = storedVersion && storedTimestamp && Date.now() - parseInt(storedTimestamp, 10) < oneHour;
      if (storedVersion) {
        setVersionFor(chainId, storedVersion);
      }
      if (!isFresh) {
        fetchVersion(chainId, rpcEndpoint);
      }
    });
  }, []);
  return <table className="min-w-full divide-y divide-neutral-200 dark:divide-neutral-800">
      <thead className="bg-neutral-50 dark:bg-neutral-900/50">
        <tr>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">Network</th>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">Version</th>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">Chain ID</th>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">EVM Chain ID</th>
        </tr>
      </thead>
      <tbody className="divide-y divide-neutral-200 dark:divide-neutral-800 bg-neutral-50 dark:bg-neutral-900/30">
        {networks.map(({label, chainId, evmChainId}) => <tr key={chainId}>
            <td className="px-4 py-3 text-sm font-medium text-neutral-900 dark:text-neutral-100">{label}</td>
            <td className="px-4 py-3 text-sm text-neutral-600 dark:text-neutral-400">
              <code style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>{versions[chainId] || 'Fetching...'}</code>
            </td>
            <td className="px-4 py-3 text-sm text-neutral-600 dark:text-neutral-400">{chainId}</td>
            <td className="px-4 py-3 text-sm text-neutral-600 dark:text-neutral-400">{evmChainId}</td>
          </tr>)}
      </tbody>
    </table>;
};

## What is seid CLI?

The `seid` CLI is the command-line tool for interacting with the Sei blockchain. It allows you to manage wallets, send transactions, query network data, and perform validator operations.

## Prerequisites

* Go 1.23+: Installation instructions are available [here](https://go.dev/doc/install).

## Installation

To install seid, locate the version you wish to use on the [sei-chain releases page](https://github.com/sei-protocol/sei-chain/releases). A list of the currently used versions on mainnet and testnet are displayed right below.

<VersionTable />

Then, execute the following commands with the version that you picked:

```bash theme={"dark"}
git clone https://github.com/sei-protocol/sei-chain
cd sei-chain
git checkout [VERSION]
make install
```

You can verify that seid was installed correctly by running:

```bash theme={"dark"}
seid version
```

## Troubleshooting Installation

<Warning>If you encounter an error like `command not found: seid`, you may need to set your GOPATH environment variable.</Warning>

* Use `go env GOPATH` to find your GOPATH
* Add the following lines to your `~/.bashrc` or `~/.zshrc`:

```bash theme={"dark"}
export GOPATH=[your GOPATH from step 1]
export PATH=$PATH:$GOPATH/bin
```

For more information see [here](https://pkg.go.dev/cmd/go#hdr-GOPATH_environment_variable).

## Command Overview

Seid supports all the commands you need to interact with the chain. To see a list of available commands and explanations of what they do, run seid:

```bash theme={"dark"}
seid
Start sei app

Usage:
  seid [command]

Available Commands:
  add-genesis-account      Add a genesis account to genesis.json
  add-wasm-genesis-message Wasm genesis subcommands
  blocktest                run EF blocktest
  collect-gentxs           Collect genesis txs and output a genesis.json file
  compact                  Compact the application DB fully (only if it is a levelDB)
  config                   Create or query an application CLI configuration file
  debug                    Tool for helping with debugging your application
  ethreplay                replay EVM transactions
  export                   Export state to JSON
  gentx                    Generate a genesis tx carrying a self delegation
  help                     Help about any command
  init                     Initialize private validator, p2p, genesis, and application configuration files
  keys                     Manage your application's keys
  latest_version           Prints the latest version of the app DB
  migrate                  Migrate genesis to a specified target version
  prune                    Prune app history states by keeping the recent heights and deleting old heights
  query                    Querying subcommands
  rollback                 rollback cosmos-sdk and tendermint state by one height
  start                    Run the full node
  status                   Query remote node for status
  tendermint               Tendermint subcommands
  tools                    A set of useful tools for sei chain
  tx                       Transactions subcommands
  validate-genesis         validates the genesis file at the default location or at the location passed as an arg
  version                  Print the application binary version information

Flags:
  -h, --help                help for seid
      --home string         directory for config and data (default "~/.sei")
      --log_format string   The logging format (json|plain)
      --log_level string    The logging level (trace|debug|info|warn|error|fatal|panic)
      --trace               print out full stack trace on errors

Use "seid [command] --help" for more information about a command.
```

## Adding a Wallet

You can create a new wallet using the seid keys command:

```bash theme={"dark"}
seid keys add $NAME
```

Output:

```bash theme={"dark"}
- name: [YOUR_KEY_NAME]
  type: local
  address: sei1[GENERATED_ADDRESS]
  evm_address: ""
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"[PUBLIC_KEY]"}'
  mnemonic: ""

**Important** write this mnemonic phrase in a safe place.
It is the only way to recover your account if you ever forget your password.

[YOUR_24_WORD_MNEMONIC_PHRASE]

```

<Info>Please replace `$NAME` with the name you would like to use for this key. This will generate a seed phrase and store the account in the CLI for use.</Info>

<Danger>**Important**: Write this mnemonic down and store it in a safe place. Never share your seed phrase with anyone.</Danger>

Alternatively, if you would like to import an existing seed phrase, you can add the `--recover` flag:

```bash theme={"dark"}
seid keys add $NAME --recover
```

Output:

This will prompt you to enter your seed phrase, allowing you to import an existing wallet into the CLI.

```bash theme={"dark"}
> Enter your bip39 mnemonic
[ENTER_YOUR_EXISTING_MNEMONIC_PHRASE_HERE]

- name: [YOUR_WALLET_NAME]
  type: local
  address: sei1[RECOVERED_ADDRESS]
  evm_address: ""
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"[PUBLIC_KEY]"}'
  mnemonic: ""
```

## EVM Wallet Compatibility

### Understanding Coin Types

Sei supports two coin types:

* Coin type 118 (default): Standard Cosmos address format
* Coin type 60: Ethereum-compatible address format for EVM wallets

### Creating an EVM-Compatible Wallet

To create a new wallet that's compatible with EVM wallets like MetaMask:

```bash theme={"dark"}
seid keys add $NAME --coin-type=60
```

Output:

```bash theme={"dark"}
- name: [YOUR_KEY_NAME]
  type: local
  address: sei1[GENERATED_ADDRESS]
  evm_address: ""
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"[PUBLIC_KEY]"}'
  mnemonic: ""

**Important** write this mnemonic phrase in a safe place.
It is the only way to recover your account if you ever forget your password.

[YOUR_24_WORD_MNEMONIC_PHRASE]

```

<Info>`evm_address` is shown as empty here because it's only displayed after the key first broadcasts a transaction or is associated on-chain. The `0x` address is deterministically derived from the secp256k1 public key.</Info>

### Importing an Existing EVM Wallet

To import an existing wallet from MetaMask or other EVM wallets:

```bash theme={"dark"}
seid keys add $NAME --coin-type=60 --recover
```

Output:

```bash theme={"dark"}
> Enter your bip39 mnemonic
> [ENTER_YOUR_EXISTING_MNEMONIC_PHRASE_HERE]

- name: [YOUR_WALLET_NAME]
  type: local
  address: sei1[RECOVERED_ADDRESS]
  evm_address: ""
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"[PUBLIC_KEY]"}'
  mnemonic: ""
```

You'll be prompted to enter your existing 12 or 24-word mnemonic phrase.

<Info>Use coin type 60 when you want to use the same address across EVM-compatible chains or import from MetaMask. Use the default coin type 118 for standard Cosmos operations.</Info>

## Managing Wallets

To see your local wallets, you can run:

```bash theme={"dark"}
seid keys list
```

Output:

```bash theme={"dark"}
- name: [YOUR_WALLET_NAME]
  type: local
  address: sei1[WALLET_ADDRESS]
  evm_address: [EVM_ADDRESS]
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"[PUBLIC_KEY]"}'
  mnemonic: ""
  ...
```

to see a list of all wallets added, or

```bash theme={"dark"}
seid keys show $NAME
```

Output:

```bash theme={"dark"}
- name: [YOUR_WALLET_NAME]
  type: local
  address: sei1[WALLET_ADDRESS]
  evm_address: [EVM_ADDRESS]
  pubkey: '{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"[PUBLIC_KEY]"}'
  mnemonic: ""
```

to see details about a specific wallet.

## Deleting Wallets

To delete a wallet/key, you can use the following command:

```bash theme={"dark"}
seid keys delete $NAME
```

Output:

```bash theme={"dark"}
Key reference will be deleted. Continue? [y/N]: y
Key deleted forever (uh oh!)
```

This will remove the specified wallet from your local keyring. Be cautious, as this action cannot be undone.

## Uninstalling seid

If you need to remove `seid` from your system, you can delete the binary from your `$GOPATH/bin` directory:

```bash theme={"dark"}
rm $(go env GOPATH)/bin/seid
```

---

URL: https://docs.sei.io/evm/querying-the-evm

# Querying the EVM

> Read EVM state from the seid CLI: address associations, ERC20 reads, ABI-encoded payloads, and transaction details.

The `seid q evm` subcommands let you read EVM state — token data, address associations, and transactions — without sending a transaction or running your own node.

## Prerequisites

If your machine is **not running a Sei node**, append the `--node` flag to every `seid q evm` command, pointing at a Sei Cosmos RPC endpoint (the same kind used by `seid status`):

```bash theme={"dark"}
--node https://<sei-cosmos-rpc-url>
```

The one exception is `seid q evm tx`, which uses `--evm-rpc` to point at an EVM JSON-RPC endpoint (port 8545 by convention). See [Transaction Lookup](#transaction-lookup) below.

<Info>Refer to the [RPC endpoints](/evm/networks) page for a list of available RPC endpoints.</Info>

<Info>
  **Output format.** Most commands print YAML by default. Pass `-o json` for JSON. ERC20 read methods (`name`, `balanceOf`, …) return a bare value with no formatting — the result below is the raw stdout.
</Info>

## Address Mapping

Sei addresses (`sei1…`) and EVM addresses (`0x…`) are linked via an on-chain association set the first time an account signs an EVM transaction or calls the address-association precompile. Until then, the two address spaces are independent.

### Get Sei Address from EVM Address

```bash theme={"dark"}
seid q evm sei-addr [evm address]
```

**Example:**

```bash theme={"dark"}
seid q evm sei-addr 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55
```

**Output:**

```yaml theme={"dark"}
associated: true
sei_address: sei13ytysxs88z0fp9cssagg77ekpecrrlrwce9pwl
```

### Get EVM Address from Sei Address

```bash theme={"dark"}
seid q evm evm-addr [sei address]
```

**Example:**

```bash theme={"dark"}
seid q evm evm-addr sei13ytysxs88z0fp9cssagg77ekpecrrlrwce9pwl
```

**Output:**

```yaml theme={"dark"}
associated: true
evm_address: 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55
```

<Info>If the account hasn't been associated yet, `associated` is `false` and the other field is empty. This is normal for accounts that have only ever transacted on one side of the chain.</Info>

## ERC20 Contract Queries

Call standard view methods on any ERC20 contract:

```bash theme={"dark"}
seid q evm erc20 [contract address] [method] [arguments...]
```

**Example — query Wrapped Sei (`WSEI`):**

```bash theme={"dark"}
seid q evm erc20 0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7 symbol
```

**Output:**

```
WSEI
```

**Example — balance:**

```bash theme={"dark"}
seid q evm erc20 0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7 balanceOf 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55
```

**Output (raw integer, in smallest unit):**

```
0
```

<Info>
  **Supported methods:**

  * `name` — token name
  * `symbol` — token symbol
  * `decimals` — token decimals
  * `totalSupply` — total supply
  * `balanceOf [address]` — balance of an address
  * `allowance [owner] [spender]` — current allowance

  For arbitrary methods or non-standard contracts, use [`payload`](#custom-abi) with the contract ABI.
</Info>

## Payload Generation

Generate ABI-encoded call data without sending a transaction. Useful for crafting `seid tx evm call-contract` calls or inspecting expected calldata.

<Tabs>
  <Tab title="ERC20">
    ### ERC20 Payload Generation

    ```bash theme={"dark"}
    seid q evm erc20-payload [method] [arguments...]
    ```

    **Transfer tokens (1 token, 18 decimals):**

    ```bash theme={"dark"}
    seid q evm erc20-payload transfer 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55 1000000000000000000
    ```

    **Output:**

    ```
    a9059cbb000000000000000000000000da52b9e673d1f48fcd9916b3f606a136a8ea5e550000000000000000000000000000000000000000000000000de0b6b3a7640000
    ```

    **Approve spender:**

    ```bash theme={"dark"}
    seid q evm erc20-payload approve 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55 2000000000000000000
    ```

    **Output:**

    ```
    095ea7b3000000000000000000000000da52b9e673d1f48fcd9916b3f606a136a8ea5e550000000000000000000000000000000000000000000000001bc16d674ec80000
    ```

    **Transfer from (pulls tokens from `from` to `to`, using a prior `approve`):**

    ```bash theme={"dark"}
    seid q evm erc20-payload transferFrom 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55 0xdEAD000000000000000042069420694206942069 1500000000000000000
    ```

    **Output:**

    ```
    23b872dd000000000000000000000000da52b9e673d1f48fcd9916b3f606a136a8ea5e55000000000000000000000000dead00000000000000004206942069420694206900000000000000000000000000000000000000000000000014d1120d7b160000
    ```

    <Info>
      **Supported methods:**

      * `transfer [to] [amount]`
      * `approve [spender] [amount]`
      * `transferFrom [from] [to] [amount]`

      Amounts are in the token's smallest unit (e.g., wei for an 18-decimal token; `1000000` for 1 USDC with 6 decimals).
    </Info>
  </Tab>

  <Tab title="ERC721">
    ### ERC721 Payload Generation

    ```bash theme={"dark"}
    seid q evm erc721-payload [method] [arguments...]
    ```

    **Approve a token ID:**

    ```bash theme={"dark"}
    seid q evm erc721-payload approve 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55 123
    ```

    **Output:**

    ```
    095ea7b3000000000000000000000000da52b9e673d1f48fcd9916b3f606a136a8ea5e55000000000000000000000000000000000000000000000000000000000000007b
    ```

    **Transfer a token:**

    ```bash theme={"dark"}
    seid q evm erc721-payload transferFrom 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55 0xdEAD000000000000000042069420694206942069 123
    ```

    **Output:**

    ```
    23b872dd000000000000000000000000da52b9e673d1f48fcd9916b3f606a136a8ea5e55000000000000000000000000dead000000000000000042069420694206942069000000000000000000000000000000000000000000000000000000000000007b
    ```

    **Set operator approval:**

    ```bash theme={"dark"}
    seid q evm erc721-payload setApprovalForAll 0xdEAD000000000000000042069420694206942069 true
    ```

    **Output:**

    ```
    a22cb465000000000000000000000000dead0000000000000000420694206942069420690000000000000000000000000000000000000000000000000000000000000001
    ```

    <Info>
      **Supported methods:**

      * `approve [spender] [tokenId]`
      * `transferFrom [from] [to] [tokenId]`
      * `setApprovalForAll [operator] [true|false]`
    </Info>
  </Tab>

  <Tab title="ERC1155">
    ### ERC1155 Payload Generation

    ```bash theme={"dark"}
    seid q evm erc1155-payload [method] [arguments...]
    ```

    **Safe transfer:**

    ```bash theme={"dark"}
    seid q evm erc1155-payload safeTransferFrom 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55 0xdEAD000000000000000042069420694206942069 123 5 0x
    ```

    **Output:**

    ```
    f242432a000000000000000000000000da52b9e673d1f48fcd9916b3f606a136a8ea5e55000000000000000000000000dead000000000000000042069420694206942069000000000000000000000000000000000000000000000000000000000000007b000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000023078000000000000000000000000000000000000000000000000000000000000
    ```

    **Safe batch transfer:**

    ```bash theme={"dark"}
    seid q evm erc1155-payload safeBatchTransferFrom 0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55 0xdEAD000000000000000042069420694206942069 "[123,456]" "[5,10]" 0x
    ```

    **Set operator approval:**

    ```bash theme={"dark"}
    seid q evm erc1155-payload setApprovalForAll 0xdEAD000000000000000042069420694206942069 true
    ```

    <Info>
      **Supported methods:**

      * `safeTransferFrom [from] [to] [tokenId] [amount] [data]`
      * `safeBatchTransferFrom [from] [to] [tokenIds] [amounts] [data]`
      * `setApprovalForAll [operator] [true|false]`

      For batch operations, pass arrays as quoted bracketed strings: `"[123,456]"`. The trailing `data` field is a hex string (use `0x` for empty).
    </Info>
  </Tab>

  <Tab title="Custom ABI">
    ### Custom ABI Payload Generation

    Encode a call against any contract by supplying its ABI:

    ```bash theme={"dark"}
    seid q evm payload [abi-filepath] [method] [arguments...]
    ```

    **Example:**

    ```bash theme={"dark"}
    seid q evm payload ./MyContract.json myMethod arg1 arg2
    ```

    <Info>
      The ABI file must be a JSON array of function definitions, in the same shape Hardhat/Foundry emit (the `abi` field of an artifact, not the whole artifact).
    </Info>
  </Tab>
</Tabs>

## Pointer System

Pointers bridge the EVM and CosmWasm sides of Sei: a CW20 can be exposed as an ERC20 (via an EVM pointer at a `0x` address) and an ERC20 can be exposed as a CW20 (via a CW pointer at a `sei1…` address). The same applies to NFTs (CW721/ERC721) and multi-token contracts (CW1155/ERC1155).

## Transaction Lookup

### Query Transaction by Hash

Equivalent to `eth_getTransactionByHash`:

```bash theme={"dark"}
seid q evm tx [hash] --evm-rpc [EVM RPC endpoint]
```

**Example:**

```bash theme={"dark"}
seid q evm tx 0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14 \
  --evm-rpc https://evm-rpc.sei-apis.com
```

**Output:**

```json theme={"dark"}
{
  "blockHash": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864",
  "blockNumber": "0xc5e1386",
  "from": "0xda52b9e673d1f48fcd9916b3f606a136a8ea5e55",
  "gas": "0x493e0",
  "gasPrice": "0xe1614bd00",
  "maxFeePerGas": "0xe1614bd00",
  "maxPriorityFeePerGas": "0xe1614bd00",
  "hash": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14",
  "input": "0x9cab5684...",
  "nonce": "0x0",
  "to": "0x7507454444fa193d39f1392076bc784b77a7a8ff",
  "transactionIndex": "0x0",
  "value": "0x0",
  "type": "0x2",
  "accessList": [],
  "chainId": "0x531",
  "v": "0x0",
  "r": "0x468ac709b74e666834bcc740e5156e019fd0ba40cff7f8a59a46f08bff56eb2b",
  "s": "0x3496458ec06b57315721cf5e6be810b9548744a5dafab1739b8fdcff23939939",
  "yParity": "0x0"
}
```

<Info>
  This is the only `seid q evm` command that takes `--evm-rpc` (an **EVM JSON-RPC** endpoint, typically port 8545) instead of `--node` (a Cosmos RPC). The default if you omit the flag is `http://0.0.0.0:8545`, which only works if you're running a local node. See [RPC endpoints](/evm/networks) for hosted EVM RPCs.
</Info>

## Common Use Cases

### Check Token Balance and Info

```bash theme={"dark"}
# Token metadata
seid q evm erc20 0xtoken... symbol
seid q evm erc20 0xtoken... decimals

# Balance (raw integer, in smallest unit)
seid q evm erc20 0xtoken... balanceOf 0xuser...
```

### Prepare and Send a Transaction

```bash theme={"dark"}
# 1. Encode the calldata
PAYLOAD=$(seid q evm erc20-payload transfer 0xrecipient... 1000000000000000000)

# 2. Send via seid
seid tx evm call-contract 0xtoken... $PAYLOAD --from mykey
```

---

URL: https://docs.sei.io/evm/transactions-with-seid

# Transactions with seid

> Complete guide to executing EVM transactions using the Sei CLI (seid). Learn how to send tokens, deploy contracts, and interact with smart contracts.

## Overview

EVM transactions on Sei allow you to interact with smart contracts, transfer tokens, deploy contracts, and manage various blockchain operations through the command line interface. This guide covers all available transaction types using the `seid` CLI, from basic token transfers to complex contract interactions and precompile calls.

## Prerequisites

Sending transactions via CLI requires you to have keys configured in your local keyring. You can then specify the key you want to use by appending `--from=[key name]` to your command.

If you don't already have keys configured, you'll need to either generate a new key or import an existing one into your local keyring. Refer to this guide on [how to create a key](/evm/installing-seid-cli) for more details.

## Network Configuration

If the machine you run these commands from are not a node of the network, you'd need to append the following to your commands:

```bash theme={"dark"}
--evm-rpc http://<sei-evm-rpc-url>
```

Refer to the [RPC endpoints](/evm/networks) page for the list of available RPC endpoints.

<Info>Most commands support `--evm-rpc` flag to specify custom RPC endpoints. The default is `http://localhost:8545`.</Info>

## Common Transaction Flags

All transaction commands support these common flags:

* `--from=<sender>` - Specifies the key name to use for signing
* `--gas-fee-cap=<cap>` - Gas fee cap for the transaction (default varies by command)
* `--gas-limit=<limit>` - Gas limit for the transaction (default varies by command)
* `--evm-rpc=<url>` - EVM RPC endpoint URL (default: `http://localhost:8545`)
* `--nonce=<nonce>` - Nonce override for the transaction (-1 means auto-calculate)

## Address Management Commands

### Associate Address

Associates the Sei address and EVM address on-chain for the sending key. This is required for cross-layer interactions.

```bash theme={"dark"}
seid tx evm associate-address [optional priv key hex] --from=<sender> --evm-rpc=<url>
```

**Parameters:**

* `[optional priv key hex]` - Optional private key in hex format. If not provided, uses the key from keyring.

**Example:**

```bash theme={"dark"}
seid tx evm associate-address --from=mykey --evm-rpc=http://localhost:8545
```

**Output :**

```
Response: {"jsonrpc":"2.0","result":null,"id":"associate_addr"}
```

## Token Transfer Commands

### Send Native Tokens

Sends native tokens (usei) to the target EVM address.

```bash theme={"dark"}
seid tx evm send [to EVM address] [amount in wei] --from=<sender> --gas-fee-cap=<cap> --gas-limit=<limit> --evm-rpc=<url>
```

**Parameters:**

* `[to EVM address]` - Destination EVM address (0x format)
* `[amount in wei]` - Amount to send in wei (smallest unit)

**Default Flags:**

* `--gas-fee-cap=1000000000000` (1000 Gwei)
* `--gas-limit=21000`

**Example:**

```bash theme={"dark"}
seid tx evm send 0x1234567890abcdef1234567890abcdef12345678 1000000000000000000 --from=mykey
```

**Output :**

```
Transaction hash: 0x...
```

### Send ERC20 Tokens

Sends ERC20 tokens from a specific contract to a recipient.

```bash theme={"dark"}
seid tx evm erc20-send [contract addr] [recipient] [amount] --from=<sender> --gas-fee-cap=<cap> --gas-limit=<limit> --evm-rpc=<url>
```

**Parameters:**

* `[contract addr]` - ERC20 contract address
* `[recipient]` - Recipient EVM address
* `[amount]` - Amount in smallest unit of the token

**Default Flags:**

* `--gas-fee-cap=1000000000000` (1000 Gwei)
* `--gas-limit=7000000`

**Example:**

```bash theme={"dark"}
seid tx evm erc20-send 0xTokenContract123... 0xRecipient456... 1000000 --from=mykey
```

**Output :**

```
Transaction hash: 0x...
```

## Contract Deployment Commands

### Deploy Contract

Deploys an EVM contract from a binary file.

```bash theme={"dark"}
seid tx evm deploy [path to binary] --from=<sender> --gas-fee-cap=<cap> --gas-limit=<limit> --evm-rpc=<url>
```

**Parameters:**

* `[path to binary]` - Path to the contract binary file

**Default Flags:**

* `--gas-fee-cap=1000000000000` (1000 Gwei)
* `--gas-limit=5000000`

**Example:**

```bash theme={"dark"}
seid tx evm deploy ./MyContract.bin --from=mykey --gas-limit=8000000
```

**Output :**

```
Deployer: 0x...
Deployed to: 0x...
Transaction hash: 0x...
```

## Contract Interaction Commands

### Call Contract

Calls an EVM contract with a specific payload. You can generate payload by taking a look at docs [here](/evm/querying-the-evm#payload-generation).

```bash theme={"dark"}
seid tx evm call-contract [addr] [payload hex] --value=<payment> --from=<sender> --gas-fee-cap=<cap> --gas-limit=<limit> --evm-rpc=<url>
```

**Parameters:**

* `[addr]` - Contract address
* `[payload hex]` - Function call data in hex format

**Default Flags:**

* `--gas-fee-cap=1000000000000` (1000 Gwei)
* `--gas-limit=7000000`
* `--value=0` - SEI value to send with the call

**Example:**

```bash theme={"dark"}
seid tx evm call-contract 0xContract123... 0xa9059cbb000000... --value=1000000000000000000 --from=mykey
```

**Output :**

```
Transaction hash: 0x...
```

### Call Precompile

Calls a method on a precompiled contract. Precompiles provide EVM access to Cosmos-SDK functionality.

```bash theme={"dark"}
seid tx evm call-precompile [precompile name] [method] [args...] --value=<payment> --from=<sender> --gas-fee-cap=<cap> --gas-limit=<limit> --evm-rpc=<url>
```

**Parameters:**

* `[precompile name]` - Name of the precompiled contract
* `[method]` - Method name to call
* `[args...]` - Method arguments

**Default Flags:**

* `--gas-fee-cap=1000000000000` (1000 Gwei)
* `--gas-limit=7000000`
* `--value=""` - SEI value to send (required for payable methods)

**Examples:**

*Delegate to validator (payable - uses --value):*

```bash theme={"dark"}
seid tx evm call-precompile staking delegate seivaloper1... --value=1000000000000000000 --from=mykey
```

**Available Precompiles:**

* `distribution` - Staking rewards management
* `json` - JSON parsing utilities
* `p256` - P256 cryptographic operations
* `staking` - Validator delegation and staking

<Info>For detailed information about each precompile's methods, parameters, and usage patterns, refer to the [EVM Precompiles documentation](/evm/precompiles/example-usage).</Info>

**Output :**

```
Transaction hash: 0x...
```

## Advanced Usage

### Custom Gas Settings

You can customize gas settings for any transaction:

```bash theme={"dark"}
seid tx evm send 0x... 1000000000000000000 \
  --gas-fee-cap=2000000000000 \
  --gas-limit=100000 \
  --from=mykey
```

### Nonce Management

Override automatic nonce calculation:

```bash theme={"dark"}
seid tx evm send 0x... 1000000000000000000 \
  --nonce=42 \
  --from=mykey
```

## Error Handling

<Warning>
  **Common Issues:**

  * Insufficient balance for transaction + gas
  * Incorrect address formats (use 0x prefix for EVM addresses)
  * Gas limit too low for complex operations
  * Nonce conflicts in rapid successive transactions
</Warning>

## Best Practices

1. **Gas Estimation**: Start with default gas limits and adjust based on transaction complexity
2. **Address Validation**: Always verify addresses before sending transactions
3. **Key Management**: Use secure key storage and never expose private keys
4. **Network Verification**: Confirm you're connected to the correct network
5. **Transaction Monitoring**: Save transaction hashes for tracking purposes

## Transaction Requirements

* **Key Configuration**: Local keyring must contain the signing key
* **Sufficient Balance**: Account must have enough tokens for transaction amount + gas
* **Address Formats**: Use proper formats (0x... for EVM, seivaloper... for validators)
* **Network Access**: Ensure connectivity to the specified RPC endpoint
* **Gas Limits**: Set appropriate gas limits for transaction complexity

For more detailed information about specific commands, use the help flag:

```bash theme={"dark"}
seid tx evm [command] --help
```

---

URL: https://docs.sei.io/evm/changelog

# Changelog

> Track the latest updates, improvements, and changes to Sei Chain. Stay informed about new features, bug fixes, and protocol upgrades.

export const Changelog = props => {
  const STATIC_CHANGELOG = [{
    version: 'v5.9.0',
    body: `sei-chain
* [#1867](https://github.com/sei-protocol/sei-chain/pull/1867) Add synthetic events in separate sei endpoints
* [#1861](https://github.com/sei-protocol/sei-chain/pull/1861) Revert showing wasm txs in EVM RPCs
* [#1857](https://github.com/sei-protocol/sei-chain/pull/1857) Fix events in 2-hop scenarios
* [#1856](https://github.com/sei-protocol/sei-chain/pull/1856) Add delegatecall flag to properly detect delegatecalls
* [#1850](https://github.com/sei-protocol/sei-chain/pull/1853) Fix websocket from_height
* [#1849](https://github.com/sei-protocol/sei-chain/pull/1849) Reduce block bloom storage
* [#1844](https://github.com/sei-protocol/sei-chain/pull/1844) Allowlist for token extensions

sei-iavl
* [#41](https://github.com/sei-protocol/sei-iavl/pull/41) Fix tree versions causing slow restart and OOM`
  }, {
    version: 'v5.8.0',
    body: `sei-chain
* [#1840](https://github.com/sei-protocol/sei-chain/pull/1840) Add migration for new params
* [#1837](https://github.com/sei-protocol/sei-chain/pull/1837) Move token id from Data to Topic in ERC721 Event
* [#1836](https://github.com/sei-protocol/sei-chain/pull/1836) Properly handle gas in pointer precompile
* [#1835](https://github.com/sei-protocol/sei-chain/pull/1835) Check TX nonce before registering hook to bump nonce for failed tx
* [#1832](https://github.com/sei-protocol/sei-chain/pull/1832) Show CW transactions that have synthetic EVM events in eth_getBlock response
* [#1831](https://github.com/sei-protocol/sei-chain/pull/1831) Fork event manager when creating EVM snapshots
* [#1830](https://github.com/sei-protocol/sei-chain/pull/1830) Add wasm contract query gas limit
* [#1826](https://github.com/sei-protocol/sei-chain/pull/1826) limit MsgExec max nested level
* [#1821](https://github.com/sei-protocol/sei-chain/pull/1821) Add antehandler for EVM to check gas exceed limit or not
* [#1818](https://github.com/sei-protocol/sei-chain/pull/1818) Prevent ddos against associate msgs
* [#1816](https://github.com/sei-protocol/sei-chain/pull/1816) Actually remove dex module
* [#1813](https://github.com/sei-protocol/sei-chain/pull/1813) Tune Configs
* [#1812](https://github.com/sei-protocol/sei-chain/pull/1812) Evidence Max Bytes Update
* [#1785](https://github.com/sei-protocol/sei-chain/pull/1785) Allow CW->ERC pointers to be called through wasmd precompile
* [#1778](https://github.com/sei-protocol/sei-chain/pull/1778) Bump nonce even if tx fails

sei-cosmos
* [#535](https://github.com/sei-protocol/sei-cosmos/pull/535) init app earliest version correctly after state sync
* [#534](https://github.com/sei-protocol/sei-cosmos/pull/534) Stop executing the handler when proposal is submitted
* [#533](https://github.com/sei-protocol/sei-cosmos/pull/533) Delete kvstore specified in store upgrades
* [#532](https://github.com/sei-protocol/sei-cosmos/pull/532) Add max gas limit check in ante handler
* [#528](https://github.com/sei-protocol/sei-cosmos/pull/528) Add logs for snapshot export and import

sei-wasmd
* [#63](https://github.com/sei-protocol/sei-wasmd/pull/63) Add CW dispatch call depth
* [#62](https://github.com/sei-protocol/sei-wasmd/pull/62) Patch Gas mispricing in CW VM

sei-tendermint
* [#242](https://github.com/sei-protocol/sei-tendermint/pull/242) Allow hyphen in event query`
  }, {
    version: 'v5.7.5',
    body: `sei-chain
* [#1795](https://github.com/sei-protocol/sei-chain/pull/1795) Do not charge gas for feecollector address query
* [#1782](https://github.com/sei-protocol/sei-chain/pull/1782) Update excessBlobGas and BlobBaseFee to fix simulate evmcontext

sei-cosmos
* [#530](https://github.com/sei-protocol/sei-cosmos/pull/530) Add EVMEntryViaWasmdPrecompile flag
* [#519](https://github.com/sei-protocol/sei-cosmos/pull/519) Genesis export stream
* [#529](https://github.com/sei-protocol/sei-cosmos/pull/529) Add DeliverTx callback
* [#528](https://github.com/sei-protocol/sei-cosmos/pull/528) Add logs for snapshot export and import

sei-wasmd
* [#58](https://github.com/sei-protocol/sei-wasmd/pull/58) Genesis Export OOM

sei-tendermint
* [#239](https://github.com/sei-protocol/sei-tendermint/pull/239) Use Marshal and UnmarshalJSON For HexBytes`
  }, {
    version: 'v5.7.1 & v5.7.2',
    body: `sei-chain
* [#1779](https://github.com/sei-protocol/sei-chain/pull/1779) Fix subscribe logs empty params crash
* [#1783](https://github.com/sei-protocol/sei-chain/pull/1783) Add meaningful message for eth_call balance override overflow
* [#1783](https://github.com/sei-protocol/sei-chain/pull/1784) Fix log index on synthetic receipt
* [#1775](https://github.com/sei-protocol/sei-chain/pull/1775) Disallow sending to direct cast addr after association

sei-wasmd
* [#60](https://github.com/sei-protocol/sei-wasmd/pull/60) Query penalty fixes

sei-tendermint
* [#237](https://github.com/sei-protocol/sei-tendermint/pull/237) Add metrics for total txs bytes in mempool`
  }, {
    version: 'v5.7.0',
    body: `sei-chain
* [#1731](https://github.com/sei-protocol/sei-chain/pull/1731) Remove 1-hop limit
* [#1663](https://github.com/sei-protocol/sei-chain/pull/1663) Retain pointer address on upgrade`
  }, {
    version: 'v5.6.0',
    body: `sei-chain
* [#1690](https://github.com/sei-protocol/sei-chain/pull/1690) Use transient store for EVM deferred info
* [#1742](https://github.com/sei-protocol/sei-chain/pull/1742) Add transient receipts with eventual flush to store
* [#1744](https://github.com/sei-protocol/sei-chain/pull/1744) Only emit cosmos events if no error in precompiles
* [#1737](https://github.com/sei-protocol/sei-chain/pull/1737) Only send unlocked tokens upon address association
* [#1740](https://github.com/sei-protocol/sei-chain/pull/1740) Update Random to Hash of Block Timestamp
* [#1734](https://github.com/sei-protocol/sei-chain/pull/1734) Add migration to unwind dex state
* [#1736](https://github.com/sei-protocol/sei-chain/pull/1736) Create account for sendNative receiver
* [#1738](https://github.com/sei-protocol/sei-chain/pull/1738) Reduce Default TTL configs
* [#1733](https://github.com/sei-protocol/sei-chain/pull/1733) Update getBlockReceipts to accept block hash
* [#1732](https://github.com/sei-protocol/sei-chain/pull/1732) Show empty trace on insufficient funds error
* [#1727](https://github.com/sei-protocol/sei-chain/pull/1727) Add association error metric
* [#1728](https://github.com/sei-protocol/sei-chain/pull/1728) Make occ caused evm panics less noisy
* [#1719](https://github.com/sei-protocol/sei-chain/pull/1719) Fixes local network in /scripts/run-node.py

sei-cosmos
* [#521](https://github.com/sei-protocol/sei-cosmos/pull/521) add DeliverTx hook
* [#520](https://github.com/sei-protocol/sei-cosmos/pull/520) Add callback for receipt storage
* [#517](https://github.com/sei-protocol/sei-cosmos/pull/517) Fix metric name for chain state size
* [#516](https://github.com/sei-protocol/sei-cosmos/pull/516) add EVM event manager to context

sei-wasmd
* [#54](https://github.com/sei-protocol/sei-wasmd/pull/54) Update wasm query behavior upon error

sei-tendermint
* [#238](https://github.com/sei-protocol/sei-tendermint/pull/238) Make RPC timeout configurable
* [#219](https://github.com/sei-protocol/sei-tendermint/pull/219) Add metrics for mempool change`
  }, {
    version: 'v5.5.5',
    body: `sei-chain
* [#1726](https://github.com/sei-protocol/sei-chain/pull/1726) Handle VM error code properly
* [#1713](https://github.com/sei-protocol/sei-chain/pull/1713) RPC Get Evm Hash
* [#1711](https://github.com/sei-protocol/sei-chain/pull/1711) Add gov proposal v2 for native pointer
* [#1694](https://github.com/sei-protocol/sei-chain/pull/1694) Add native associate tx type

sei-cosmos
* [#511](https://github.com/sei-protocol/sei-cosmos/pull/511) Add error for evm revert`
  }, {
    version: 'v5.5.2',
    body: `sei-chain
* [#1685](https://github.com/sei-protocol/sei-chain/pull/1685) Add EVM support to v5.5.2`
  }, {
    version: 'v5.4.0',
    body: `sei-chain
* [#1671](https://github.com/sei-protocol/sei-chain/pull/1671) Update and fixes to ERC721 contract
* [#1672](https://github.com/sei-protocol/sei-chain/pull/1672) Add sei_getCosmosTx endpoint
* [#1669](https://github.com/sei-protocol/sei-chain/pull/1669) Add ERC/CW 2981 in pointer
* [#1668](https://github.com/sei-protocol/sei-chain/pull/1673) Bring CW721 pointer contract up to spec
* [#1662](https://github.com/sei-protocol/sei-chain/pull/1662) Add memo support to ibc compiles
* [#1661](https://github.com/sei-protocol/sei-chain/pull/1661) Do not modify original value passed in executeBatch call

sei-cosmos
* [#505](https://github.com/sei-protocol/sei-cosmos/pull/505) Fix export genesis for historical height
* [#506](https://github.com/sei-protocol/sei-cosmos/pull/506) Allow reading pairs in changeset before flush

sei-wasmd
* [#50](https://github.com/sei-protocol/sei-wasmd/pull/50) Changes to fix runtime gas and add paramsKeeper to wasmKeeper for query gas multiplier`
  }, {
    version: 'v5.2.0',
    body: `sei-chain
* [#1621](https://github.com/sei-protocol/sei-chain/pull/1621) Add websocket metrics
* [#1619](https://github.com/sei-protocol/sei-chain/pull/1619) Limit number of subscriptions
* [#1618](https://github.com/sei-protocol/sei-chain/pull/1618) Fix contract deploy receipts
* [#1615](https://github.com/sei-protocol/sei-chain/pull/1615) Optimize websocket newHead by reusing tendermint subscription
* [#1609](https://github.com/sei-protocol/sei-chain/pull/1609) Add association logic to simulate endpoints
* [#1605](https://github.com/sei-protocol/sei-chain/pull/1605) Disallow sr25519 addresses for evm functions
* [#1606](https://github.com/sei-protocol/sei-chain/pull/1606) Skip evm antehandler on sr25519 signatures

sei-cosmos
* [#495](https://github.com/sei-protocol/sei-cosmos/pull/495) Fix seid keys list by ignoring evm-addr for sr25519
* [#493](https://github.com/sei-protocol/sei-cosmos/pull/493) Remove non-multiplier gas meter

sei-tendermint
* [#235](https://github.com/sei-protocol/sei-tendermint/pull/235) Check removed including wrapped tx state

sei-db
* [#63](https://github.com/sei-protocol/sei-db/pull/63) Fix edge case for iterating over tombstoned value`
  }, {
    version: 'v5.0.1',
    body: `sei-chain
* [#1577](https://github.com/sei-protocol/sei-chain/pull/1577) Re-enable Cancun`
  }, {
    version: 'v5.0.0',
    body: `sei-chain
* [Compare v3.9.0 → v5.0.0](https://github.com/sei-protocol/sei-chain/compare/v3.9.0...008ff68)

sei-cosmos
* [Compare v0.2.84 → v0.3.1](https://github.com/sei-protocol/sei-cosmos/compare/v0.2.83...v0.3.1)

sei-tendermint
* [Compare v0.2.40 → v0.3.0](https://github.com/sei-protocol/sei-tendermint/compare/v0.2.40...v0.3.0)`
  }, {
    version: 'v3.9.0',
    body: `sei-chain
* [#1565](https://github.com/sei-protocol/sei-chain/pull/1565) Cosmos Gas Multiplier Params
* [#1444](https://github.com/sei-protocol/sei-chain/pull/1444) Adding tokenfactory denom metadata endpoint

sei-cosmos
* [#489](https://github.com/sei-protocol/sei-cosmos/pull/489) Cosmos Gas Multiplier Params
* [#477](https://github.com/sei-protocol/sei-cosmos/pull/477) OCC if synchronous, reset non-pending

sei-tendermint
* [#211](https://github.com/sei-protocol/sei-tendermint/pull/211) Replay events during restart to avoid tx missing

sei-db
* [#62](https://github.com/sei-protocol/sei-db/pull/62) Set CreateIfMissing to false when copyExisting

sei-wasmd
* [#45](https://github.com/sei-protocol/sei-wasmd/pull/45) Update LimitSimulationGasDecorator with custom Gas Meter Setter
* [#44](https://github.com/sei-protocol/sei-wasmd/pull/44) Bump wasmvm to v1.5.2`
  }, {
    version: 'v3.8.0',
    body: `sei-tendermint
* [#209](https://github.com/sei-protocol/sei-tendermint/pull/209) Use write-lock in (*TxPriorityQueue).ReapMax funcs

sei-db
* [#61](https://github.com/sei-protocol/sei-db/pull/61) LoadVersion should open DB with read only

sei-wasmd
* [#41](https://github.com/sei-protocol/sei-wasmd/pull/42) Bump wasmd version`
  }, {
    version: 'v3.7.0',
    body: `sei-chain
* [#1283](https://github.com/sei-protocol/sei-chain/pull/1283) Update synchronous execution to set tx indices properly
* [#1325](https://github.com/sei-protocol/sei-chain/pull/1325) Oracle price feeder ignore error for vote already exist

sei-cosmos
* [#401](https://github.com/sei-protocol/sei-cosmos/pull/401) Ensure Panic Recovery in Prepare & Process Handlers
* [#404](https://github.com/sei-protocol/sei-cosmos/pull/404) No longer disable dynamic dep generation
* [#411](https://github.com/sei-protocol/sei-cosmos/pull/411) Fix concurrent map access for seidb
* [#424](https://github.com/sei-protocol/sei-cosmos/pull/424) Fix SS apply changeset version off by 1`
  }, {
    version: 'v3.6.1',
    body: `sei-chain
* [#1204](https://github.com/sei-protocol/sei-chain/pull/1204) Cleanup removed oracle feeds
* [#1196](https://github.com/sei-protocol/sei-chain/pull/1196) Add panic handler in dex endblock
* [#1170](https://github.com/sei-protocol/sei-chain/pull/1170) Integrate SeiDB into Sei Chain

sei-cosmos
* [#391](https://github.com/sei-protocol/sei-cosmos/pull/391) Fix potential memory leak due to emitting events
* [#388](https://github.com/sei-protocol/sei-cosmos/pull/388) Improve cachekv write performance
* [#385](https://github.com/sei-protocol/sei-cosmos/pull/385) Add params to disable seqno
* [#373](https://github.com/sei-protocol/sei-cosmos/pull/373) Add root multistore v2 for SeiDB

sei-tendermint
* [#175](https://github.com/sei-protocol/sei-tendermint/pull/175) Fix self remediation bug for block sync`
  }, {
    version: 'v3.5.0',
    body: `sei-chain
* [#1164](https://github.com/sei-protocol/sei-chain/pull/1164) Bump wasmd
* [#1163](https://github.com/sei-protocol/sei-chain/pull/1163) Update antehandler
* [#1160](https://github.com/sei-protocol/sei-chain/pull/1160) Allow metrics script to query remote
* [#1156](https://github.com/sei-protocol/sei-chain/pull/1156) Bump ledger version to support nano s
* [#1155](https://github.com/sei-protocol/sei-chain/pull/1155) Allow loadtest client to take a list of grpc endpoints

sei-cosmos
* [#383](https://github.com/sei-protocol/sei-cosmos/pull/383) Refactor wasm dependency behavior
* [#353](https://github.com/sei-protocol/sei-cosmos/pull/353) Perf: Relax locking contention for cache and cachekv
* [#331](https://github.com/sei-protocol/sei-cosmos/pull/331) Fast reject invalid consensus params

sei-tendermint
* [#170](https://github.com/sei-protocol/sei-tendermint/pull/170) P2P: Optimize block pool requester retry and peer pick up logic
* [#167](https://github.com/sei-protocol/sei-tendermint/pull/167) Perf: Increase buffer size for pubsub server to boost performance
* [#164](https://github.com/sei-protocol/sei-tendermint/pull/164) Add regex support to query syntax
* [#163](https://github.com/sei-protocol/sei-tendermint/pull/163) Reduce noisy tendermint logs
* [#162](https://github.com/sei-protocol/sei-tendermint/pull/162) Use peermanager scores for blocksync peers and don't error out on block mismatch`
  }, {
    version: 'v3.3.0',
    body: `sei-ibc-go
* [#35](https://github.com/sei-protocol/sei-ibc-go/pull/35) Upgrade to Ibc v3.4.0`
  }, {
    version: 'v3.2.1',
    body: `sei-chain
* [#1073](https://github.com/sei-protocol/sei-chain/pull/1073) Add timestamp to oracle exchange rates

sei-cosmos
* [#320](https://github.com/sei-protocol/sei-cosmos/pull/320) Allow minor release upgrades prior to upgrade height

sei-tendermint
* [#158](https://github.com/sei-protocol/sei-tendermint/pull/158) Add metrics for peermanager scores
* [#157](https://github.com/sei-protocol/sei-tendermint/pull/157) Fix findNewPrimary never timing out upon encountering poor witnesses
* [#156](https://github.com/sei-protocol/sei-tendermint/pull/156) Remove bad witness and don't block on all witnesses for ConsensusParams`
  }, {
    version: 'v3.1.1',
    body: `sei-ibc-go
* [#34](https://github.com/sei-protocol/sei-ibc-go/pull/34) Upgrade to Ibc v3.2.0`
  }, {
    version: 'v3.0.9',
    body: `sei-tendermint
* [#154](https://github.com/sei-protocol/sei-tendermint/pull/154) Fix empty prevote latency metrics`
  }, {
    version: '3.0.8',
    body: `sei-chain
* [#1018](https://github.com/sei-protocol/sei-chain/pull/1018) Reorder tx results into absolute order`
  }, {
    version: '3.0.7',
    body: `sei-chain
* [#1002](https://github.com/sei-protocol/sei-chain/pull/1002) Tokenfactory Query Wasmbindings
* [#989](https://github.com/sei-protocol/sei-chain/pull/989) Add CLI/wasmbinding to set tokenfactory metadata
* [#963](https://github.com/sei-protocol/sei-chain/pull/963) Add SetMetadata to tokenfactory

sei-cosmos
* [#308](https://github.com/sei-protocol/sei-cosmos/pull/308) Add NoConsumptionInfiniteGasMeter`
  }, {
    version: '3.0.6',
    body: `sei-chain
* [#944](https://github.com/sei-protocol/sei-chain/pull/944) Add new configuration for snapshot directory
* [#940](https://github.com/sei-protocol/sei-chain/pull/940) Use ImmutableAppend for v16 to v17 dex migration

sei-cosmos
* [#306](https://github.com/sei-protocol/sei-cosmos/pull/306) Fix dryRun for seid tx`
  }, {
    version: '3.0.5',
    body: `sei-chain
* [#878](https://github.com/sei-protocol/sei-chain/pull/878) Fix denom key collision

sei-tendermint
* [#149](https://github.com/sei-protocol/sei-tendermint/pull/149) Fix condition for tx key dissemination

sei-iavl
* [#32](https://github.com/sei-protocol/sei-iavl/pull/32) Separate orphan storage`
  }, {
    version: '3.0.4',
    body: `sei-chain
* [#874](https://github.com/sei-protocol/sei-chain/pull/874) Charge rent after failed Sudo call
* [#869](https://github.com/sei-protocol/sei-chain/pull/869) Require fee per byte in order data
* [#861](https://github.com/sei-protocol/sei-chain/pull/861) Fix tokenfactory metadata

sei-cosmos
* [#287](https://github.com/sei-protocol/sei-cosmos/pull/287) Refactor deferred balance to use memkv
* [#286](https://github.com/sei-protocol/sei-cosmos/pull/286) Prevent multisig sign with wrong key
* [#284](https://github.com/sei-protocol/sei-cosmos/pull/284) Fix allowed_msg uncapped spend limit
* [#280](https://github.com/sei-protocol/sei-cosmos/pull/280) Barberry patch

sei-tendermint
* [#148](https://github.com/sei-protocol/sei-tendermint/pull/148) Add sleep to avoid consensus reactor retrying too quickly`
  }, {
    version: '3.0.3',
    body: `sei-chain
* [#816](https://github.com/sei-protocol/sei-chain/pull/816) Reenable tx concurrency for non oracle/priority txs

sei-cosmos
* [#254](https://github.com/sei-protocol/sei-cosmos/pull/254) Use sequential searching instead of binary search for coins

sei-tendermint
* [#143](https://github.com/sei-protocol/sei-tendermint/pull/143) Fix cpu leak for simple pq but stopping timer
* [#140](https://github.com/sei-protocol/sei-tendermint/pull/140) Add raw logs to tx output`
  }, {
    version: '3.0.2',
    body: `sei-chain
* [#810](https://github.com/sei-protocol/sei-chain/pull/810) Disable FOK orders
* [#809](https://github.com/sei-protocol/sei-chain/pull/809) Huckleberry patch
* [#808](https://github.com/sei-protocol/sei-chain/pull/808) Add global min fees as a param`
  }, {
    version: '3.0.1',
    body: `sei-chain
* [#797](https://github.com/sei-protocol/sei-chain/pull/797) Don't charge gas for loading contract dependencies
* [#792](https://github.com/sei-protocol/sei-chain/pull/792) Reset block gas meter if concurrent processing fails
* [#791](https://github.com/sei-protocol/sei-chain/pull/791) Disable skipFastStorageUpgrade to make iavl dump faster
* [#790](https://github.com/sei-protocol/sei-chain/pull/790) Disable non-prioritized tx concurrency
* [#789](https://github.com/sei-protocol/sei-chain/pull/789) Adds appropriate READ access for dex contract in antehandler
* [#788](https://github.com/sei-protocol/sei-chain/pull/788) Clear dex memstate cache when falling back to sequential processing
* [#786](https://github.com/sei-protocol/sei-chain/pull/786) Add NoVersioning to seid command
* [#781](https://github.com/sei-protocol/sei-chain/pull/781) Add order limit for price level and pair limit for contracts

tm-db
* [#2](https://github.com/sei-protocol/tm-db/pull/2) Load items eagerly to memdb_iterator to avoid deadlock

sei-tendermint
* [#137](https://github.com/sei-protocol/sei-tendermint/pull/137) New endpoint to expose lag`
  }, {
    version: '3.0.0',
    body: `sei-chain
* [#777](https://github.com/sei-protocol/sei-chain/pull/777) Parallelize Sudo Deposit
* [#771](https://github.com/sei-protocol/sei-chain/pull/771) Parallelize BeginBlock for x/dex
* [#768](https://github.com/sei-protocol/sei-chain/pull/768) Add FOK back to order match result
* [#763](https://github.com/sei-protocol/sei-chain/pull/763) Refactor dex EndBlock to optimize store access

sei-cosmos
* [#240](https://github.com/sei-protocol/sei-cosmos/pull/239) Add dex contract ACL type
* [#237](https://github.com/sei-protocol/sei-cosmos/pull/237) Add next-account-numnber cli

sei-tendermint
* [#136](https://github.com/sei-protocol/sei-tendermint/pull/136) Revert block.Evidence to nested block.Evidence.Evidence
* [#135](https://github.com/sei-protocol/sei-tendermint/pull/135) Auto switch to blocksync should only start in consensus mode`
  }, {
    version: '2.0.48beta',
    body: `sei-chain
* [#743](https://github.com/sei-protocol/sei-chain/pull/743) Do not unregister contract if out of rent
* [#742](https://github.com/sei-protocol/sei-chain/pull/742) Add more metrics to dex module
* [#733](https://github.com/sei-protocol/sei-chain/pull/733) Remove liquidation logic from dex

sei-cosmos
* [#235](https://github.com/sei-protocol/sei-cosmos/pull/235) Fix x/simulation fee check
* [#234](https://github.com/sei-protocol/sei-cosmos/pull/234) Add more metrics for Begin/Mid/End Block

sei-tendermint
* [#134](https://github.com/sei-protocol/sei-tendermint/pull/134) Fix nil peer address map`
  }, {
    version: '2.0.47beta',
    body: `sei-chain
* [#726](https://github.com/sei-protocol/sei-chain/pull/726) Fix of dex rent transfer issue
* [#723](https://github.com/sei-protocol/sei-chain/pull/723) Security CW Patch Cherry
* [#699](https://github.com/sei-protocol/sei-chain/pull/699) Loadtest update
* [#716](https://github.com/sei-protocol/sei-chain/pull/716) Sei cluster init script update
* [#725](https://github.com/sei-protocol/sei-chain/pull/725) DBSync config update
* [#718](https://github.com/sei-protocol/sei-chain/pull/718) Update mint distribution to be daily
* [#729](https://github.com/sei-protocol/sei-chain/pull/729) Add gov prop handler for updating current minter
* [#730](https://github.com/sei-protocol/sei-chain/pull/730) Add README.md for epoch module
* [#727](https://github.com/sei-protocol/sei-chain/pull/727) Bump max wasm file size to 2MB
* [#731](https://github.com/sei-protocol/sei-chain/pull/731) Bump for module to module debug logs
* [#732](https://github.com/sei-protocol/sei-chain/pull/732) Remove x/nitro from genesis version

sei-cosmos
* [#231](https://github.com/sei-protocol/sei-cosmos/pull/231) Typo for m2m debug message
* [#230](https://github.com/sei-protocol/sei-cosmos/pull/230) Add debug message for module to module transactions
* [#228](https://github.com/sei-protocol/sei-cosmos/pull/228) Deprecate LoadLatest flag
* [#229](https://github.com/sei-protocol/sei-cosmos/pull/229) Replace snapshot manager multistore with new one after DBSync

sei-tendermint
* [#130](https://github.com/sei-protocol/sei-tendermint/pull/130) Do not run DBSync if there is already a readable app version`
  }, {
    version: '2.0.46beta',
    body: `sei-chain
* [#694](https://github.com/sei-protocol/sei-chain/pull/694) Register prune command
* [#702](https://github.com/sei-protocol/sei-chain/pull/702) Change tick failure log to warning

sei-cosmos
* [#227](https://github.com/sei-protocol/sei-cosmos/pull/227) Add checkTxResponse log to RPCResponse
* [#224](https://github.com/sei-protocol/sei-cosmos/pull/224) Default to secp256k1
* [#220](https://github.com/sei-protocol/sei-cosmos/pull/220) Add admin field to base vesting account
* [#218](https://github.com/sei-protocol/sei-cosmos/pull/218) Restart node instead of panicking
* [#216](https://github.com/sei-protocol/sei-cosmos/pull/216) Fix pruning command

sei-tendermint
* [#118](https://github.com/sei-protocol/sei-tendermint/pull/118) Add DBSync module`
  }, {
    version: '2.0.45beta',
    body: `sei-chain
* [#666](https://github.com/sei-protocol/sei-chain/pull/666) DEX remove BeginBlock/FinalizeBlock sudo hooks
* [#674](https://github.com/sei-protocol/sei-chain/pull/674) Longterm fix for max gas enforcement

sei-cosmos
* [#210](https://github.com/sei-protocol/sei-cosmos/pull/210) Add levelDB compaction goroutine

sei-tendermint
* [#110](https://github.com/sei-protocol/sei-tendermint/pull/110) Add more granular buckets for block interval
* [#111](https://github.com/sei-protocol/sei-tendermint/pull/111) Add unused prival pubKey back to node info - fix for IBC on full nodes
* [#113](https://github.com/sei-protocol/sei-tendermint/pull/113) Add metrics label for missing val power`
  }, {
    version: '2.0.44beta',
    body: `sei-chain
* [#658](https://github.com/sei-protocol/sei-chain/pull/658) Revert EventAttribute fields to byte array

sei-cosmos
* [#204](https://github.com/sei-protocol/sei-cosmos/pull/204) IBC Compatibility Fix

sei-tendermint
* IBC Compatibility Fix, Bump default max gas limit, Add metrics & visibility for high block time`
  }, {
    version: '2.0.42beta',
    body: `sei-chain
* [#670](https://github.com/sei-protocol/sei-chain/pull/670) Add add-wasm-genesis-message to seid
* [#654](https://github.com/sei-protocol/sei-chain/pull/654) Improve endblock performance and fix trace

sei-cosmos
* improvements around monitoring for sei-cosmos, dont enforce gas limit on deliverTx, refactor slashing module

sei-tendermint
* [#95](https://github.com/sei-protocol/sei-tendermint/pull/95) Patch forging empty merkle tree attack vector, set default max gas param to 6mil, log tunning for p2p`
  }, {
    version: '2.0.40beta - 2023-03-10',
    body: `sei-chain
* [#646](https://github.com/sei-protocol/sei-chain/pull/646) Optimizations for FinalizeBlock
* [#644](https://github.com/sei-protocol/sei-chain/pull/644) Oak Audit: Add check for non-existent transaction
* [#647](https://github.com/sei-protocol/sei-chain/pull/647) Fixes to race conditions
* [#638](https://github.com/sei-protocol/sei-chain/pull/638) Emit Version Related Metrics
* [#636](https://github.com/sei-protocol/sei-chain/pull/636) Fix deadlock with upgrades
* [#635](https://github.com/sei-protocol/sei-chain/pull/635) Add event to dex messages`
  }, {
    version: '2.0.39beta - 2023-03-06',
    body: `sei-chain
* [#632](https://github.com/sei-protocol/sei-chain/pull/632) Bump Sei-tendermint to reduce log volume
* [#631](https://github.com/sei-protocol/sei-chain/pull/631) Nondeterminism deadlock fixes
* [#630](https://github.com/sei-protocol/sei-chain/pull/630) Mempool configs to avoid node slow down`
  }, {
    version: '2.0.38beta - 2023-03-04',
    body: `sei-chain
* [#623](https://github.com/sei-protocol/sei-chain/pull/623) Add new epoch events
* [#624](https://github.com/sei-protocol/sei-chain/pull/624) Add long messages for dex and mint
* [#588](https://github.com/sei-protocol/sei-chain/pull/588) Send deposit funds in message server instead of EndBlock
* [#627](https://github.com/sei-protocol/sei-chain/pull/627) Add slash window progress query
* [#625](https://github.com/sei-protocol/sei-chain/pull/625) Update contract rent deposit logic + add query endpoint`
  }, {
    version: '2.0.37beta - 2023-02-27',
    body: `sei-chain
* [#621](https://github.com/sei-protocol/sei-chain/pull/621) Add success count to the oracle query
* [#600](https://github.com/sei-protocol/sei-chain/pull/600) Add params to guard Nitro fraud challenge
* [#617](https://github.com/sei-protocol/sei-chain/pull/617) gracefully handle nil response for new provider
* [#619](https://github.com/sei-protocol/sei-chain/pull/619) Move store operations outside of iterator

sei-tendermint
* [#73](https://github.com/sei-protocol/sei-tendermint/pull/73) reduce checktx log noise`
  }, {
    version: '2.0.36beta - 2023-02-27',
    body: `sei-chain
* [#603](https://github.com/sei-protocol/sei-chain/pull/603) Set mempool ttl
* [#612](https://github.com/sei-protocol/sei-chain/pull/612) Optimistic Processing should finish before main goroutine
* [#613](https://github.com/sei-protocol/sei-chain/pull/613) Incorporate IAVL change that removes mutex locking
* Various audit fixes`
  }];
  const normVersion = s => (s || '').toLowerCase().replace(/\s+/g, '').replace(/^v/, '');
  const STATIC_VERSION_NAMES = new Set(STATIC_CHANGELOG.map(entry => normVersion(entry.version)));
  const [dynamicVersions, setDynamicVersions] = useState([]);
  const [error, setError] = useState(null);
  const [loading, setLoading] = useState(true);
  const [isDark, setIsDark] = useState(false);
  useEffect(() => {
    const el = document.documentElement;
    const update = () => setIsDark(el.classList.contains('dark'));
    update();
    const obs = new MutationObserver(update);
    obs.observe(el, {
      attributes: true,
      attributeFilter: ['class']
    });
    return () => obs.disconnect();
  }, []);
  const parseContent = rawContent => {
    if (!rawContent) return [];
    const sections = rawContent.split(/^## /gm).slice(1);
    const merged = new Map();
    const order = [];
    for (const section of sections) {
      const lines = section.split('\n');
      const version = lines[0]?.trim() || '';
      const body = lines.slice(1).join('\n').trim();
      if (!version || STATIC_VERSION_NAMES.has(normVersion(version))) continue;
      if (merged.has(version)) {
        const existing = merged.get(version);
        existing.body += `\n\n${body}`;
      } else {
        merged.set(version, {
          version,
          body
        });
        order.push(version);
      }
    }
    return order.map(v => merged.get(v));
  };
  useEffect(() => {
    fetch('https://raw.githubusercontent.com/sei-protocol/sei-chain/main/CHANGELOG.md').then(res => {
      if (!res.ok) throw new Error(`Failed to fetch: ${res.status}`);
      return res.text();
    }).then(content => {
      setDynamicVersions(parseContent(content));
      setLoading(false);
    }).catch(err => {
      setError(err.message);
      setLoading(false);
    });
  }, []);
  const linkBaseStyle = () => ({
    color: isDark ? 'var(--sei-maroon-25)' : 'var(--sei-maroon-100)',
    backgroundColor: isDark ? 'rgba(96, 0, 20, 0.2)' : 'var(--sei-grey-25)',
    fontFamily: 'var(--sei-font-mono)',
    transition: 'color 0.15s, background-color 0.15s'
  });
  const applyLinkHover = (e, hovering) => {
    if (hovering) {
      e.currentTarget.style.color = isDark ? 'var(--sei-cream)' : 'var(--sei-maroon-200)';
      e.currentTarget.style.backgroundColor = isDark ? 'rgba(96, 0, 20, 0.3)' : 'var(--sei-grey-30)';
    } else {
      e.currentTarget.style.color = isDark ? 'var(--sei-maroon-25)' : 'var(--sei-maroon-100)';
      e.currentTarget.style.backgroundColor = isDark ? 'rgba(96, 0, 20, 0.2)' : 'var(--sei-grey-25)';
    }
  };
  const TextWithLinks = ({content, componentName}) => {
    if (!content) {
      return <span className="text-base">{content}</span>;
    }
    const getRepoUrl = compName => {
      const repoMap = {
        'sei-chain': 'sei-protocol/sei-chain',
        'sei-tendermint': 'sei-protocol/sei-tendermint',
        'sei-cosmos': 'sei-protocol/sei-cosmos',
        'sei-db': 'sei-protocol/sei-db',
        'sei-wasmd': 'sei-protocol/sei-wasmd',
        'sei-iavl': 'sei-protocol/sei-iavl',
        'sei-ibc-go': 'sei-protocol/sei-ibc-go',
        'tm-db': 'sei-protocol/tm-db'
      };
      return repoMap[compName] || 'sei-protocol/sei-chain';
    };
    const renderLink = (key, href, text, marginClass = 'ml-1') => <a key={key} href={href} target="_blank" rel="noopener noreferrer" className={`px-2 py-0.5 text-sm font-medium no-underline ${marginClass}`} style={linkBaseStyle()} onMouseEnter={e => applyLinkHover(e, true)} onMouseLeave={e => applyLinkHover(e, false)}>
        {text}
      </a>;
    const labelForUrl = url => {
      if (url.includes('/compare/')) {
        const m = url.match(/\/compare\/([^/\s]+)/);
        if (m) return `Compare ${m[1].replace('...', ' → ')}`;
      } else if (url.includes('/releases/tag/')) {
        const m = url.match(/\/releases\/tag\/([^/\s]+)/);
        if (m) return `Release ${m[1]}`;
      } else if (url.includes('/pull/')) {
        const m = url.match(/\/pull\/(\d+)/);
        if (m) return `#${m[1]}`;
      }
      return url;
    };
    const renderPlainSegment = (text, keyPrefix) => {
      const stripped = text.replace(/\[/g, '').replace(/\]/g, '');
      const urlPattern = /(https:\/\/github\.com\/[^\s)]+)/g;
      const parts = stripped.split(urlPattern);
      return parts.map((part, i) => {
        const key = `${keyPrefix}-${i}`;
        if (part.match(urlPattern)) {
          return renderLink(key, part, labelForUrl(part));
        }
        const compareMatch = part.match(/Compare\s+((?:sei-[a-z]+-)?(v?\d+\.\d+\.\d+(?:\.\d+)?(?:beta|alpha|rc\d*)?(?:-release)?))(?:\s*[→-]\s*|\.\.\.)+(v?\d+\.\d+\.\d+(?:\.\d+)?(?:beta|alpha|rc\d*)?(?:-release)?)/i);
        if (compareMatch) {
          const [fullMatch, fromVersion, , toVersion] = compareMatch;
          const cleanFromVersion = fromVersion.replace(/^sei-[a-z]+-/, '');
          const cleanToVersion = toVersion.replace(/^sei-[a-z]+-/, '');
          const repoPath = getRepoUrl(componentName);
          const compareUrl = `https://github.com/${repoPath}/compare/${cleanFromVersion}...${cleanToVersion}`;
          return <span key={key}>
              {part.replace(fullMatch, '')}
              {renderLink(`${key}-cmp`, compareUrl, `Compare ${cleanFromVersion} → ${cleanToVersion}`)}
            </span>;
        }
        const prParts = part.split(/(\b\d{1,4}\b|#\d+)/g);
        return <span key={key}>
            {prParts.map((subPart, j) => {
          const trimmedPart = subPart.trim();
          if (trimmedPart.match(/^#\d+$/)) {
            const num = trimmedPart.slice(1);
            const prevParts = prParts.slice(0, j).join('');
            const inlineComponentMatch = prevParts.match(/\b(sei-chain|sei-tendermint|sei-cosmos|sei-db|sei-wasmd|sei-iavl|sei-ibc-go|tm-db)\s*$/i);
            const effectiveComponent = inlineComponentMatch ? inlineComponentMatch[1] : componentName;
            const repoPath = getRepoUrl(effectiveComponent);
            return renderLink(`${key}-${j}`, `https://github.com/${repoPath}/pull/${num}`, `#${num}`);
          } else if (trimmedPart.match(/^\d{1,4}$/) && parseInt(trimmedPart, 10) > 0) {
            const prevPart = prParts[j - 1] || '';
            const nextPart = prParts[j + 1] || '';
            const followedByNonPR = nextPart.match(/^\s*(hop|limit|version|v\d|\.\d|px|ms|s\b|mb|gb|kb)/i);
            const precededByNonPR = prevPart.match(/(v|version|\d\.)\s*$/i);
            const isLikelyPRNumber = (j < 3 || prevPart.includes('•') || prevPart.includes('\n') || prevPart.includes('#')) && !followedByNonPR && !precededByNonPR && parseInt(trimmedPart, 10) >= 10;
            if (isLikelyPRNumber) {
              const prevParts = prParts.slice(0, j).join('');
              const inlineComponentMatch = prevParts.match(/\b(sei-chain|sei-tendermint|sei-cosmos|sei-db|sei-wasmd|sei-iavl|sei-ibc-go|tm-db)\s*$/i);
              const effectiveComponent = inlineComponentMatch ? inlineComponentMatch[1] : componentName;
              const repoPath = getRepoUrl(effectiveComponent);
              return renderLink(`${key}-${j}`, `https://github.com/${repoPath}/pull/${trimmedPart}`, `#${trimmedPart}`, 'mr-1');
            }
          }
          return <span key={`${key}-${j}`}>{subPart}</span>;
        })}
          </span>;
      });
    };
    const markdownLinkPattern = /\[([^\]]+)\]\((https?:\/\/[^)]+)\)/g;
    const tokens = content.split(markdownLinkPattern);
    const nodes = [];
    for (let i = 0; i < tokens.length; i++) {
      const mod = i % 3;
      if (mod === 0) {
        if (tokens[i]) {
          nodes.push(<span key={`seg-${i}`}>{renderPlainSegment(tokens[i], `seg-${i}`)}</span>);
        }
      } else if (mod === 1) {
        const label = tokens[i];
        const url = tokens[i + 1] || '';
        nodes.push(renderLink(`md-${i}`, url, label));
      }
    }
    return <span className="text-base">{nodes}</span>;
  };
  const renderContent = body => {
    if (!body) {
      return <div className="text-gray-500 dark:text-white italic py-4">No changes listed</div>;
    }
    const sectionComponents = [];
    const sections = body.split(/^### /gm);
    for (let i = 1; i < sections.length; i++) {
      const section = sections[i];
      const lines = section.split('\n');
      const sectionName = lines[0]?.trim();
      if (sectionName) {
        const bulletPoints = [];
        for (let j = 1; j < lines.length; j++) {
          const line = lines[j].trim();
          if (line.startsWith('*') || line.startsWith('-') || line.startsWith('•')) {
            const cleanLine = line.replace(/^\*\s*/, '').replace(/^-\s*/, '').replace(/^•\s*/, '');
            bulletPoints.push(cleanLine);
          }
        }
        if (bulletPoints.length > 0) {
          sectionComponents.push({
            name: sectionName,
            changes: bulletPoints.join('\n* ').replace(/^\* /, '')
          });
        }
      }
    }
    if (sectionComponents.length > 0) {
      return <div className="space-y-6">
          {sectionComponents.map((comp, i) => <div key={i}>
              <div className="flex items-center gap-2 mb-3">
                <div className="flex items-center gap-2 bg-gray-100 px-3 py-1.5">
                  <div className="w-2 h-2 rounded-full" style={{
        backgroundColor: 'var(--sei-maroon-100)'
      }}></div>
                  <span className="font-medium text-gray-700 dark:text-white text-sm">{comp.name}</span>
                </div>
              </div>
              <div className="space-y-2">
                {comp.changes.split(/\s*\*\s+/).filter(c => c.trim()).map((change, j) => <div key={j} className="flex items-start gap-3 py-2">
                      <span className="text-base mt-0.5 text-gray-400">•</span>
                      <div className="flex-1">
                        <TextWithLinks content={change.trim()} componentName={comp.name} />
                      </div>
                    </div>)}
              </div>
            </div>)}
        </div>;
    }
    const componentPattern = /^([a-zA-Z][a-zA-Z0-9-]*):?\s*(?:\(.*\))?\s*$/gm;
    const componentMatches = Array.from(body.matchAll(componentPattern));
    const components = [];
    if (componentMatches.length > 0) {
      const parts = body.split(/^([a-zA-Z][a-zA-Z0-9-]*):?\s*(?:\(.*\))?\s*$/gm);
      for (let i = 1; i < parts.length; i += 2) {
        const compName = parts[i]?.trim().replace(':', '');
        const compContent = parts[i + 1]?.trim();
        if (compName && compContent) {
          const bulletPoints = [];
          for (const line of compContent.split('\n')) {
            const trimmedLine = line.trim();
            if (trimmedLine.startsWith('*') || trimmedLine.startsWith('-') || trimmedLine.startsWith('•')) {
              const cleanLine = trimmedLine.replace(/^\*\s*/, '').replace(/^-\s*/, '').replace(/^•\s*/, '');
              bulletPoints.push(cleanLine);
            } else if (trimmedLine && !trimmedLine.match(/^[a-zA-Z][a-zA-Z0-9-]*:?\s*(?:\(.*\))?\s*$/)) {
              bulletPoints.push(trimmedLine);
            }
          }
          if (bulletPoints.length > 0) {
            components.push({
              name: compName,
              changes: bulletPoints.join('\n* ').replace(/^\* /, '')
            });
          }
        }
      }
    }
    if (components.length > 0) {
      return <div className="space-y-6">
          {components.map((comp, i) => <div key={i}>
              <div className="flex items-center gap-2 mb-3">
                <div className="flex items-center gap-2 bg-slate-100 px-3 py-1.5">
                  <div className="w-2 h-2 rounded-full" style={{
        backgroundColor: 'var(--sei-maroon-100)'
      }}></div>
                  <span className="font-medium text-slate-700 text-sm">{comp.name}</span>
                </div>
              </div>
              <div className="space-y-2">
                {comp.changes.split(/\s*\*\s+/).filter(c => c.trim()).map((change, j) => <div key={j} className="flex items-start gap-3 py-2">
                      <span className="text-base mt-0.5 text-gray-400">•</span>
                      <div className="flex-1">
                        <TextWithLinks content={change.trim()} componentName={comp.name} />
                      </div>
                    </div>)}
              </div>
            </div>)}
        </div>;
    }
    const fallbackLines = body.split('\n').map(l => l.trim().replace(/^\*\s*/, '').replace(/^-\s*/, '').replace(/^•\s*/, '')).filter(l => l);
    return <div className="space-y-2">
        {fallbackLines.map((line, i) => <div key={i} className="flex items-start gap-3 py-2">
            <span className="text-base mt-0.5 text-gray-400">•</span>
            <div className="flex-1">
              <TextWithLinks content={line} componentName="sei-chain" />
            </div>
          </div>)}
      </div>;
  };
  const staticVersions = STATIC_CHANGELOG.map(entry => ({
    version: entry.version,
    body: entry.body
  }));
  const versions = [...dynamicVersions, ...staticVersions];
  if (error) {
    return <div>
        <div className="my-4 p-4 border border-red-300 dark:border-red-700 bg-red-50 dark:bg-red-900/20 text-red-800 dark:text-red-200 text-sm">
          Failed to load latest changelog: {error}. Showing cached versions below.
        </div>
        <div className="changelog-content">
          {staticVersions.map(version => <div key={version.version} className="mb-8">
              <div className="flex items-center gap-3 mb-4">
                <h2 className="text-xl font-bold text-gray-900 dark:text-white m-0">{version.version}</h2>
                <span className="text-xs text-gray-500 bg-gray-100 px-2 py-1 rounded-full">Release</span>
              </div>
              <div className="space-y-4">{renderContent(version.body)}</div>
            </div>)}
        </div>
      </div>;
  }
  return <div>
      <div className="flex items-center justify-between mb-2 pb-4 mt-4">
        <a href="https://github.com/sei-protocol/sei-chain/blob/main/CHANGELOG.md" target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-2 text-sm px-3 py-1.5 font-medium no-underline" style={{
    color: isDark ? 'var(--sei-maroon-25)' : 'var(--sei-maroon-100)',
    backgroundColor: isDark ? 'rgba(96, 0, 20, 0.2)' : 'var(--sei-grey-25)',
    transition: 'color 0.15s, background-color 0.15s'
  }} onMouseEnter={e => {
    e.currentTarget.style.color = isDark ? 'var(--sei-cream)' : 'var(--sei-maroon-200)';
    e.currentTarget.style.backgroundColor = isDark ? 'rgba(96, 0, 20, 0.3)' : 'var(--sei-grey-30)';
  }} onMouseLeave={e => {
    e.currentTarget.style.color = isDark ? 'var(--sei-maroon-25)' : 'var(--sei-maroon-100)';
    e.currentTarget.style.backgroundColor = isDark ? 'rgba(96, 0, 20, 0.2)' : 'var(--sei-grey-25)';
  }}>
          <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20">
            <path fillRule="evenodd" d="M10 0C4.477 0 0 4.484 0 10.017c0 4.425 2.865 8.18 6.839 9.504.5.092.682-.217.682-.483 0-.237-.008-.868-.013-1.703-2.782.605-3.369-1.343-3.369-1.343-.454-1.158-1.11-1.466-1.11-1.466-.908-.62.069-.608.069-.608 1.003.07 1.531 1.032 1.531 1.032.892 1.53 2.341 1.088 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.113-4.555-4.951 0-1.093.39-1.988 1.029-2.688-.103-.253-.446-1.272.098-2.65 0 0 .84-.27 2.75 1.026A9.564 9.564 0 0110 4.844c.85.004 1.705.115 2.504.337 1.909-1.296 2.747-1.027 2.747-1.027.546 1.379.203 2.398.1 2.651.64.7 1.028 1.595 1.028 2.688 0 3.848-2.339 4.695-4.566 4.942.359.31.678.921.678 1.856 0 1.338-.012 2.419-.012 2.747 0 .268.18.58.688.482A10.019 10.019 0 0020 10.017C20 4.484 15.522 0 10 0z" clipRule="evenodd" />
          </svg>
          View on GitHub
        </a>
        {loading && <span className="inline-flex items-center text-xs text-neutral-500 dark:text-neutral-400">
            <span className="inline-block h-3 w-3 animate-spin rounded-full border-2 border-current border-r-transparent mr-2" />
            Checking for the latest releases…
          </span>}
      </div>

      <div className="changelog-content">
        {versions.map(version => <div key={version.version} className="mb-8">
            <div className="flex items-center gap-3 mb-4">
              <h2 className="text-xl font-bold text-gray-900 dark:text-white m-0">{version.version}</h2>
              <span className="text-xs text-gray-500 bg-gray-100 px-2 py-1 rounded-full">Release</span>
            </div>
            <div className="space-y-4">{renderContent(version.body)}</div>
          </div>)}
      </div>
    </div>;
};

Stay up-to-date with the latest changes, improvements, and new features in Sei.

<Info>This changelog is automatically synced from the [sei-chain repository](https://github.com/sei-protocol/sei-chain/blob/main/CHANGELOG.md). For the most up-to-date information, you can also view the changelog directly on GitHub.</Info>

<Info>
  **Stay Updated**

  Want to be notified of new releases? **Watch** the [sei-protocol/sei-chain](https://github.com/sei-protocol/sei-chain) repository on GitHub or follow the release announcements in the [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk).
</Info>

## Latest Changes

<Changelog />

---

URL: https://docs.sei.io/evm/sei-global-wallet

# Sei Global Wallet Integration Guide

> Learn how to integrate and use Sei Global Wallet, a cross-application embedded crypto wallet that provides persistent wallet experience across Sei ecosystem applications.

<Danger>By logging in with Sei Global Wallet, you agree to our [Terms of Use](https://dashboard.sei.io/terms)</Danger>

Sei Global Wallet is a cross-application embedded crypto wallet powered by [Dynamic Global Wallets](https://www.dynamic.xyz/docs/react/global-wallets/overview). It gives users a persistent wallet experience across any integrated app within the Sei ecosystem, allowing them to authenticate and interact using familiar login methods like Google, Twitter, or Telegram—no browser extension or prior crypto knowledge required.

<Info>Additional auth methods such as existing wallet apps (MetaMask, ..) are possible through Dynamic, but are not currently enabled</Info>

## What is Sei Global Wallet?

Unlike traditional browser extension wallets, Sei Global Wallet is built directly into web applications and allows users to authenticate using familiar methods like Google, Twitter, Telegram, or email—no downloads or crypto knowledge required.

## Why Use Sei Global Wallet?

**For Users:**

* **No Installation Required:** Works directly in your browser without extensions
* **Familiar Authentication:** Login with Google, Twitter, Telegram, or email
* **Persistent Across Apps:** Same wallet works across all Sei ecosystem applications
* **Self-Custodial:** You maintain full control of your keys

**For Developers:**

* **One-Line Integration:** Single import enables wallet across all EIP-6963 compatible libraries
* **Zero Configuration:** Pre-configured and ready to use
* **Universal Compatibility:** Works with RainbowKit, ConnectKit, Web3-React, and more

## How to Create a Sei Global Wallet Account

1. Visit [dashboard.sei.io](https://dashboard.sei.io) or any Sei ecosystem application
2. Click "Connect Wallet" and select "Sei Global Wallet"
3. Choose your preferred login method (Google, X, Telegram, or Email)
4. Complete the authentication flow
5. Your wallet is automatically created and ready to use across all integrated Sei apps

## How to Integrate Sei Global Wallet

### Prerequisites

**EIP-6963:** A standard that allows multiple wallets to coexist without conflicts. Instead of fighting over `window.ethereum`, wallets announce themselves through events, letting users choose which one to use.

**Dynamic:** The infrastructure powering Sei Global Wallet. It handles authentication, key management, and cross-app wallet persistence while keeping wallets non-custodial.

## Installation

Install Sei Global Wallet Package:

```bash theme={"dark"}
npm install @sei-js/sei-global-wallet
```

or

```bash theme={"dark"}
yarn add @sei-js/sei-global-wallet
```

Import the package to register the wallet:

```js theme={"dark"}
import '@sei-js/sei-global-wallet/eip6963';
```

<Warning>**Important:** Importing the package registers the wallet for discovery, but you'll need to ensure your application's provider stack is properly configured to interact with it. Most wallet connection libraries that support EIP-6963 will automatically detect the wallet after import.</Warning>

***

## Integration Examples

Below are integration examples for different frameworks and wallet provider libraries to properly integrate the pre-configured Sei Global Wallet package.

<Accordion title="RainbowKit Integration">
  **Create a new Vite app:**

  ```bash theme={"dark"}
  npm create vite@latest my-sei-dapp -- --template react-ts
  cd my-sei-dapp
  ```

  **Install Dependencies:**

  ```bash theme={"dark"}
  npm install @rainbow-me/rainbowkit wagmi viem @tanstack/react-query @sei-js/sei-global-wallet
  ```

  **Update App.tsx:**

  ```tsx theme={"dark"}
  import '@rainbow-me/rainbowkit/styles.css';
  import '@sei-js/sei-global-wallet/eip6963';

  import { ConnectButton, getDefaultConfig, RainbowKitProvider } from '@rainbow-me/rainbowkit';
  import { WagmiProvider } from 'wagmi';
  import { sei, seiTestnet } from 'wagmi/chains';
  import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
  import { useAccount, useBalance } from 'wagmi';

  const config = getDefaultConfig({
    appName: 'My Sei dApp',
    projectId: 'YOUR_WALLETCONNECT_PROJECT_ID',
    chains: [sei, seiTestnet],
    ssr: false
  });

  const queryClient = new QueryClient();

  function AccountInfo() {
    const { address, isConnected, chain } = useAccount();
    const { data: balance } = useBalance({ address });

    if (!isConnected) {
      return <p>Connect your wallet to see account details</p>;
    }

    return (
      <div className="account-info">
        <h3>Account Information</h3>
        <p>
          <strong>Address:</strong> {address}
        </p>
        <p>
          <strong>Network:</strong> {chain?.name}
        </p>
        <p>
          <strong>Balance:</strong> {balance?.formatted} {balance?.symbol}
        </p>
      </div>
    );
  }

  export default function App() {
    return (
      <WagmiProvider config={config}>
        <QueryClientProvider client={queryClient}>
          <RainbowKitProvider>
            <div className="app-container">
              <h1>My Sei dApp</h1>
              <ConnectButton />
              <AccountInfo />
            </div>
          </RainbowKitProvider>
        </QueryClientProvider>
      </WagmiProvider>
    );
  }
  ```

  **Run Your App:**

  ```bash theme={"dark"}
  npm run dev
  ```
</Accordion>

<Accordion title="ConnectKit Integration">
  **Create a new Vite app:**

  ```bash theme={"dark"}
  npm create vite@latest my-sei-dapp -- --template react-ts
  cd my-sei-dapp
  ```

  **Install Dependencies:**

  ```bash theme={"dark"}
  npm install connectkit wagmi viem @tanstack/react-query @sei-js/sei-global-wallet
  ```

  **Update App.tsx:**

  ```tsx theme={"dark"}
  import '@sei-js/sei-global-wallet/eip6963';

  import { ConnectKitButton, ConnectKitProvider, getDefaultConfig } from 'connectkit';
  import { WagmiProvider, createConfig, http } from 'wagmi';
  import { sei, seiTestnet } from 'wagmi/chains';
  import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
  import { useAccount, useBalance } from 'wagmi';

  const config = createConfig(
    getDefaultConfig({
      chains: [sei, seiTestnet],
      transports: {
        [sei.id]: http(),
        [seiTestnet.id]: http()
      },
      walletConnectProjectId: 'YOUR_WALLETCONNECT_PROJECT_ID',
      appName: 'My Sei dApp'
    })
  );

  const queryClient = new QueryClient();

  function AccountInfo() {
    const { address, isConnected, chain } = useAccount();
    const { data: balance } = useBalance({ address });

    if (!isConnected) {
      return <p>Connect your wallet to see account details</p>;
    }

    return (
      <div className="account-info">
        <h3>Account Information</h3>
        <p>
          <strong>Address:</strong> {address}
        </p>
        <p>
          <strong>Network:</strong> {chain?.name}
        </p>
        <p>
          <strong>Balance:</strong> {balance?.formatted} {balance?.symbol}
        </p>
      </div>
    );
  }

  export default function App() {
    return (
      <WagmiProvider config={config}>
        <QueryClientProvider client={queryClient}>
          <ConnectKitProvider>
            <div className="app-container">
              <h1>My Sei dApp</h1>
              <ConnectKitButton />
              <AccountInfo />
            </div>
          </ConnectKitProvider>
        </QueryClientProvider>
      </WagmiProvider>
    );
  }
  ```

  **Run Your App:**

  ```bash theme={"dark"}
  npm run dev
  ```
</Accordion>

<Accordion title="Web3-React v8 Integration">
  **Create a new Vite app:**

  ```bash theme={"dark"}
  npm create vite@latest my-sei-dapp -- --template react-ts
  cd my-sei-dapp
  ```

  **Install Dependencies:**

  ```bash theme={"dark"}
  npm install @web3-react/core @web3-react/eip1193 @web3-react/types @sei-js/sei-global-wallet
  ```

  **Update App.tsx:**

  ```tsx theme={"dark"}
  import '@sei-js/sei-global-wallet/eip6963';

  import React, { useEffect, useState } from 'react';
  import { Web3ReactProvider, initializeConnector } from '@web3-react/core';
  import { EIP1193 } from '@web3-react/eip1193';

  interface EIP6963ProviderInfo {
    uuid: string;
    name: string;
    icon: string;
    rdns: string;
  }

  interface EIP6963ProviderDetail {
    info: EIP6963ProviderInfo;
    provider: any;
  }

  function findSeiGlobalWallet(): any {
    if (typeof window === 'undefined') return null;

    const providers = new Map<string, EIP6963ProviderDetail>();

    const handleProviderAnnouncement = (event: Event) => {
      const customEvent = event as CustomEvent<EIP6963ProviderDetail>;
      providers.set(customEvent.detail.info.uuid, customEvent.detail);
    };

    window.addEventListener('eip6963:announceProvider', handleProviderAnnouncement as EventListener);

    window.dispatchEvent(new Event('eip6963:requestProvider'));
    window.removeEventListener('eip6963:announceProvider', handleProviderAnnouncement);

    for (const [uuid, provider] of providers) {
      if (provider.info.name.toLowerCase().includes('sei') || provider.info.rdns.includes('sei')) {
        return provider.provider;
      }
    }
  }

  export const [eip6963Connector, eip6963Hooks] = initializeConnector<EIP1193>((actions) => {
    const seiProvider = findSeiGlobalWallet();
    return new EIP1193({ actions, provider: seiProvider });
  });

  const connectors: [EIP1193, typeof eip6963Hooks][] = [[eip6963Connector, eip6963Hooks]];

  function InnerApp() {
    const { useAccount, useChainId, useIsActive } = eip6963Hooks;
    const account = useAccount();
    const chainId = useChainId();
    const isActive = useIsActive();
    const [isConnecting, setIsConnecting] = useState(false);

    useEffect(() => {
      const autoConnect = async () => {
        try {
          setIsConnecting(true);
          await eip6963Connector.activate();
        } catch (err) {
          console.error('Failed to connect Sei Global Wallet', err);
        } finally {
          setIsConnecting(false);
        }
      };
      autoConnect();
    }, []);

    if (!isActive) {
      return (
        <div>
          <h3>{isConnecting ? 'Connecting to Sei Global Wallet…' : 'Not Connected'}</h3>
          {!isConnecting && (
            <button onClick={() => eip6963Connector.activate()} className="connect-button">
              Connect Sei Global Wallet
            </button>
          )}
        </div>
      );
    }

    return (
      <div className="connected-info">
        <h2>✅ Connected to Sei Global Wallet!</h2>
        <p>
          <strong>Account:</strong> <code>{account}</code>
        </p>
        <p>
          <strong>Chain ID:</strong> <code>{chainId}</code>
        </p>

        <button
          onClick={() => {
            if (eip6963Connector?.deactivate) {
              eip6963Connector.deactivate();
            } else {
              eip6963Connector.resetState();
            }
          }}
          className="disconnect-button">
          Disconnect
        </button>
      </div>
    );
  }

  export default function App() {
    return (
      <Web3ReactProvider connectors={connectors}>
        <div className="app-container">
          <h1>Sei Global Wallet via EIP-6963 Discovery</h1>
          <p>This app targets the Sei Global Wallet using EIP-6963 discovery</p>
          <InnerApp />
        </div>
      </Web3ReactProvider>
    );
  }
  ```

  **Run Your App:**

  ```bash theme={"dark"}
  npm run dev
  ```
</Accordion>

<Accordion title="Wagmi + Dynamic Integration">
  **Create a new Vite app:**

  ```bash theme={"dark"}
  npm create vite@latest my-sei-dapp -- --template react-ts
  cd my-sei-dapp
  ```

  **Install Dependencies:**

  ```bash theme={"dark"}
  npm install @dynamic-labs/sdk-react-core \
    @dynamic-labs/wagmi-connector @dynamic-labs/ethereum \
    wagmi viem @tanstack/react-query @sei-js/sei-global-wallet
  ```

  **Update App.tsx:**

  ```tsx theme={"dark"}
  import React from 'react';
  import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
  import { createConfig, WagmiProvider, useAccount } from 'wagmi';
  import { http } from 'viem';
  import { sei, seiTestnet } from 'viem/chains';

  // Dynamic imports
  import { DynamicContextProvider, DynamicWidget } from '@dynamic-labs/sdk-react-core';
  import { DynamicWagmiConnector } from '@dynamic-labs/wagmi-connector';
  import { EthereumWalletConnectors } from '@dynamic-labs/ethereum';

  // Import Sei Global Wallet for EIP-6963 discovery
  import '@sei-js/sei-global-wallet/eip6963';

  const queryClient = new QueryClient();

  const wagmiConfig = createConfig({
    chains: [sei, seiTestnet],
    transports: {
      [sei.id]: http('https://evm-rpc.sei-apis.com'),
      [seiTestnet.id]: http('https://evm-rpc-testnet.sei-apis.com')
    }
  });

  export default function App() {
    return (
      <DynamicContextProvider
        settings={{
          environmentId: 'REPLACE-WITH-YOUR-ENVIRONMENT-ID', // <- Replace
          walletConnectors: [EthereumWalletConnectors],
          overrides: {
            evmNetworks: (networks) => [
              ...networks,
              {
                blockExplorerUrls: ['https://seiscan.io'],
                chainId: 1329,
                chainName: 'Sei Network',
                iconUrls: ['https://app.dynamic.xyz/assets/networks/sei.svg'],
                name: 'Sei',
                nativeCurrency: {
                  decimals: 18,
                  name: 'Sei',
                  symbol: 'SEI'
                },
                networkId: 1329,
                rpcUrls: ['https://evm-rpc.sei-apis.com'],
                vanityName: 'Sei Mainnet'
              },
              {
                blockExplorerUrls: ['https://testnet.seiscan.io'],
                chainId: 1328,
                chainName: 'Sei Testnet',
                iconUrls: ['https://app.dynamic.xyz/assets/networks/sei.svg'],
                name: 'Sei Testnet',
                nativeCurrency: {
                  decimals: 18,
                  name: 'Sei',
                  symbol: 'SEI'
                },
                networkId: 1328,
                rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
                vanityName: 'Sei Testnet'
              }
            ]
          }
        }}>
        <WagmiProvider config={wagmiConfig}>
          <QueryClientProvider client={queryClient}>
            <DynamicWagmiConnector>
              <div className="app-container">
                <h1>Dynamic + Wagmi + Sei Global Wallet</h1>
                <DynamicWidget />
                <AccountInfo />
              </div>
            </DynamicWagmiConnector>
          </QueryClientProvider>
        </WagmiProvider>
      </DynamicContextProvider>
    );
  }

  function AccountInfo() {
    const { address, isConnected, chain } = useAccount();

    if (!isConnected) {
      return <p>Connect your wallet to see account info</p>;
    }

    return (
      <div className="account-info">
        <h3>Account Information</h3>
        <p>
          <strong>Address:</strong> {address}
        </p>
        <p>
          <strong>Chain:</strong> {chain?.name} (ID: {chain?.id})
        </p>
        <p>
          <strong>Connected:</strong> {isConnected ? 'Yes' : 'No'}
        </p>
      </div>
    );
  }
  ```

  **Run Your App:**

  ```bash theme={"dark"}
  npm run dev
  ```

  **Note:** Replace `"REPLACE-WITH-YOUR-ENVIRONMENT-ID"` with your actual Dynamic environment ID from your [Dynamic dashboard](https://app.dynamic.xyz/dashboard/overview).
</Accordion>

<Accordion title="Dynamic (Next.js) Integration">
  **Create a new Next.js app:**

  ```bash theme={"dark"}
  npx create-next-app@latest my-sei-dapp --typescript --tailwind --eslint
  cd my-sei-dapp
  ```

  **Install Dependencies:**

  ```bash theme={"dark"}
  npm install @dynamic-labs/sdk-react-core \
    @dynamic-labs/wagmi-connector wagmi viem \
    @tanstack/react-query @sei-js/sei-global-wallet \
    @dynamic-labs/ethereum
  ```

  **layout.tsx:**

  ```tsx theme={"dark"}
  'use client';

  import './globals.css';
  import { Inter } from 'next/font/google';
  import Providers from './lib/providers';
  const inter = Inter({ subsets: ['latin'] });

  // Import the global wallet implementation
  import '@sei-js/sei-global-wallet/eip6963';

  export default function RootLayout({ children }: { children: React.ReactNode }) {
    return (
      <html lang="en">
        <body className={inter.className}>
          <Providers>{children}</Providers>
        </body>
      </html>
    );
  }
  ```

  **lib/providers.tsx:**

  ```tsx theme={"dark"}
  'use client';

  import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
  import { createConfig, WagmiProvider } from 'wagmi';
  import { http } from 'viem';
  import { sei, seiTestnet } from 'viem/chains';

  // Dynamic imports
  import { DynamicContextProvider, DynamicWidget } from '@dynamic-labs/sdk-react-core';
  import { DynamicWagmiConnector } from '@dynamic-labs/wagmi-connector';
  import { EthereumWalletConnectors } from '@dynamic-labs/ethereum';

  // Import Sei Global Wallet for EIP-6963 discovery
  import '@sei-js/sei-global-wallet/eip6963';

  const queryClient = new QueryClient();

  const wagmiConfig = createConfig({
    chains: [sei, seiTestnet],
    transports: {
      [sei.id]: http('https://evm-rpc.sei-apis.com'),
      [seiTestnet.id]: http('https://evm-rpc-testnet.sei-apis.com')
    }
  });

  export default function Providers({ children }: { children: React.ReactNode }) {
    return (
      <DynamicContextProvider
        settings={{
          environmentId: 'REPLACE-WITH-YOUR-ENVIRONMENT-ID', // Replace with your environmentId
          walletConnectors: [EthereumWalletConnectors],
          overrides: {
            evmNetworks: (networks) => [
              ...networks,
              {
                blockExplorerUrls: ['https://seiscan.io'],
                chainId: 1329,
                chainName: 'Sei Network',
                iconUrls: ['https://app.dynamic.xyz/assets/networks/sei.svg'],
                name: 'Sei',
                nativeCurrency: {
                  decimals: 18,
                  name: 'Sei',
                  symbol: 'SEI'
                },
                networkId: 1329,
                rpcUrls: ['https://evm-rpc.sei-apis.com'],
                vanityName: 'Sei Mainnet'
              },
              {
                blockExplorerUrls: ['https://testnet.seiscan.io'],
                chainId: 1328,
                chainName: 'Sei Testnet',
                iconUrls: ['https://app.dynamic.xyz/assets/networks/sei.svg'],
                name: 'Sei Testnet',
                nativeCurrency: {
                  decimals: 18,
                  name: 'Sei',
                  symbol: 'SEI'
                },
                networkId: 1328,
                rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
                vanityName: 'Sei Testnet'
              }
            ]
          }
        }}>
        <WagmiProvider config={wagmiConfig}>
          <QueryClientProvider client={queryClient}>
            <DynamicWagmiConnector>{children}</DynamicWagmiConnector>
          </QueryClientProvider>
        </WagmiProvider>
      </DynamicContextProvider>
    );
  }
  ```

  **Note:** Replace `"REPLACE-WITH-YOUR-ENVIRONMENT-ID"` with your actual Dynamic environment ID from your [Dynamic dashboard](https://app.dynamic.xyz/dashboard/overview).

  **page.tsx**

  ```tsx theme={"dark"}
  'use client';

  import { DynamicWidget } from '@dynamic-labs/sdk-react-core';
  import { useAccount, useBalance } from 'wagmi';

  export default function Home() {
    return (
      <main className="container mx-auto px-4 py-8">
        <div className="max-w-2xl mx-auto space-y-6">
          <h1 className="text-3xl font-bold text-center">Dynamic with Next.js</h1>

          <div className="flex justify-center">
            <DynamicWidget />
          </div>
        </div>
      </main>
    );
  }
  ```

  **Run Your App:**

  ```bash theme={"dark"}
  npm run dev
  ```
</Accordion>

<Accordion title="HTML Bundle Integration">
  For projects using plain HTML/JavaScript without a build system, you can create a bundled version of Sei Global Wallet to include directly in your HTML pages.

  **Create Bundle Directory**

  ```bash theme={"dark"}
  mkdir sei-global-wallet-bundle
  cd sei-global-wallet-bundle
  ```

  **Initialize npm Project**

  ```bash theme={"dark"}
  npm init -y
  ```

  **Install Dependencies**

  ```bash theme={"dark"}
  npm install @sei-js/sei-global-wallet
  ```

  ```bash theme={"dark"}
  npm install --save-dev esbuild
  ```

  **Create Bundle Source File**
  Create bundle.js:

  ```js theme={"dark"}
  // bundle.js
  import '@sei-js/sei-global-wallet/eip6963';
  ```

  **Update package.json**
  Add this build script to your package.json:

  ```json theme={"dark"}
  {
    "scripts": {
      "build": "esbuild bundle.js --bundle --format=iife --outfile=sei-wallet-bundled.js"
    }
  }
  ```

  **Build the Bundle**

  ```bash theme={"dark"}
  npm run build
  ```

  This creates sei-wallet-bundled.js

  **Use in Your HTML Project**

  Copy sei-wallet-bundled.js to your web project and use it:

  ```html theme={"dark"}
  <!DOCTYPE html>
  <html lang="en">
    <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <title>Sei Global Wallet HTML Integration</title>
    </head>
    <body>
      <h1>Sei Global Wallet HTML Integration</h1>
      <p>Connect your Sei Global Wallet using plain HTML and JavaScript.</p>

      <button onclick="scanForWallets()" id="scanBtn">🔍 Scan for Wallets</button>
      <button onclick="connectToSei()" id="connectBtn" disabled>🔗 Connect to Sei</button>

      <div id="walletList"></div>
      <div id="accountInfo"></div>

      <!-- Load the bundled Sei wallet file -->
      <script src="./sei-wallet-bundled.js"></script>

      <script>
        let detectedWallets = [];

        function scanForWallets() {
          console.log('Scanning for EIP-6963 wallets...');
          detectedWallets = [];

          document.getElementById('walletList').innerHTML = '<p>Scanning for wallets...</p>';

          const handleWalletAnnouncement = (event) => {
            const wallet = event.detail;
            if (!detectedWallets.find((w) => w.info.uuid === wallet.info.uuid)) {
              detectedWallets.push(wallet);
              updateWalletList();
            }
          };

          window.addEventListener('eip6963:announceProvider', handleWalletAnnouncement);
          window.dispatchEvent(new Event('eip6963:requestProvider'));

          setTimeout(() => {
            window.removeEventListener('eip6963:announceProvider', handleWalletAnnouncement);
            if (detectedWallets.length === 0) {
              document.getElementById('walletList').innerHTML = '<p>No wallets detected</p>';
            }
          }, 2000);
        }

        function updateWalletList() {
          const walletListDiv = document.getElementById('walletList');
          walletListDiv.innerHTML =
            `<h3>Detected Wallets:</h3>` +
            detectedWallets
              .map((wallet) => {
                const isSeiWallet = wallet.info.name.toLowerCase().includes('sei');
                return `<div>
                          <strong>${wallet.info.name}</strong> ${isSeiWallet ? '🎯' : ''}
                          <br><small>${wallet.info.rdns}</small>
                      </div>`;
              })
              .join('');

          const seiWallet = detectedWallets.find((w) => w.info.name.toLowerCase().includes('sei'));
          if (seiWallet) {
            document.getElementById('connectBtn').disabled = false;
          }
        }

        async function connectToSei() {
          const seiWallet = detectedWallets.find((w) => w.info.name.toLowerCase().includes('sei'));

          if (!seiWallet) {
            console.error('No Sei wallet found');
            return;
          }

          try {
            const accounts = await seiWallet.provider.request({
              method: 'eth_requestAccounts'
            });

            if (accounts && accounts.length > 0) {
              document.getElementById('accountInfo').innerHTML = `
                          <div>
                              <h3>👤 Connected Account</h3>
                              <p><strong>Wallet:</strong> ${seiWallet.info.name}</p>
                              <p><strong>Address:</strong> ${accounts[0]}</p>
                              <p><strong>Status:</strong> ✅ Connected successfully!</p>
                          </div>`;
            }
          } catch (error) {
            alert(`Connection failed: ${error.message}`);
          }
        }

        window.addEventListener('load', () => {
          setTimeout(scanForWallets, 500);
        });
      </script>
    </body>
  </html>
  ```
</Accordion>

<Accordion title="Web3Auth Integration">
  **Create a new Vite app:**

  ```bash theme={"dark"}
  npm create vite@latest my-sei-dapp -- --template react-ts
  cd my-sei-dapp
  ```

  **Install Dependencies:**

  ```bash theme={"dark"}
  npm install @web3auth/modal \
    wagmi viem @tanstack/react-query \
    @sei-js/sei-global-wallet
  ```

  **Create Web3Auth Context (src/web3authContext.ts):**

  ```ts theme={"dark"}
  import '@sei-js/sei-global-wallet/eip6963';
  import { WEB3AUTH_NETWORK } from '@web3auth/modal';
  import { type Web3AuthContextConfig } from '@web3auth/modal/react';

  const clientId = 'YOUR_CLIENT_ID'; // get from https://dashboard.web3auth.io

  const web3AuthContextConfig: Web3AuthContextConfig = {
    web3AuthOptions: {
      clientId,
      web3AuthNetwork: WEB3AUTH_NETWORK.SAPPHIRE_DEVNET
    }
  };

  export default web3AuthContextConfig;
  ```

  **Update App.tsx:**

  ```tsx theme={"dark"}
  import './App.css';
  import '@sei-js/sei-global-wallet/eip6963';
  import { useWeb3AuthConnect, useWeb3AuthUser } from '@web3auth/modal/react';
  import { useWeb3AuthDisconnect } from '@web3auth/modal/react';
  import { useAccount } from 'wagmi';

  function App() {
    const { connect, isConnected, connectorName } = useWeb3AuthConnect();

    const { loading: connectLoading, error: connectError } = useWeb3AuthConnect();

    const { disconnect, loading: disconnectLoading } = useWeb3AuthDisconnect();

    const { error: disconnectError } = useWeb3AuthDisconnect();

    const { userInfo } = useWeb3AuthUser();
    const { address } = useAccount();

    function uiConsole(...args: any[]): void {
      const el = document.querySelector('#console>p');
      if (el) {
        el.innerHTML = JSON.stringify(args || {}, null, 2);
        console.log(...args);
      }
    }
    const loggedInView = (
      <div className="grid">
        <h2>Connected to {connectorName}</h2>
        <div className="account-info">
          <p>
            <strong>Address:</strong> {address}
          </p>
        </div>

        <div className="flex-container">
          <button onClick={() => uiConsole(userInfo)} className="card">
            Get User Info
          </button>

          <button onClick={() => disconnect()} className="card">
            Log Out
          </button>
        </div>

        {disconnectLoading && <div className="loading">Disconnecting...</div>}
        {disconnectError && <div className="error">{disconnectError.message}</div>}
      </div>
    );

    const unloggedInView = (
      <div className="grid">
        <button onClick={() => connect()} className="card">
          Connect with Web3Auth
        </button>
        {connectLoading && <div className="loading">Connecting...</div>}
        {connectError && <div className="error">{connectError.message}</div>}
      </div>
    );

    return (
      <div className="container">
        <h1 className="title">
          <a target="_blank" href="https://web3auth.io/docs/sdk/pnp/web/modal" rel="noreferrer">
            Web3Auth
          </a>{' '}
          + Sei Global Wallet Integration
        </h1>

        {isConnected ? loggedInView : unloggedInView}

        <div id="console" style={{ whiteSpace: 'pre-line' }}>
          <p style={{ whiteSpace: 'pre-line' }}></p>
        </div>
      </div>
    );
  }

  export default App;
  ```

  **Setup your main.tsx with Web3Auth Provider:**

  ```tsx theme={"dark"}
  import { StrictMode } from 'react';
  import { createRoot } from 'react-dom/client';
  import { Web3AuthProvider } from '@web3auth/modal/react';
  import { WagmiProvider } from 'wagmi';
  import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
  import { createConfig, http } from 'wagmi';
  import { sei, seiTestnet } from 'wagmi/chains';
  import web3AuthContextConfig from './web3authContext';
  import App from './App';

  const queryClient = new QueryClient();

  const wagmiConfig = createConfig({
    chains: [sei, seiTestnet],
    transports: {
      [sei.id]: http('https://evm-rpc.sei-apis.com'),
      [seiTestnet.id]: http('https://evm-rpc-testnet.sei-apis.com')
    }
  });

  createRoot(document.getElementById('root')!).render(
    <StrictMode>
      <Web3AuthProvider config={web3AuthContextConfig}>
        <WagmiProvider config={wagmiConfig}>
          <QueryClientProvider client={queryClient}>
            <App />
          </QueryClientProvider>
        </WagmiProvider>
      </Web3AuthProvider>
    </StrictMode>
  );
  ```

  **Run Your App:**

  ```bash theme={"dark"}
  npm run dev
  ```

  **Note:** Replace the `clientId` in `web3authContext.ts` with your actual Web3Auth client ID from your [Web3Auth Dashboard](https://dashboard.web3auth.io).
</Accordion>

## Troubleshooting & FAQ

<Tabs>
  <Tab title="Troubleshooting">
    ### Troubleshooting & Debugging Tips

    #### Common Issues

    **Issue:** Sei Global Wallet doesn't appear in wallet list

    ```bash theme={"dark"}
    # Ensure the import is at the top of your App.tsx
    import '@sei-js/sei-global-wallet/eip6963';
    ```

    **Issue:** TypeScript errors about `window.ethereum`

    ```typescript theme={"dark"}
    // Add this to your App.tsx or create types/global.d.ts
    declare global {
      interface Window {
        ethereum?: any;
      }
    }
    ```

    **Issue:** WalletConnect connection fails

    ```bash theme={"dark"}
    # Get a proper project ID from cloud.walletconnect.com
    # Replace 'YOUR_WALLETCONNECT_PROJECT_ID' with your actual ID
    ```

    **Issue:** Network not found in MetaMask

    ```javascript theme={"dark"}
    // Use the exact chainId in hex format
    chainId: '0x531'; // for Sei Mainnet (1329)
    chainId: '0x530'; // for Sei Testnet (1328)
    ```

    ### Debugging Commands

    ```javascript theme={"dark"}
    // Check if EIP-6963 events are firing
    console.log('EIP-6963 providers:', window.eip6963Providers);

    // Listen for wallet announcements
    window.addEventListener('eip6963:announceProvider', (event) => {
      console.log('Wallet announced:', event.detail);
    });

    // Request wallet announcements
    window.dispatchEvent(new Event('eip6963:requestProvider'));
    ```

    ### Testing Tips

    1. **Test with multiple browsers** to ensure cross-browser compatibility
    2. **Clear browser cache** if wallets aren't appearing
    3. **Check browser console** for EIP-6963 events and errors
    4. **Test both testnet and mainnet** connections
    5. **Verify social login methods** work across different auth providers

    ### Security Considerations

    * Sei Global Wallet is **self-custodial** - users control their private keys
    * All communications between app and wallet are **encrypted**
    * **Multi-factor authentication** is available for enhanced security
    * Keys can be **exported** to other wallets like MetaMask
    * Platform has been **audited by Cure53** for security compliance
  </Tab>

  <Tab title="FAQ">
    ### FAQ

    #### Q: What is Sei Global Wallet?

    Sei Global Wallet is an embedded wallet experience for the Sei network, enabling wallet creation and authentication through social logins. Unlike traditional embedded wallets, Sei Global Wallet offer greater flexibility by allowing users to carry their wallets across different apps within the Sei ecosystem.

    #### Q: What are the key benefits of Sei Global Wallet for developers and users?

    **For Developers:**

    * **Sei ecosystem front and center:** Add Sei as a login method to your app ("Log in with Sei")
    * **Simple integration:** Compatible with tools like RainbowKit, ConnectKit, and Web3-React
    * **Enhanced security:** Multi-factor authentication (MFA) and secure key management

    **For Users:**

    * **Simplified onboarding:** Create wallets using familiar social logins
    * **Cross-app connectivity:** Navigate seamlessly across Sei ecosystem applications
    * **User-friendly flows:** Transaction simulation helps users understand impacts before confirmation

    #### Q: What login methods are currently supported?

    Sei Global Wallet support email, Google, X (Twitter), and Telegram authentication.

    #### Q: How do the security considerations differ from traditional wallets?

    Key security differences include:

    * **Secure encrypted communication:** All communication between app and wallet popup is encrypted
    * **Protection against replay attacks:** Encrypted messaging prevents malicious reuse of data
    * **Trusted Execution Environments (TEEs):** Operations occur within secure environments
    * **Verified origins:** Only verified origins can interact with Sei Global Wallet

    #### Q: Is Sei Global Wallet self-custodial or custodial?

    Sei Global Wallet is self-custodial, giving full control to end-users. Users can export their keys at any time and import them into other wallets, such as MetaMask.

    #### Q: Do Sei Global Wallet require browser extensions?

    No, they operate as embedded wallets that work directly in the browser without requiring extensions.

    #### Q: Can I link my existing external wallet to my Sei Global Wallet?

    Not currently. In the future, you will be able to link external wallets to a Sei global account.

    #### Q: What extra protections can I add to my Sei Global Wallet?

    While Global Wallets are non-custodial, good security practices include:

    * **Enable multi-factor authentication (MFA)** for sensitive actions
    * **Be wary of phishing attempts** - verify sources before sharing information
    * **Always have backup methods** - link additional email or social login methods
    * **Never store authentication keys digitally** - keep private keys secure offline

    #### Q: Have Sei Global Wallet been audited?

    Yes, the Dynamic Global Wallets product has been audited by Cure53.

    #### Q: How should bugs be reported?

    Please provide:

    * Device details
    * Browser information
    * Clear description of the issue
    * If possible, a Loom video or screen recording
  </Tab>
</Tabs>

## References and Links

* [Dynamic Global Wallet Documentation](https://www.dynamic.xyz/docs/react/global-wallets/overview)
* [EIP-6963 Standard](https://eips.ethereum.org/EIPS/eip-6963)
* [RainbowKit Documentation](https://www.rainbowkit.com/docs/introduction)
* [ConnectKit Documentation](https://docs.family.co/connectkit)
* [Web3-React Documentation](https://github.com/Uniswap/web3-react)
* [Wagmi Documentation](https://wagmi.sh)
* [WalletConnect Cloud](https://cloud.walletconnect.com)

---

URL: https://docs.sei.io/evm/building-a-frontend

# Building a Frontend for Sei EVM: A Comprehensive Guide

> Comprehensive guide on Building a Frontend for Sei EVM. Learn key concepts, commands, and best practices.

Developing the frontend of a dApp on Sei EVM involves connecting to wallets, interacting with the blockchain via RPC endpoints, and signing and broadcasting transactions. This tutorial will demonstrate how to build a simple ERC20 token interface using three popular libraries:

1. [**Ethers.js**](https://docs.ethers.org/v6/) - A complete and compact library for interacting with
   EVM blockchains. Known for its simplicity and extensive functionality.
2. [**Viem**](https://viem.sh/docs/getting-started) - A lightweight and modular TypeScript interface for Ethereum
3. [**Wagmi**](https://wagmi.sh/) - A React hooks library built on top of Viem that simplifies wallet
   connection and interaction. Provides hooks for interacting with Ethereum
   wallets and contracts for use with modern frontend libraries and frameworks.

We'll implement the same functionality using each library so you can compare their approaches and choose the one that best fits your development style.

<Tip>
  **Deploy to Testnet First**

  It is <strong>highly recommended</strong> that you deploy to <em>testnet (atlantic-2)</em> first and verify everything works as expected before committing to mainnet. Doing so helps you catch bugs early, avoid unnecessary gas costs, and keep your users safe.
</Tip>

## When to Use Each Library

### Ethers.js

Ethers.js is ideal for developers who want a comprehensive, battle-tested library with straightforward API design. It's great for both simple and complex dApps, especially when you're not using React or need custom state management.

* **Pros**:
  * Comprehensive and easy-to-use API
  * Well-documented with a large community
  * Works well with both TypeScript and JavaScript
  * All-in-one solution for wallet connection and contract interaction
* **Cons**:
  * Larger bundle size compared to Viem
  * Not specifically designed for React hooks integration

### Viem

Viem is perfect for developers who want fine-grained control over their blockchain interactions and appreciate a modular, lightweight approach. It's a good choice when bundle size matters and when you have specific requirements for how contract interactions should work.

* **Pros**:
  * Lightweight and modular
  * Excellent TypeScript support with better type safety
  * Lower-level API gives more control
  * Smaller bundle size
* **Cons**:
  * Steeper learning curve
  * Requires more boilerplate code for some operations
  * Requires separate handling for wallet connection and contract interactions

### Wagmi

Wagmi is the best choice for React developers building dApps who want to leverage React's state management capabilities. It abstracts away much of the complexity of blockchain interactions via hooks, making it easy to build reactive UIs that respond to chain state.

* **Pros**:
  * React-specific hooks for seamless integration
  * Handles complex state management for you
  * Built on top of Viem, combining its benefits
  * Convenient caching and auto-refreshing for contract data
* **Cons**:
  * Only works with React
  * Adds another dependency layer
  * Opinionated about how data should be managed in your app

## Requirements

Before starting, ensure you have:

* Node.js & NPM installed
* One of the Sei wallets listed [here](/learn/wallets)

## Creating a React Project

Start by creating a new React project using Vite's TypeScript template for streamlined development:

```bash theme={"dark"}
npm create vite@latest sei-token-interface -- --template react-ts
```

This command creates a new folder with a React project using TypeScript. Open `sei-token-interface` in your favorite IDE.

<Info>This tutorial uses TypeScript. If you're not using TypeScript, you can easily adjust by removing the types.</Info>

## Project Structure

For clarity, we'll create separate components for each library implementation. First, let's set up the project structure:

```bash theme={"dark"}
cd sei-token-interface
mkdir src/components
touch src/components/EthersInterface.tsx
touch src/components/ViemInterface.tsx
touch src/components/WagmiInterface.tsx
mkdir src/shared
touch src/shared/constants.ts
touch src/wagmi.ts
```

## Defining the ERC20 Contract Details

<Info>Make sure to deploy your ERC20 token contract first — for example with [Hardhat](/evm/evm-hardhat) or [Foundry](/evm/evm-foundry), or generate one with the [contract wizard](/evm/evm-wizard) (see also [deploy & verify](/evm/evm-parity/examples/deploy-verify)) — and replace `TOKEN_CONTRACT_ADDRESS` in the constants file with your actual deployed contract address, and update the RPC URL in the Sei chain configuration. You can find a list of existing ERC20 contracts on Sei Mainnet here: [Sei Assets](https://seiscan.io/tokens)</Info>

Let's create a shared constants file for our project:

```tsx title="src/shared/constants.ts" theme={"dark"}
// Constants used across different implementations
export const ERC20_ABI = [
  {
    inputs: [],
    name: 'name',
    outputs: [
      {
        internalType: 'string',
        name: '',
        type: 'string'
      }
    ],
    stateMutability: 'view',
    type: 'function'
  },
  {
    inputs: [],
    name: 'symbol',
    outputs: [
      {
        internalType: 'string',
        name: '',
        type: 'string'
      }
    ],
    stateMutability: 'view',
    type: 'function'
  },
  {
    inputs: [],
    name: 'decimals',
    outputs: [
      {
        internalType: 'uint8',
        name: '',
        type: 'uint8'
      }
    ],
    stateMutability: 'view',
    type: 'function'
  },
  {
    inputs: [
      {
        internalType: 'address',
        name: 'account',
        type: 'address'
      }
    ],
    name: 'balanceOf',
    outputs: [
      {
        internalType: 'uint256',
        name: '',
        type: 'uint256'
      }
    ],
    stateMutability: 'view',
    type: 'function'
  },
  {
    inputs: [
      {
        internalType: 'address',
        name: 'to',
        type: 'address'
      },
      {
        internalType: 'uint256',
        name: 'amount',
        type: 'uint256'
      }
    ],
    name: 'transfer',
    outputs: [
      {
        internalType: 'bool',
        name: '',
        type: 'bool'
      }
    ],
    stateMutability: 'nonpayable',
    type: 'function'
  },
  {
    anonymous: false,
    inputs: [
      {
        indexed: true,
        internalType: 'address',
        name: 'from',
        type: 'address'
      },
      {
        indexed: true,
        internalType: 'address',
        name: 'to',
        type: 'address'
      },
      {
        indexed: false,
        internalType: 'uint256',
        name: 'value',
        type: 'uint256'
      }
    ],
    name: 'Transfer',
    type: 'event'
  }
];

// TODO: Deploy an ERC-20 (see /evm/evm-hardhat or /evm/evm-foundry) and paste its address here
export const TOKEN_CONTRACT_ADDRESS = '0xYourTokenContractAddress';
```

## Option 1: Ethers.js Implementation

Install ethers.js first:

```bash theme={"dark"}
npm install ethers
```

Let's start with the Ethers.js implementation:

* Checks for any EVM compatible wallet extension.
* Establishes a connection to Sei Mainnet via the connected wallet,
  using ethers.js BrowserProvider.
* Creates an ethers.js contract instance with the signer from the wallet,
  setting it in the contract state for later use.

```tsx title="src/components/EthersInterface.tsx" theme={"dark"}
import { useState, useEffect } from 'react';
import { BrowserProvider, Contract, formatEther, parseEther } from 'ethers';
import { ERC20_ABI, TOKEN_CONTRACT_ADDRESS } from '../shared/constants';

export function EthersInterface() {
  const [balance, setBalance] = useState<string>();
  const [contract, setContract] = useState<Contract>();
  const [recipientAddress, setRecipientAddress] = useState('');
  const [amount, setAmount] = useState('');
  const [isTransferring, setIsTransferring] = useState(false);
  const [tokenInfo, setTokenInfo] = useState<{ name: string; symbol: string }>();
  const [address, setAddress] = useState<string>();

  // Sei EVM network configuration
  const SEI_NETWORK_PARAMS = {
    chainId: '0x531', // 1329 in hexadecimal
    chainName: 'Sei Network',
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    blockExplorerUrls: ['https://seiscan.io']
  };

  const fetchBalance = async () => {
    if (!contract || !address) return;
    try {
      const balance = await contract.balanceOf(address);
      setBalance(formatEther(balance));
    } catch (error) {
      console.error('Failed to fetch balance:', error);
    }
  };

  const fetchTokenInfo = async () => {
    if (!contract) return;
    try {
      const name = await contract.name();
      const symbol = await contract.symbol();
      setTokenInfo({ name, symbol });
    } catch (error) {
      console.error('Failed to fetch token info:', error);
    }
  };

  useEffect(() => {
    if (contract) {
      fetchTokenInfo();
      fetchBalance();
    }
  }, [contract, address]);

  const connectWallet = async () => {
    if (window.ethereum) {
      try {
        const provider = new BrowserProvider(window.ethereum);
        // Attempt to switch to the Sei network
        try {
          await provider.send('wallet_switchEthereumChain', [{ chainId: SEI_NETWORK_PARAMS.chainId }]);
        } catch (switchError: any) {
          // Error code 4902 indicates the chain is not added in MetaMask
          if (switchError.code === 4902) {
            await provider.send('wallet_addEthereumChain', [SEI_NETWORK_PARAMS]);
          } else {
            throw switchError;
          }
        }
        // Request account access
        await provider.send('eth_requestAccounts', []);
        const signer = await provider.getSigner();
        const userAddress = await signer.getAddress();
        setAddress(userAddress);
        const tokenContract = new Contract(TOKEN_CONTRACT_ADDRESS, ERC20_ABI, signer);
        setContract(tokenContract);
      } catch (error) {
        console.error('Failed to connect wallet:', error);
        alert('Failed to connect wallet. See console for details.');
      }
    } else {
      alert('No EVM compatible wallet installed');
    }
  };

  const transferTokens = async () => {
    if (!contract || !recipientAddress || !amount) return;
    try {
      setIsTransferring(true);
      const tx = await contract.transfer(recipientAddress, parseEther(amount));
      console.log('Transaction sent:', tx.hash);
      const receipt = await tx.wait();
      console.log('Transaction confirmed:', receipt);
      await fetchBalance();
      setRecipientAddress('');
      setAmount('');
    } catch (error) {
      console.error('Transfer failed:', error);
      alert('Transfer failed. Check console for details.');
    } finally {
      setIsTransferring(false);
    }
  };

  return (
    <div className="card">
      <h2>Ethers.js v6 Implementation</h2>
      {contract ? (
        <div>
          <h3>
            {tokenInfo?.name} ({tokenInfo?.symbol})
          </h3>
          <p>
            Connected Address: {address?.slice(0, 6)}...{address?.slice(-4)}
          </p>
          <p>
            Balance: {balance} {tokenInfo?.symbol}
          </p>
          <div style={{ marginTop: '20px' }}>
            <input type="text" placeholder="Recipient Address" value={recipientAddress} onChange={(e) => setRecipientAddress(e.target.value)} style={{ marginBottom: '10px', width: '300px' }} />
            <br />
            <input type="number" placeholder="Amount" value={amount} onChange={(e) => setAmount(e.target.value)} style={{ marginBottom: '10px', width: '300px' }} />
            <br />
            <button disabled={isTransferring} onClick={transferTokens}>
              {isTransferring ? 'Transferring...' : 'Transfer Tokens'}
            </button>
          </div>
        </div>
      ) : (
        <button onClick={connectWallet}>Connect with Ethers.js v6</button>
      )}
    </div>
  );
}
```

## Option 2: Viem Implementation

Install Viem first:

```bash theme={"dark"}
npm install viem
```

Now implement the Viem interface:

```tsx title="src/components/ViemInterface.tsx" theme={"dark"}
import { useState, useEffect } from 'react';
import { createWalletClient, custom, parseEther, formatEther } from 'viem';
import { createPublicClient, http } from 'viem';
import { sei } from 'viem/chains';
import { ERC20_ABI, TOKEN_CONTRACT_ADDRESS } from '../shared/constants';

export function ViemInterface() {
  const [balance, setBalance] = useState<string>();
  const [address, setAddress] = useState<string>();
  const [walletClient, setWalletClient] = useState<any>(null);
  const [publicClient, setPublicClient] = useState<any>(null);
  const [recipientAddress, setRecipientAddress] = useState('');
  const [amount, setAmount] = useState('');
  const [isTransferring, setIsTransferring] = useState(false);
  const [tokenInfo, setTokenInfo] = useState<{ name: string; symbol: string }>();

  useEffect(() => {
    // Initialize the public client
    const newPublicClient = createPublicClient({
      chain: sei,
      transport: http()
    });
    setPublicClient(newPublicClient);
  }, []);

  useEffect(() => {
    if (walletClient && publicClient && address) {
      fetchTokenInfo();
      fetchBalance();
    }
  }, [walletClient, publicClient, address]);

  const fetchBalance = async () => {
    if (!publicClient || !address) return;

    try {
      const balance = await publicClient.readContract({
        address: TOKEN_CONTRACT_ADDRESS as `0x${string}`,
        abi: ERC20_ABI,
        functionName: 'balanceOf',
        args: [address]
      });

      setBalance(formatEther(balance as bigint));
    } catch (error) {
      console.error('Error fetching balance:', error);
    }
  };

  const fetchTokenInfo = async () => {
    if (!publicClient) return;

    try {
      const [name, symbol] = await Promise.all([
        publicClient.readContract({
          address: TOKEN_CONTRACT_ADDRESS,
          abi: ERC20_ABI,
          functionName: 'name'
        }),
        publicClient.readContract({
          address: TOKEN_CONTRACT_ADDRESS,
          abi: ERC20_ABI,
          functionName: 'symbol'
        })
      ]);

      setTokenInfo({ name: name as string, symbol: symbol as string });
    } catch (error) {
      console.error('Error fetching token info:', error);
    }
  };
  const connectWallet = async () => {
    if (!window.ethereum) {
      alert('No EVM compatible wallet installed');
      return;
    }

    try {
      const [userAddress] = await window.ethereum.request({
        method: 'eth_requestAccounts'
      });

      setAddress(userAddress);

      const newWalletClient = createWalletClient({
        chain: sei,
        transport: custom(window.ethereum)
      });

      setWalletClient(newWalletClient);
    } catch (error) {
      console.error('Failed to connect wallet:', error);
      alert('Failed to connect wallet. See console for details.');
    }
  };

  const transferTokens = async () => {
    if (!walletClient || !address || !recipientAddress || !amount) return;

    try {
      setIsTransferring(true);

      // Prepare the contract call parameters
      const abi = ERC20_ABI;
      const functionName = 'transfer';
      const args = [recipientAddress, parseEther(amount)];

      // Execute the transaction
      const hash = await walletClient.writeContract({
        address: TOKEN_CONTRACT_ADDRESS as `0x${string}`,
        abi,
        functionName,
        args
      });

      console.log('Transaction sent:', hash);

      // Wait for the transaction to be mined
      const receipt = await publicClient.waitForTransactionReceipt({ hash });
      console.log('Transaction confirmed:', receipt);

      // Refresh the balance
      await fetchBalance();

      // Reset form
      setRecipientAddress('');
      setAmount('');
    } catch (error) {
      console.error('Transfer failed:', error);
      alert('Transfer failed. Check console for details.');
    } finally {
      setIsTransferring(false);
    }
  };

  return (
    <div className="card">
      <h2>Viem Implementation</h2>
      {address ? (
        <div>
          <h3>
            {tokenInfo?.name} ({tokenInfo?.symbol})
          </h3>
          <p>
            Connected Address: {address.slice(0, 6)}...{address.slice(-4)}
          </p>
          <p>
            Balance: {balance} {tokenInfo?.symbol}
          </p>
          <div style={{ marginTop: '20px' }}>
            <input type="text" placeholder="Recipient Address" value={recipientAddress} onChange={(e) => setRecipientAddress(e.target.value)} style={{ marginBottom: '10px', width: '300px' }} />
            <br />
            <input type="number" placeholder="Amount" value={amount} onChange={(e) => setAmount(e.target.value)} style={{ marginBottom: '10px', width: '300px' }} />
            <br />
            <button disabled={isTransferring} onClick={transferTokens}>
              {isTransferring ? 'Transferring...' : 'Transfer Tokens'}
            </button>
          </div>
        </div>
      ) : (
        <button onClick={connectWallet}>Connect with Viem</button>
      )}
    </div>
  );
}
```

## Option 3: Wagmi Implementation

Install Wagmi and configure it:

```bash theme={"dark"}
npm install wagmi viem @tanstack/react-query
```

First, let's create a Wagmi configuration file:

```tsx title="src/wagmi.ts" theme={"dark"}
import { http, createConfig } from 'wagmi';
import { sei, seiTestnet } from 'wagmi/chains';
import { injected } from 'wagmi/connectors';

export const config = createConfig({
  chains: [sei, seiTestnet],
  connectors: [injected()],
  transports: {
    [sei.id]: http(),
    [seiTestnet.id]: http()
  }
});
```

Now implement the Wagmi interface:

```tsx title="src/components/WagmiInterface.tsx" theme={"dark"}
import { useState, useEffect } from 'react';
import { useAccount, useConnect, useReadContract, useWriteContract, useWaitForTransactionReceipt } from 'wagmi';
import { injected } from 'wagmi/connectors';
import { parseEther, formatEther } from 'viem';
import { ERC20_ABI, TOKEN_CONTRACT_ADDRESS } from '../shared/constants';

export function WagmiInterface() {
  const [recipientAddress, setRecipientAddress] = useState('');
  const [amount, setAmount] = useState('');

  // Wagmi hooks
  const { address, isConnected } = useAccount();
  const { connect } = useConnect();

  // For debugging
  console.log('Connection status:', { address, isConnected });

  // Read from contract
  const { data: name } = useReadContract({
    address: TOKEN_CONTRACT_ADDRESS as `0x${string}`,
    abi: ERC20_ABI,
    functionName: 'name'
  });

  const { data: symbol } = useReadContract({
    address: TOKEN_CONTRACT_ADDRESS as `0x${string}`,
    abi: ERC20_ABI,
    functionName: 'symbol'
  });

  const { data: balance, refetch: refetchBalance } = useReadContract({
    address: TOKEN_CONTRACT_ADDRESS as `0x${string}`,
    abi: ERC20_ABI,
    functionName: 'balanceOf',
    args: address ? [address] : undefined,
    query: {
      enabled: !!address
    }
  });

  // Write to contract
  const { writeContract, data: hash, isPending: isTransferring, error } = useWriteContract();

  // Wait for transaction
  const { isLoading: isConfirming, isSuccess: isConfirmed } = useWaitForTransactionReceipt({
    hash
  });

  // Connect wallet
  const connectWallet = async () => {
    try {
      connect({ connector: injected() });
    } catch (err) {
      console.error('Failed to connect:', err);
    }
  };

  // Transfer tokens
  const transferTokens = async () => {
    if (!recipientAddress || !amount) return;
    try {
      writeContract({
        address: TOKEN_CONTRACT_ADDRESS as `0x${string}`,
        abi: ERC20_ABI,
        functionName: 'transfer',
        args: [recipientAddress, parseEther(amount)]
      });
    } catch (err) {
      console.error('Transfer failed:', err);
    }
  };

  // Handle successful transfer
  useEffect(() => {
    if (isConfirmed) {
      refetchBalance();
      setRecipientAddress('');
      setAmount('');
    }
  }, [isConfirmed, refetchBalance]);

  return (
    <div className="card">
      <h2>Wagmi Implementation</h2>
      {isConnected ? (
        <div>
          <h3>
            {(name as string) || 'Loading...'} ({(symbol as string) || '...'})
          </h3>
          <p>
            Connected Address: {address?.slice(0, 6)}...{address?.slice(-4)}
          </p>
          <p>
            Balance: {balance ? formatEther(balance as bigint) : '0'} {(symbol as string) || ''}
          </p>
          <div style={{ marginTop: '20px' }}>
            <input type="text" placeholder="Recipient Address" value={recipientAddress} onChange={(e) => setRecipientAddress(e.target.value)} style={{ marginBottom: '10px', width: '300px' }} />
            <br />
            <input type="number" placeholder="Amount" value={amount} onChange={(e) => setAmount(e.target.value)} style={{ marginBottom: '10px', width: '300px' }} />
            <br />
            <button disabled={isTransferring || isConfirming} onClick={transferTokens}>
              {isTransferring ? 'Preparing Transaction...' : isConfirming ? 'Confirming Transaction...' : 'Transfer Tokens'}
            </button>
            {error && <p style={{ color: 'red' }}>Error: {(error as Error).message}</p>}
          </div>
        </div>
      ) : (
        <button onClick={connectWallet}>Connect with Wagmi</button>
      )}
    </div>
  );
}
```

## Updating the Main App to Display all Implementations

Now update your `App.tsx` to include all three interface options:

```tsx title="src/App.tsx" theme={"dark"}
import { useState } from 'react';
import { WagmiProvider } from 'wagmi';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { EthersInterface } from './components/EthersInterface';
import { ViemInterface } from './components/ViemInterface';
import { WagmiInterface } from './components/WagmiInterface';
import { config } from './wagmi';

function App() {
  const [selectedLib, setSelectedLib] = useState<string | null>(null);

  const queryClient = new QueryClient();

  return (
    <div className="app-container">
      <h1>Sei ERC20 Token Interface</h1>
      <p>Choose a library implementation:</p>

      <div className="button-group">
        <button onClick={() => setSelectedLib('ethers')} className={selectedLib === 'ethers' ? 'active' : ''}>
          Ethers.js
        </button>
        <button onClick={() => setSelectedLib('viem')} className={selectedLib === 'viem' ? 'active' : ''}>
          Viem
        </button>
        <button onClick={() => setSelectedLib('wagmi')} className={selectedLib === 'wagmi' ? 'active' : ''}>
          Wagmi (React Hooks)
        </button>
      </div>

      <div className="interface-container">
        {selectedLib === 'ethers' && <EthersInterface />}
        {selectedLib === 'viem' && <ViemInterface />}
        {selectedLib === 'wagmi' && (
          <WagmiProvider config={config}>
            <QueryClientProvider client={queryClient}>
              <WagmiInterface />
            </QueryClientProvider>
          </WagmiProvider>
        )}
        {!selectedLib && (
          <div className="placeholder">
            <p>Select a library to see its implementation</p>
          </div>
        )}
      </div>
    </div>
  );
}

export default App;
```

## Polyfills for Browser Environment

When developing frontend applications for the blockchain, you might need polyfills for Node.js-specific features like `Buffer`. Add these polyfills to your project:

```tsx title="src/main.tsx" theme={"dark"}
import React from 'react';
import ReactDOM from 'react-dom/client';
import App from './App.tsx';
import './index.css';
import { Buffer } from 'buffer';

// Polyfill self for browser and global for Node.js
const globalObject = typeof self !== 'undefined' ? self : global;

Object.assign(globalObject, {
  Buffer: Buffer
});

ReactDOM.createRoot(document.getElementById('root')!).render(
  <React.StrictMode>
    <App />
  </React.StrictMode>
);
```

## Running the Application

To see your app in action, run:

```bash theme={"dark"}
npm run dev
```

This will start a local development server, at `http://localhost:5173`. You can toggle between the different library implementations to see how each one works.

To build your application, run:

```bash theme={"dark"}
npm run build
```

Then preview the production build locally:

```bash theme={"dark"}
npm run preview
```

This serves the built app at `http://localhost:4173` so you can verify it before deploying. To go live, deploy the contents of the `dist` directory to any static hosting provider.

---

URL: https://docs.sei.io/evm/in-app-swaps

# In-App Swaps - Symphony Integration Guide

> Guide to integrating the Symphony swap widget into your Sei application for seamless token exchanges.

Integrating in-app swap functionality into your Sei application enables users to exchange tokens directly within your platform, enhancing user experience and engagement.

## Overview

Swap widgets are embeddable UI components that abstract the complexity of interacting with decentralized exchanges (DEXs) and liquidity aggregators. They provide:

* **Seamless UX**: Users can swap tokens without leaving your app
* **Reduced Friction**: No need to redirect users to external DEX interfaces
* **Revenue Opportunities**: Many providers offer fee-sharing mechanisms
* **Cross-Chain Support**: Some widgets enable bridging assets from other chains

## Symphony Swap Widget

[Symphony](https://symph.ag) is a native DEX aggregator on Sei, offering the simplest integration via iframe embedding.

### Quick Start

```html theme={"dark"}
<iframe src="https://symph.ag/embed"></iframe>
```

### Live Demo

<div style={{ display: 'flex', justifyContent: 'center' }}>
  <iframe src="https://symph.ag/embed" style={{ width: '100%', maxWidth: '420px', minWidth: '377px', minHeight: '680px', border: 'none', borderRadius: '12px' }} title="Symphony Swap Widget Demo" />
</div>

### Size Requirements

* **Minimum Width**: `377px`
* **Minimum Height**: `650px` (recommended to prevent wallet modal scrolling)
* **Optimal Height**: `680-685px`

### URL Parameters

Customize the widget by appending query parameters:

#### Token Selection

| Parameter  | Description                   | Example                                               |
| ---------- | ----------------------------- | ----------------------------------------------------- |
| `tokenIn`  | Input token contract address  | `tokenIn=0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392`  |
| `tokenOut` | Output token contract address | `tokenOut=0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7` |

<Info>Tokens can be changed by the user after the widget loads.</Info>

#### Appearance

| Parameter | Description               | Supported Formats                                                                            |
| --------- | ------------------------- | -------------------------------------------------------------------------------------------- |
| `bgColor` | Background color          | Hex (`%23FFFFFF`), Named (`white`), RGB (`rgb(255,255,255)`), RGBA (`rgba(255,255,255,0.9)`) |
| `theme`   | Color theme of the widget | `light` or `dark` (defaults to `dark` if not specified)                                      |

<Warning>For hex colors, use `%23` instead of `#` in the URL (e.g., `%23FFFFFF` for white).</Warning>

#### Features

| Parameter       | Description                  | Values                      |
| --------------- | ---------------------------- | --------------------------- |
| `notifications` | Show/hide notification cards | `true` (default) or `false` |

### Complete Example

<Tabs>
  <Tab title="HTML">
    ```html theme={"dark"}
    <iframe
      src="https://symph.ag/embed?tokenIn=0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392&tokenOut=0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7&bgColor=white&theme=light&notifications=false"
      style="width: 100%; min-height: 650px; border: none; border-radius: 12px;"
      title="Symphony Swap Widget"
    ></iframe>
    ```
  </Tab>

  <Tab title="React">
    ```jsx theme={"dark"}
    function SwapWidget() {
      const tokenIn = "0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392";
      const tokenOut = "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7";
      
      return (
        <iframe
          src={`https://symph.ag/embed?tokenIn=${tokenIn}&tokenOut=${tokenOut}&theme=dark`}
          style={{
            width: '100%',
            minHeight: '650px',
            border: 'none',
            borderRadius: '12px'
          }}
          title="Symphony Swap Widget"
        />
      );
    }
    ```
  </Tab>

  <Tab title="Next.js">
    ```tsx theme={"dark"}
    'use client';

    export default function SwapPage() {
      const params = new URLSearchParams({
        tokenIn: '0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392',
        tokenOut: '0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7',
        theme: 'dark',
        notifications: 'true'
      });

    return (

    <div className="max-w-md mx-auto">
      <iframe src={`https://symph.ag/embed?${params.toString()}`} className="w-full min-h-[650px] border-0" title="Symphony Swap" />
    </div>
    ); }

    ```
  </Tab>
</Tabs>

### Popular Sei Token Addresses (Mainnet)

| Token         | Address                                                                                                               |
| ------------- | --------------------------------------------------------------------------------------------------------------------- |
| WSEI          | [`0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7`](https://seiscan.io/address/0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7) |
| USDC (native) | [`0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392`](https://seiscan.io/address/0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392) |
| USDT0         | [`0x9151434b16b9763660705744891fA906F660EcC5`](https://seiscan.io/address/0x9151434b16b9763660705744891fA906F660EcC5) |

***

## Best Practices

### Security Considerations

<Warning>
  **Security Checklist**

  * ✅ Validate that iframe sources match official domains
  * ✅ Implement Content Security Policy (CSP) headers
</Warning>

### Performance Optimization

```tsx theme={"dark"}
// Lazy load swap widgets to improve initial page load
import dynamic from 'next/dynamic';

const SwapWidget = dynamic(() => import('./SwapWidget'), {
  loading: () => <div className="animate-pulse h-[650px] bg-gray-800 " />,
  ssr: false
});
```

### Responsive Design

```css theme={"dark"}
/* Ensure swap widgets are responsive */
.swap-container {
  width: 100%;
  max-width: 420px;
  margin: 0 auto;
}

.swap-container iframe {
  width: 100%;
  min-height: 650px;
  border: none;
  border-radius: 12px;
}

@media (max-width: 480px) {
  .swap-container {
    max-width: 100%;
    padding: 0 16px;
  }
}
```

### Error Handling

```tsx theme={"dark"}
import { useState } from 'react';

function SwapWidgetWithFallback() {
  const [error, setError] = useState(false);

  if (error) {
    return (
      <div className="p-6 bg-sei-maroon-200/20  text-center">
        <p>Swap widget failed to load.</p>
        <a href="https://symph.ag" target="_blank" rel="noopener noreferrer" className="text-blue-400 underline">
          Open Symphony directly →
        </a>
      </div>
    );
  }

  return <iframe src="https://symph.ag/embed" onError={() => setError(true)} style={{ width: '100%', minHeight: '650px', border: 'none' }} title="Swap Widget" />;
}
```

***

## Additional Resources

* [Symphony Swap Widget Documentation](https://docs.symph.ag/widget/symphony-swap-widget)

---

URL: https://docs.sei.io/evm/evm-general

# EVM General Guide for Sei Blockchain

> Comprehensive guide on Ethereum Virtual Machine (EVM) on Sei blockchain. Learn about smart contract languages, development tools, and best practices for building on Sei's parallelized EVM.

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

## Overview

The Ethereum Virtual Machine (EVM) is the runtime environment for smart
contracts, enabling compatibility with Ethereum-based dApps. Sei is an EVM
compatible blockchain. Sei's parallelized EVM ensures high performance and
efficiency.

<Info>Watch the video walkthrough for this topic in the [Video Tutorials](/evm/videos) section.</Info>

Here are some key points about the EVM:

1. **Turing Completeness**: The EVM is Turing complete, meaning it can execute
   any computable function. This allows developers to write complex smart
   contracts.
2. **Gas**: Transactions and contract executions on the EVM compatible network
   consume gas. Gas is a measure of computational work, and users pay for it in
   usei on Sei networks. Gas ensures that malicious or inefficient code doesn't
   overload the network.
3. **Bytecode Execution**: Smart contracts are compiled into bytecode (low-level
   machine-readable instructions) and deployed to the EVM compatible network.
   The EVM executes this bytecode.

## Try it: deploy without any setup

You don't need a local toolchain to ship a contract to Sei. First confirm the network is live, then compile and deploy a minimal `Counter.sol` to testnet straight from the browser.

<RunSnippet method="eth_chainId" network="testnet" title="eth_chainId · atlantic-2" description="Confirms the testnet RPC responds — decodes to 1328, the chain ID your tooling needs." />

<RunSnippet method="eth_chainId" network="mainnet" title="eth_chainId · pacific-1" description="Confirms the mainnet RPC responds — decodes to 1329." />

Add Sei testnet to your wallet, then deploy from Remix below — compile under **Solidity Compiler**, then **Deploy & Run** with **Environment** set to **Injected Provider — MetaMask**:

<AddSeiButton network="testnet" label="Add Sei testnet" />

<SandboxEmbed kind="remix" src="https://remix.ethereum.org/?#activate=solidity,fileManager&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVApwcmFnbWEgc29saWRpdHkgXjAuOC4yNDsKCi8vLyBAdGl0bGUgQ291bnRlciDigJQgbWluaW1hbCBjb250cmFjdCB0byBjb21waWxlICYgZGVwbG95IHRvIFNlaSB0ZXN0bmV0Lgpjb250cmFjdCBDb3VudGVyIHsKICAgIHVpbnQyNTYgcHVibGljIGNvdW50OwogICAgZnVuY3Rpb24gaW5jcmVtZW50KCkgZXh0ZXJuYWwgeyBjb3VudCsrOyB9CiAgICBmdW5jdGlvbiBkZWNyZW1lbnQoKSBleHRlcm5hbCB7IGNvdW50LS07IH0KfQ" title="Counter.sol · deploy to Sei testnet" description="Remix IDE with a minimal Counter contract preloaded. Compile in-browser, then deploy to Sei testnet." />

## Smart contract languages

The two most popular languages for developing smart contracts on the EVM are
**Solidity** and **Vyper**.

### Solidity

* Object-oriented, high-level language for implementing smart contracts.
* Curly-bracket language that has been most profoundly influenced by C++.
* Statically typed (the type of a variable is known at compile time).
* Supports:
  * Inheritance (you can extend other contracts).
  * Libraries (you can create reusable code that you can call from different
    contracts – like static functions in a static class in other object oriented
    programming languages).
  * Complex user-defined types.

#### Example solidity contract

```solidity theme={"dark"}
// SPDX-License-Identifier: GPL-3.0
pragma solidity >= 0.7.0;

contract Coin {
    // The keyword "public" makes variables
    // accessible from other contracts
    address public minter;
    mapping (address => uint) public balances;

    // Events allow clients to react to specific
    // contract changes you declare
    event Sent(address from, address to, uint amount);

    // Constructor code is only run when the contract
    // is created
    constructor() {
        minter = msg.sender;
    }

    // Sends an amount of newly created coins to an address
    // Can only be called by the contract creator
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount < 1e60);
        balances[receiver] += amount;
    }

    // Sends an amount of existing coins
    // from any caller to an address
    function send(address receiver, uint amount) public {
        require(amount <= balances[msg.sender], "Insufficient balance.");
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Sent(msg.sender, receiver, amount);
    }
}
```

### Vyper

* Pythonic programming language
* Strong typing
* Small and understandable compiler code
* Efficient bytecode generation
* Deliberately has less features than Solidity with the aim of making contracts
  more secure and easier to audit. Vyper does not support:
  * Modifiers
  * Inheritance
  * Inline assembly
  * Function overloading
  * Operator overloading
  * Recursive calling
  * Infinite-length loops
  * Binary fixed points

#### Example Vyper contract

```python theme={"dark"}
# Open Auction

# Auction params
# Beneficiary receives money from the highest bidder
beneficiary: public(address)
auctionStart: public(uint256)
auctionEnd: public(uint256)

# Current state of auction
highestBidder: public(address)
highestBid: public(uint256)

# Set to true at the end, disallows any change
ended: public(bool)

# Keep track of refunded bids so we can follow the withdraw pattern
pendingReturns: public(HashMap[address, uint256])

# Create a simple auction with `_bidding_time`
# seconds bidding time on behalf of the
# beneficiary address `_beneficiary`.
@external
def __init__(_beneficiary: address, _bidding_time: uint256):
    self.beneficiary = _beneficiary
    self.auctionStart = block.timestamp
    self.auctionEnd = self.auctionStart + _bidding_time

# Bid on the auction with the value sent
# together with this transaction.
# The value will only be refunded if the
# auction is not won.
@external
@payable
def bid():
    # Check if bidding period is over.
    assert block.timestamp < self.auctionEnd
    # Check if bid is high enough
    assert msg.value > self.highestBid
    # Track the refund for the previous high bidder
    self.pendingReturns[self.highestBidder] += self.highestBid
    # Track new high bid
    self.highestBidder = msg.sender
    self.highestBid = msg.value

# Withdraw a previously refunded bid. The withdraw pattern is
# used here to avoid a security issue. If refunds were directly
# sent as part of bid(), a malicious bidding contract could block
# those refunds and thus block new higher bids from coming in.
@external
def withdraw():
    pending_amount: uint256 = self.pendingReturns[msg.sender]
    self.pendingReturns[msg.sender] = 0
    send(msg.sender, pending_amount)

# End the auction and send the highest bid
# to the beneficiary.
@external
def endAuction():
    # It is a good guideline to structure functions that interact
    # with other contracts (i.e. they call functions or send ether)
    # into three phases:
    # 1. checking conditions
    # 2. performing actions (potentially changing conditions)
    # 3. interacting with other contracts
    # If these phases are mixed up, the other contract could call
    # back into the current contract and modify the state or cause
    # effects (ether payout) to be performed multiple times.
    # If functions called internally include interaction with external
    # contracts, they also have to be considered interaction with
    # external contracts.

    # 1. Conditions
    # Check if auction endtime has been reached
    assert block.timestamp >= self.auctionEnd
    # Check if this function has already been called
    assert not self.ended

    # 2. Effects
    self.ended = True

    # 3. Interaction
    send(self.beneficiary, self.highestBid)
```

---

URL: https://docs.sei.io/evm/evm-hardhat

# Sei EVM Development with Hardhat

> Learn how to set up Hardhat for Sei EVM development, create and deploy smart contracts, and leverage OpenZeppelin components for secure, standardized implementations.

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

This tutorial will guide you through setting up Hardhat for Sei EVM development and using OpenZeppelin contracts to build secure, standardized smart contracts. We'll cover environment setup, contract creation, deployment, and show how to leverage OpenZeppelin's pre-built components.

<Info>Watch the video walkthrough for this topic in the [Video Tutorials](/evm/videos) section.</Info>

<Tip>
  **Deploy to Testnet First**

  It is <strong>highly recommended</strong> that you deploy to <em>testnet (atlantic-2)</em> first and verify everything works as expected before committing to mainnet. Doing so helps you catch bugs early, avoid unnecessary gas costs, and keep your users safe.
</Tip>

## Try it before you install

Setting up the full toolchain takes a few minutes. If you just want to see a contract deploy to Sei, you can do both of these right now in the browser.

First, confirm the RPC endpoints you'll put in `hardhat.config` respond:

<RunSnippet method="eth_chainId" network="testnet" title="eth_chainId · atlantic-2" description="Testnet RPC — decodes to 1328." />

<RunSnippet method="eth_chainId" network="mainnet" title="eth_chainId · pacific-1" description="Mainnet RPC — decodes to 1329." />

Then add Sei testnet to your wallet and deploy a minimal `Counter.sol` from Remix — no Node, no install. In Remix: compile under **Solidity Compiler**, then **Deploy & Run** with **Environment** set to **Injected Provider — MetaMask**.

<AddSeiButton network="testnet" label="Add Sei testnet" />

<SandboxEmbed kind="remix" src="https://remix.ethereum.org/?#activate=solidity,fileManager&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVApwcmFnbWEgc29saWRpdHkgXjAuOC4yNDsKCi8vLyBAdGl0bGUgQ291bnRlciDigJQgbWluaW1hbCBjb250cmFjdCB0byBjb21waWxlICYgZGVwbG95IHRvIFNlaSB0ZXN0bmV0Lgpjb250cmFjdCBDb3VudGVyIHsKICAgIHVpbnQyNTYgcHVibGljIGNvdW50OwogICAgZnVuY3Rpb24gaW5jcmVtZW50KCkgZXh0ZXJuYWwgeyBjb3VudCsrOyB9CiAgICBmdW5jdGlvbiBkZWNyZW1lbnQoKSBleHRlcm5hbCB7IGNvdW50LS07IH0KfQ" title="Counter.sol · deploy to Sei testnet" description="Remix IDE with a minimal Counter contract preloaded. Compile in-browser, then deploy to Sei testnet." />

## Table of Contents

* [Try it before you install](#try-it-before-you-install)
* [Prerequisites](#prerequisites)
* [Setting Up Your Development Environment](#setting-up-your-development-environment)
* [Configuring Hardhat for Sei EVM](#configuring-hardhat-for-sei-evm)
* [Using OpenZeppelin Contracts](#using-openzeppelin-contracts)
* [Creating and Deploying an ERC20 Token, ERC721 NFT or an Upgradeable UUPS Token ](#creating-and-deploying-an-erc20-token)
* [Testing Your Smart Contracts](#testing-your-smart-contracts)
* [Deploying to Sei Testnet and Mainnet](#deploying-to-sei-testnet-and-mainnet)

## Prerequisites

Before we begin, ensure you have the following installed:

* [Node.js](https://nodejs.org/) (v18.0.0 or later)
* [npm](https://www.npmjs.com/) (v7.0.0 or later) or [yarn](https://yarnpkg.com/)
* A code editor (VS Code recommended)

## Setting Up Your Development Environment

Let's create a new project and set up Hardhat:

```bash theme={"dark"}
# Create a new directory for your project
mkdir sei-hardhat-project
cd sei-hardhat-project

# Scaffold a Hardhat 3 project (ESM + TypeScript)
npx hardhat --init
```

When prompted, choose **Hardhat 3** and **a TypeScript project using Mocha and Ethers.js**, then follow the prompts. This generates an ESM project (`"type": "module"` in `package.json`) with `@nomicfoundation/hardhat-toolbox-mocha-ethers`, `ethers`, Hardhat Ignition, TypeScript, and a ready-to-use `tsconfig.json`.

Then add the OpenZeppelin contract library:

```bash theme={"dark"}
npm install @openzeppelin/contracts
```

<Tip>
  Prefer a non-interactive setup (CI or scripted environments)? Do the same thing by hand — no prompts:

  ```bash theme={"dark"}
  npm init -y
  npm pkg set type=module
  npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox-mocha-ethers @openzeppelin/contracts typescript @types/node
  ```

  The `@nomicfoundation/hardhat-toolbox-mocha-ethers` bundle pulls in `ethers`, Ignition, Mocha/Chai, and the keystore, network-helpers, verify, and typechain plugins — so this single install covers everything in this guide. If you hit peer-dependency errors, re-run with `--legacy-peer-deps`.
</Tip>

## Configuring Hardhat for Sei EVM

Next, we'll need to configure Hardhat to work with the Sei EVM. Update your `hardhat.config.ts` file:

```typescript title="hardhat.config.ts" theme={"dark"}
import type { HardhatUserConfig } from 'hardhat/config';
import { configVariable } from 'hardhat/config';
import hardhatToolboxMochaEthers from '@nomicfoundation/hardhat-toolbox-mocha-ethers';

const config: HardhatUserConfig = {
  // Hardhat 3 loads plugins from an explicit array — no side-effect `import` statements
  plugins: [hardhatToolboxMochaEthers],
  solidity: {
    version: '0.8.28',
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      }
    }
  },
  networks: {
    // Sei testnet (atlantic-2)
    seitestnet: {
      type: 'http',
      chainType: 'l1',
      url: 'https://evm-rpc-testnet.sei-apis.com',
      accounts: [configVariable('SEI_PRIVATE_KEY')],
      chainId: 1328
    },
    // Sei mainnet (pacific-1)
    seimainnet: {
      type: 'http',
      chainType: 'l1',
      url: 'https://evm-rpc.sei-apis.com',
      accounts: [configVariable('SEI_PRIVATE_KEY')],
      chainId: 1329
    }
  }
};

export default config;
```

<Note>Hardhat 3 is ESM-first and requires `"type": "module"` in `package.json` (the scaffold sets this for you). Each network needs an explicit `type: 'http'`, and plugins load via the `plugins` array rather than the Hardhat 2 side-effect `import '@nomicfoundation/hardhat-toolbox'`. A local simulated network is provided automatically — no `hardhat`/`localhost` entry required.</Note>

Hardhat 3 reads secrets through `configVariable(...)`, backed by an encrypted keystore — so your key is never stored in a plaintext file. Set it once:

```bash theme={"dark"}
npx hardhat keystore set SEI_PRIVATE_KEY
```

You'll be prompted to paste the private key of the account you deploy from; Hardhat stores it encrypted on your machine. For CI, export a `SEI_PRIVATE_KEY` environment variable instead — `configVariable` falls back to it.

<Warning>Use a dedicated, throwaway deploy key funded with only what you need — never a personal wallet holding real funds.</Warning>

## Using OpenZeppelin Contracts

OpenZeppelin provides a library of secure, tested smart contract components that you can use to build your applications. The `@openzeppelin/contracts` package was already installed during setup, so you're ready to import its contracts directly.

## Creating and Deploying an ERC20 Token, ERC721 NFT or an Upgradeable UUPS Token

<Tabs>
  <Tab title="ERC20">
    Let's create a simple ERC20 token using OpenZeppelin contracts. Create a new file in the `contracts` directory called `SeiToken.sol`:

    ```solidity title="contracts/SeiToken.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    import "@openzeppelin/contracts/access/Ownable.sol";

    contract SeiToken is ERC20, Ownable {
        constructor(address initialOwner)
            ERC20("Sei Token", "SEI")
            Ownable(initialOwner)
        {
            // Mint 1 million tokens to the contract deployer (with 18 decimals)
            _mint(msg.sender, 1000000 * 10 ** decimals());
        }

        // Function to mint new tokens (only owner)
        function mint(address to, uint256 amount) public onlyOwner {
            _mint(to, amount);
        }

        // Function to burn tokens
        function burn(uint256 amount) public {
            _burn(msg.sender, amount);
        }
    }
    ```

    Now, create a deployment script in the `ignition/modules` directory called `deploy-sei-token.ts`:

    ```typescript title="ignition/modules/deploy-sei-token.ts" theme={"dark"}
    import { buildModule } from '@nomicfoundation/hardhat-ignition/modules';

    export default buildModule('SeiTokenModule', (m) => {
      const deployer = m.getAccount(0);

      const seiToken = m.contract('SeiToken', [deployer]);

      return { seiToken };
    });
    ```

    To deploy the token to the Sei testnet:

    ```bash theme={"dark"}
    npx hardhat ignition deploy ignition/modules/deploy-sei-token.ts --network seitestnet
    ```
  </Tab>

  <Tab title="ERC721">
    Now, let's create an ERC721 NFT contract. Create a new file `SeiNFT.sol` in the `contracts` directory:

    ```solidity title="contracts/SeiNFT.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    // Compatible with OpenZeppelin Contracts ^5.0.0
    pragma solidity ^0.8.22;

    import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
    import {ERC721Burnable} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
    import {ERC721Enumerable} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
    import {ERC721Pausable} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
    import {ERC721URIStorage} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
    import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

    contract SeiNFT is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Pausable, Ownable, ERC721Burnable {
        uint256 private _nextTokenId;

         // Base URI for metadata
        string private _baseTokenURI;

        constructor(address initialOwner, string memory baseTokenURI)
            ERC721("Sei NFT Collection", "SEINFT")
            Ownable(initialOwner)
        {
            _baseTokenURI = baseTokenURI;
        }

        // Function to update the base URI (only owner)
        function setBaseURI(string memory baseTokenURI) public onlyOwner {
            _baseTokenURI = baseTokenURI;
        }

        // Override the baseURI function
        function _baseURI() internal view override returns (string memory) {
            return _baseTokenURI;
        }

        function pause() public onlyOwner {
            _pause();
        }

        function unpause() public onlyOwner {
            _unpause();
        }

        function safeMint(address to, string memory uri)
            public
            onlyOwner
            returns (uint256)
        {
            uint256 tokenId = _nextTokenId++;
            _safeMint(to, tokenId);
            _setTokenURI(tokenId, uri);
            return tokenId;
        }

        // The following functions are overrides required by Solidity.

        function _update(address to, uint256 tokenId, address auth)
            internal
            override(ERC721, ERC721Enumerable, ERC721Pausable)
            returns (address)
        {
            return super._update(to, tokenId, auth);
        }

        function _increaseBalance(address account, uint128 value)
            internal
            override(ERC721, ERC721Enumerable)
        {
            super._increaseBalance(account, value);
        }

        function tokenURI(uint256 tokenId)
            public
            view
            override(ERC721, ERC721URIStorage)
            returns (string memory)
        {
            return super.tokenURI(tokenId);
        }

        function supportsInterface(bytes4 interfaceId)
            public
            view
            override(ERC721, ERC721Enumerable, ERC721URIStorage)
            returns (bool)
        {
            return super.supportsInterface(interfaceId);
        }
    }
    ```

    Create a deployment script `deploy-sei-nft.ts`:

    ```typescript title="scripts/deploy-sei-nft.ts" theme={"dark"}
    import { network } from 'hardhat';

    // Hardhat 3 exposes ethers through a network connection rather than a global import
    const { ethers } = await network.create();

    const [deployer] = await ethers.getSigners();
    console.log('Deploying contracts with the account:', deployer.address);

    // Base URI for your NFT metadata
    const baseURI = 'https://your-metadata-server.com/metadata/';

    const SeiNFT = await ethers.getContractFactory('SeiNFT');
    const seiNFT = await SeiNFT.deploy(deployer.address, baseURI);
    await seiNFT.waitForDeployment();

    console.log('SeiNFT deployed to:', await seiNFT.getAddress());

    // Mint an example NFT
    console.log('Minting an example NFT...');
    const mintTx = await seiNFT.safeMint(deployer.address, '0.json');
    const receipt = await mintTx.wait();
    // _nextTokenId starts at 0, so the first minted token has ID 0.
    // Read the actual ID from the Transfer event:
    const transferEvent = receipt.logs.map((log) => seiNFT.interface.parseLog(log)).find((parsed) => parsed?.name === 'Transfer');
    console.log('NFT minted with ID:', transferEvent?.args.tokenId.toString() ?? 'unknown (no Transfer event in receipt)');
    ```

    Deploy the NFT contract to the Sei testnet:

    ```bash theme={"dark"}
    npx hardhat run scripts/deploy-sei-nft.ts --network seitestnet
    ```
  </Tab>

  <Tab title="Upgradeable UUPS Token">
    Upgradeable contracts allow you to modify the contract's logic after deployment without changing the contract address, which is crucial for fixing bugs or adding new features. The UUPS (Universal Upgradeable Proxy Standard) pattern is a popular way to implement upgradeability.

    For upgradeable contracts, also install the upgradeable variant of the OpenZeppelin library (the `@openzeppelin/contracts` package you installed earlier supplies the ERC1967 proxy):

    ```bash theme={"dark"}
    npm install @openzeppelin/contracts-upgradeable
    ```

    <Note>
      OpenZeppelin's `@openzeppelin/hardhat-upgrades` plugin is built for Hardhat 2 and does not register with Hardhat 3's `plugins` array. So this guide deploys the proxy directly using the ERC1967 standard and upgrades through UUPS `upgradeToAndCall` — no extra plugin, fully Hardhat 3-native. The tradeoff: you don't get the plugin's automatic storage-layout safety checks, so make sure each new version only **appends** state variables. You can validate layouts separately with [`@openzeppelin/upgrades-core`](https://www.npmjs.com/package/@openzeppelin/upgrades-core).
    </Note>

    No `hardhat.config.ts` changes are needed beyond the configuration shown earlier.

    Now, let's create an upgradeable ERC20 token. Create `contracts/UpgradeableSeiToken.sol`:

    ```solidity title="contracts/UpgradeableSeiToken.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
    import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
    import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
    import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

    contract UpgradeableSeiToken is Initializable, ERC20Upgradeable, OwnableUpgradeable, UUPSUpgradeable {
        /// @custom:oz-upgrades-unsafe-allow constructor
        constructor() {
            _disableInitializers();
        }

        function initialize(address initialOwner) initializer public {
            __ERC20_init("Upgradeable Sei Token", "uSEI");
            __Ownable_init(initialOwner);

            // Mint 1 million tokens to the initializer (deployer)
            _mint(initialOwner, 1000000 * 10 ** decimals());
        }

        // Function to mint new tokens (only owner)
        function mint(address to, uint256 amount) virtual public onlyOwner {
            _mint(to, amount);
        }

        // Required for UUPS upgradeability
        function _authorizeUpgrade(address newImplementation)
            internal
            onlyOwner
            override
        {}

        // OPTIONAL: Add a version identifier (useful for tracking upgrades)
        function version() public virtual pure returns (string memory) {
            return "V1";
        }
    }
    ```

    Note the `Initializable` base, the `initializer` modifier, the `__ERC20_init` / `__Ownable_init` calls, and the `_authorizeUpgrade` override — these are what make the contract safe to run behind a proxy. (OpenZeppelin v5's `UUPSUpgradeable` is stateless, so there is no `__UUPSUpgradeable_init` to call.)

    Add a thin, named ERC1967 proxy so Hardhat emits an artifact you can deploy by name. Create `contracts/SeiTokenProxy.sol`:

    ```solidity title="contracts/SeiTokenProxy.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";

    contract SeiTokenProxy is ERC1967Proxy {
        constructor(address implementation, bytes memory _data)
            ERC1967Proxy(implementation, _data)
        {}
    }
    ```

    Now create a deployment script `scripts/deploy-upgradeable-token.ts`. It deploys the implementation, then deploys the proxy with the `initialize` call encoded as constructor data so initialization happens atomically:

    ```typescript title="scripts/deploy-upgradeable-token.ts" theme={"dark"}
    import { network } from 'hardhat';

    const { ethers } = await network.create();

    const [deployer] = await ethers.getSigners();
    console.log('Deploying contracts with the account:', deployer.address);

    // 1. Deploy the implementation contract
    const UpgradeableSeiToken = await ethers.getContractFactory('UpgradeableSeiToken');
    const implementation = await UpgradeableSeiToken.deploy();
    await implementation.waitForDeployment();

    // 2. Deploy the ERC1967 proxy, running initialize(deployer) atomically
    const initData = UpgradeableSeiToken.interface.encodeFunctionData('initialize', [deployer.address]);
    const SeiTokenProxy = await ethers.getContractFactory('SeiTokenProxy');
    const proxy = await SeiTokenProxy.deploy(await implementation.getAddress(), initData);
    await proxy.waitForDeployment();

    // 3. Interact with the token through the proxy address from here on
    const token = await ethers.getContractAt('UpgradeableSeiToken', await proxy.getAddress());
    console.log('Proxy deployed to:', await token.getAddress());
    console.log('Implementation:', await implementation.getAddress());
    console.log('Version:', await token.version()); // V1
    ```

    Deploy this to the testnet:

    ```bash theme={"dark"}
    npx hardhat run scripts/deploy-upgradeable-token.ts --network seitestnet
    ```

    **Upgrading the Contract**

    Let's say you want to add a new feature or fix a bug. Create a new version of the contract, `contracts/UpgradeableSeiTokenV2.sol`:

    ```solidity title="contracts/UpgradeableSeiTokenV2.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import "./UpgradeableSeiToken.sol"; // Import the V1 contract

    contract UpgradeableSeiTokenV2 is UpgradeableSeiToken {
        // Add a new state variable (ensure it doesn't clash with V1 storage layout)
        uint256 public totalMintedSinceV2;

        // Override the mint function to track new mints
        function mint(address to, uint256 amount) public override onlyOwner {
            super.mint(to, amount);
            totalMintedSinceV2 += amount; // Add V2 logic
        }

        // Override the version function
        function version() public pure override returns (string memory) {
            return "V2";
        }

        // IMPORTANT: V2 does not need its own initializer or constructor for upgrades.
        // The state from V1 is preserved.
    }
    ```

    Now, create an upgrade script `scripts/upgrade-token.ts`. **Replace `PROXY_ADDRESS` with the address printed when you deployed the proxy.**

    ```typescript title="scripts/upgrade-token.ts" theme={"dark"}
    import { network } from 'hardhat';

    const { ethers } = await network.create();

    // !! REPLACE WITH YOUR PROXY ADDRESS from the deploy step !!
    const PROXY_ADDRESS = '0xYOUR_PROXY_CONTRACT_ADDRESS_HERE';

    const [deployer] = await ethers.getSigners();
    console.log('Upgrading contract with the account:', deployer.address);

    // 1. Deploy the new implementation
    const UpgradeableSeiTokenV2 = await ethers.getContractFactory('UpgradeableSeiTokenV2');
    const v2Implementation = await UpgradeableSeiTokenV2.deploy();
    await v2Implementation.waitForDeployment();

    // 2. Point the proxy at the new implementation (UUPS upgrades are owner-gated)
    const token = await ethers.getContractAt('UpgradeableSeiTokenV2', PROXY_ADDRESS);
    await (await token.upgradeToAndCall(await v2Implementation.getAddress(), '0x')).wait();

    console.log('Upgrade complete. Proxy remains at:', PROXY_ADDRESS);
    console.log('New implementation:', await v2Implementation.getAddress());
    console.log('Contract version:', await token.version()); // V2
    ```

    Run the upgrade script:

    ```bash theme={"dark"}
    npx hardhat run scripts/upgrade-token.ts --network seitestnet
    ```

    You have now successfully deployed and upgraded a UUPS contract on the Sei network using Hardhat and OpenZeppelin!
  </Tab>
</Tabs>

## Testing Your Smart Contracts

Hardhat makes it easy to test your contracts before deploying them. Create a test file `test/sei-token-test.ts`:

```typescript title="test/sei-token-test.ts" theme={"dark"}
import { expect } from 'chai';
import { network } from 'hardhat';

describe('SeiToken', function () {
  let ethers;
  let seiToken;
  let owner;
  let addr1;
  let addr2;

  beforeEach(async function () {
    // Hardhat 3 exposes ethers through a network connection
    ({ ethers } = await network.create());

    // Get signers
    [owner, addr1, addr2] = await ethers.getSigners();

    // Deploy the token
    seiToken = await ethers.deployContract('SeiToken', [owner.address]);
  });

  describe('Deployment', function () {
    it('Should set the right owner', async function () {
      expect(await seiToken.owner()).to.equal(owner.address);
    });

    it('Should assign the total supply of tokens to the owner', async function () {
      const ownerBalance = await seiToken.balanceOf(owner.address);
      const totalSupply = await seiToken.totalSupply();
      expect(totalSupply).to.equal(ownerBalance);
    });

    it('Should have correct name and symbol', async function () {
      expect(await seiToken.name()).to.equal('Sei Token');
      expect(await seiToken.symbol()).to.equal('SEI');
    });
  });

  describe('Transactions', function () {
    it('Should transfer tokens between accounts', async function () {
      // Transfer 50 tokens from owner to addr1
      await seiToken.transfer(addr1.address, 50);
      expect(await seiToken.balanceOf(addr1.address)).to.equal(50);

      // Transfer 50 tokens from addr1 to addr2
      await seiToken.connect(addr1).transfer(addr2.address, 50);
      expect(await seiToken.balanceOf(addr2.address)).to.equal(50);
    });

    it("Should fail if sender doesn't have enough tokens", async function () {
      const initialOwnerBalance = await seiToken.balanceOf(owner.address);

      // Try to send 1 token from addr1 (0 tokens) to owner
      await expect(seiToken.connect(addr1).transfer(owner.address, 1)).to.be.reverted;

      // Owner balance shouldn't change
      expect(await seiToken.balanceOf(owner.address)).to.equal(initialOwnerBalance);
    });
  });

  describe('Minting', function () {
    it('Should allow owner to mint new tokens', async function () {
      await seiToken.mint(addr1.address, 1000);
      expect(await seiToken.balanceOf(addr1.address)).to.equal(1000);
    });

    it('Should not allow non-owners to mint', async function () {
      await expect(seiToken.connect(addr1).mint(addr1.address, 1000)).to.be.reverted;
    });
  });
});
```

Run your tests with:

```bash theme={"dark"}
npx hardhat test
```

## Deploying to Sei Testnet and Mainnet

Once you've tested your contracts, you can deploy them to the Sei testnet or mainnet. To deploy, you'll need:

1. SEI tokens in your wallet for gas
2. Your private key stored in the encrypted keystore (`npx hardhat keystore set SEI_PRIVATE_KEY`) — or exported as a `SEI_PRIVATE_KEY` environment variable in CI

Deploy to the testnet:

```bash theme={"dark"}
npx hardhat ignition deploy ignition/modules/deploy-sei-token.ts --network seitestnet
```

Deploy to the mainnet (only when you're ready for production):

```bash theme={"dark"}
npx hardhat ignition deploy ignition/modules/deploy-sei-token.ts --network seimainnet
```

---

URL: https://docs.sei.io/evm/evm-foundry

# Sei EVM Smart Contract Development with Foundry

> Learn how to develop, test, and deploy smart contracts on Sei EVM using Foundry, with step-by-step examples of contract creation, testing, deployment, and interaction using both CLI and ethers.js.

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

This tutorial will guide you through setting up Foundry for Sei EVM development and using OpenZeppelin contracts to build secure, standardized smart contracts. We'll cover environment setup, contract creation, deployment, and show how to leverage OpenZeppelin's pre-built components with the powerful Foundry toolkit.

<Info>Watch the video walkthrough for this topic in the [Video Tutorials](/evm/videos) section.</Info>

<Tip>
  **Deploy to Testnet First**

  It is <strong>highly recommended</strong> that you deploy to <em>testnet (atlantic-2)</em> first and verify everything works as expected before committing to mainnet. Doing so helps you catch bugs early, avoid unnecessary gas costs, and keep your users safe.
</Tip>

## Try it before you install

Installing Foundry and scaffolding a project takes a few minutes. If you just want to see a contract deploy to Sei, you can do both of these right now in the browser.

First, confirm the RPC endpoints you'll put in `foundry.toml` respond:

<RunSnippet method="eth_chainId" network="testnet" title="eth_chainId · atlantic-2" description="Testnet RPC — decodes to 1328." />

<RunSnippet method="eth_chainId" network="mainnet" title="eth_chainId · pacific-1" description="Mainnet RPC — decodes to 1329." />

Then add Sei testnet to your wallet and deploy a minimal `Counter.sol` from Remix — no `forge`, no install. In Remix: compile under **Solidity Compiler**, then **Deploy & Run** with **Environment** set to **Injected Provider — MetaMask**.

<AddSeiButton network="testnet" label="Add Sei testnet" />

<SandboxEmbed kind="remix" src="https://remix.ethereum.org/?#activate=solidity,fileManager&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVApwcmFnbWEgc29saWRpdHkgXjAuOC4yNDsKCi8vLyBAdGl0bGUgQ291bnRlciDigJQgbWluaW1hbCBjb250cmFjdCB0byBjb21waWxlICYgZGVwbG95IHRvIFNlaSB0ZXN0bmV0Lgpjb250cmFjdCBDb3VudGVyIHsKICAgIHVpbnQyNTYgcHVibGljIGNvdW50OwogICAgZnVuY3Rpb24gaW5jcmVtZW50KCkgZXh0ZXJuYWwgeyBjb3VudCsrOyB9CiAgICBmdW5jdGlvbiBkZWNyZW1lbnQoKSBleHRlcm5hbCB7IGNvdW50LS07IH0KfQ" title="Counter.sol · deploy to Sei testnet" description="Remix IDE with a minimal Counter contract preloaded. Compile in-browser, then deploy to Sei testnet." />

## Table of Contents

* [Try it before you install](#try-it-before-you-install)
* [Prerequisites](#prerequisites)
* [Setting Up Your Development Environment](#setting-up-your-development-environment)
* [Configuring Foundry for Sei EVM](#configuring-foundry-for-sei-evm)
* [Using OpenZeppelin Contracts](#using-openzeppelin-contracts)
* [Creating and Deploying Smart Contracts](#creating-and-deploying-smart-contracts)
* [Testing Your Smart Contracts](#testing-your-smart-contracts)
* [Deploying to Sei Testnet and Mainnet](#deploying-to-sei-testnet-and-mainnet)
* [Interacting with Deployed Contracts](#interacting-with-deployed-contracts)

## Prerequisites

Before we begin, ensure you have the following:

* [Foundry](https://book.getfoundry.sh/) installed on your system
* A basic understanding of Solidity and smart contract development
* A wallet with SEI tokens for gas
* [Node.js](https://nodejs.org/) (v18.0.0 or later) for ethers.js interactions

## Setting Up Your Development Environment

First, let's install Foundry if you haven't already. Follow the [installation guide](https://book.getfoundry.sh/getting-started/installation) or use the quick install command:

```bash theme={"dark"}
curl -L https://foundry.paradigm.xyz | bash
foundryup
```

Create a new Foundry project:

```bash theme={"dark"}
# Create a new directory for your project
mkdir sei-foundry-project
cd sei-foundry-project

# Initialize a new Foundry project
forge init --no-git

# Initialize git repository (required for installing dependencies)
git init
```

This will create a standard Foundry project structure with `src/`, `test/`, and `script/` directories.

## Configuring Foundry for Sei EVM

Create a `foundry.toml` file in your project root to configure Foundry for Sei networks:

```toml title="foundry.toml" theme={"dark"}
[profile.default]
src = "src"
out = "out"
libs = ["lib"]
solc_version = "0.8.28"
optimizer = true
optimizer_runs = 200

# Sei testnet configuration
[rpc_endpoints]
sei_testnet = "https://evm-rpc-testnet.sei-apis.com"
sei_mainnet = "https://evm-rpc.sei-apis.com"
```

Create a `.env` file to store your private key and other sensitive information:

```bash title=".env" theme={"dark"}
PRIVATE_KEY=your_private_key_here
SEI_TESTNET_RPC=https://evm-rpc-testnet.sei-apis.com
SEI_MAINNET_RPC=https://evm-rpc.sei-apis.com
```

<Warning>Add `.env` to your `.gitignore` file to prevent committing sensitive information such as your `PRIVATE_KEY` and potentially lose funds.</Warning>

## Using OpenZeppelin Contracts

OpenZeppelin provides a library of secure, tested smart contract components. Let's install OpenZeppelin contracts:

```bash theme={"dark"}
forge install OpenZeppelin/openzeppelin-contracts
```

Create a `remappings.txt` file to properly map the imports:

```bash theme={"dark"}
forge remappings > remappings.txt
```

## Creating and Deploying Smart Contracts

Let's create different types of smart contracts. Choose from the tabs below based on what you want to build:

<Tabs>
  <Tab title="Counter Contract">
    Let's start with a simple counter contract. Update the default `src/Counter.sol` file:

    ```solidity title="src/Counter.sol" theme={"dark"}
    // SPDX-License-Identifier: UNLICENSED
    pragma solidity ^0.8.22;

    contract Counter {
        uint256 public number;
        address public owner;

        event NumberChanged(uint256 newNumber, address changedBy);

        constructor() {
            owner = msg.sender;
        }

        modifier onlyOwner() {
            require(msg.sender == owner, "Only owner can call this function");
            _;
        }

        function setNumber(uint256 newNumber) public {
            number = newNumber;
            emit NumberChanged(newNumber, msg.sender);
        }

        function increment() public {
            number++;
            emit NumberChanged(number, msg.sender);
        }

        function getCount() public view returns (uint256) {
            return number;
        }

        function reset() public onlyOwner {
            number = 0;
            emit NumberChanged(0, msg.sender);
        }
    }
    ```

    Create a deployment script in `script/DeployCounter.s.sol`:

    ```solidity title="script/DeployCounter.s.sol" theme={"dark"}
    // SPDX-License-Identifier: UNLICENSED
    pragma solidity ^0.8.22;

    import {Script} from "forge-std/Script.sol";
    import {Counter} from "../src/Counter.sol";

    contract DeployCounter is Script {
        function run() external returns (Counter) {
            vm.startBroadcast();
            Counter counter = new Counter();
            vm.stopBroadcast();
            return counter;
        }
    }
    ```
  </Tab>

  <Tab title="ERC20 Token">
    Create an ERC20 token using OpenZeppelin. Create `src/SeiToken.sol`:

    ```solidity title="src/SeiToken.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    import "@openzeppelin/contracts/access/Ownable.sol";

    contract SeiToken is ERC20, Ownable {
        constructor(address initialOwner)
            ERC20("Sei Token", "SEI")
            Ownable(initialOwner)
        {
            // Mint 1 million tokens to the contract deployer (with 18 decimals)
            _mint(msg.sender, 1000000 * 10 ** decimals());
        }

        // Function to mint new tokens (only owner)
        function mint(address to, uint256 amount) public onlyOwner {
            _mint(to, amount);
        }

        // Function to burn tokens
        function burn(uint256 amount) public {
            _burn(msg.sender, amount);
        }

        // Function to burn tokens from another account (with allowance)
        function burnFrom(address from, uint256 amount) public {
            _spendAllowance(from, msg.sender, amount);
            _burn(from, amount);
        }
    }
    ```

    Create a deployment script in `script/DeploySeiToken.s.sol`:

    ```solidity title="script/DeploySeiToken.s.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import {Script} from "forge-std/Script.sol";
    import {SeiToken} from "../src/SeiToken.sol";

    contract DeploySeiToken is Script {
        function run() external returns (SeiToken) {
            vm.startBroadcast();
            SeiToken token = new SeiToken(msg.sender);
            vm.stopBroadcast();
            return token;
        }
    }
    ```
  </Tab>

  <Tab title="ERC721 NFT">
    Create an ERC721 NFT contract using OpenZeppelin. Create `src/SeiNFT.sol`:

    ```solidity title="src/SeiNFT.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
    import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
    import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
    import "@openzeppelin/contracts/access/Ownable.sol";

    contract SeiNFT is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
        uint256 private _nextTokenId;
        string private _baseTokenURI;

        constructor(address initialOwner, string memory baseTokenURI)
            ERC721("Sei NFT Collection", "SEINFT")
            Ownable(initialOwner)
        {
            _baseTokenURI = baseTokenURI;
        }

        // Function to update the base URI (only owner)
        function setBaseURI(string memory baseTokenURI) public onlyOwner {
            _baseTokenURI = baseTokenURI;
        }

        // Override the baseURI function
        function _baseURI() internal view override returns (string memory) {
            return _baseTokenURI;
        }

        function safeMint(address to, string memory uri) public onlyOwner returns (uint256) {
            uint256 tokenId = _nextTokenId++;
            _safeMint(to, tokenId);
            _setTokenURI(tokenId, uri);
            return tokenId;
        }

        // Public mint function with a fee
        function publicMint(string memory uri) public payable returns (uint256) {
            require(msg.value >= 0.01 ether, "Insufficient payment");
            uint256 tokenId = _nextTokenId++;
            _safeMint(msg.sender, tokenId);
            _setTokenURI(tokenId, uri);
            return tokenId;
        }

        // Withdraw contract balance (only owner)
        function withdraw() public onlyOwner {
            uint256 balance = address(this).balance;
            require(balance > 0, "No funds to withdraw");
            payable(owner()).transfer(balance);
        }

        // The following functions are overrides required by Solidity
        function _update(address to, uint256 tokenId, address auth)
            internal
            override(ERC721, ERC721Enumerable)
            returns (address)
        {
            return super._update(to, tokenId, auth);
        }

        function _increaseBalance(address account, uint128 value)
            internal
            override(ERC721, ERC721Enumerable)
        {
            super._increaseBalance(account, value);
        }

        function tokenURI(uint256 tokenId)
            public
            view
            override(ERC721, ERC721URIStorage)
            returns (string memory)
        {
            return super.tokenURI(tokenId);
        }

        function supportsInterface(bytes4 interfaceId)
            public
            view
            override(ERC721, ERC721Enumerable, ERC721URIStorage)
            returns (bool)
        {
            return super.supportsInterface(interfaceId);
        }
    }
    ```

    Create a deployment script in `script/DeploySeiNFT.s.sol`:

    ```solidity title="script/DeploySeiNFT.s.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import {Script} from "forge-std/Script.sol";
    import {SeiNFT} from "../src/SeiNFT.sol";

    contract DeploySeiNFT is Script {
        function run() external returns (SeiNFT) {
            string memory baseURI = "https://your-metadata-server.com/metadata/";

            vm.startBroadcast();
            SeiNFT nft = new SeiNFT(msg.sender, baseURI);
            vm.stopBroadcast();

            return nft;
        }
    }
    ```
  </Tab>
</Tabs>

## Testing Your Smart Contracts

Foundry provides excellent testing capabilities. Let's create comprehensive tests for our contracts.

<Tabs>
  <Tab title="Counter Tests">
    Update `test/Counter.t.sol`:

    ```solidity title="test/Counter.t.sol" theme={"dark"}
    // SPDX-License-Identifier: UNLICENSED
    pragma solidity ^0.8.22;

    import {Test, console} from "forge-std/Test.sol";
    import {Counter} from "../src/Counter.sol";

    contract CounterTest is Test {
        Counter public counter;
        address public owner;
        address public user;

        function setUp() public {
            owner = address(this);
            user = address(0x1);
            counter = new Counter();
            counter.setNumber(0);
        }

        function test_Increment() public {
            counter.increment();
            assertEq(counter.number(), 1);
        }

        function test_SetNumber() public {
            counter.setNumber(42);
            assertEq(counter.number(), 42);
        }

        function test_GetCount() public {
            uint256 initialCount = counter.getCount();
            counter.increment();
            assertEq(counter.getCount(), initialCount + 1);
        }

        function test_Reset() public {
            counter.setNumber(100);
            counter.reset();
            assertEq(counter.number(), 0);
        }

        function test_OnlyOwnerCanReset() public {
            vm.prank(user);
            vm.expectRevert("Only owner can call this function");
            counter.reset();
        }

        function test_EventEmitted() public {
            vm.expectEmit(true, true, false, true);
            emit Counter.NumberChanged(42, address(this));
            counter.setNumber(42);
        }

        function testFuzz_SetNumber(uint256 x) public {
            counter.setNumber(x);
            assertEq(counter.number(), x);
        }
    }
    ```
  </Tab>

  <Tab title="ERC20 Tests">
    Create `test/SeiToken.t.sol`:

    ```solidity title="test/SeiToken.t.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import {Test} from "forge-std/Test.sol";
    import {SeiToken} from "../src/SeiToken.sol";

    contract SeiTokenTest is Test {
        SeiToken public token;
        address public owner;
        address public user1;
        address public user2;

        function setUp() public {
            owner = address(this);
            user1 = address(0x1);
            user2 = address(0x2);
            token = new SeiToken(owner);
        }

        function test_InitialSupply() public {
            assertEq(token.totalSupply(), 1000000 * 10 ** 18);
            assertEq(token.balanceOf(owner), 1000000 * 10 ** 18);
        }

        function test_Transfer() public {
            token.transfer(user1, 1000);
            assertEq(token.balanceOf(user1), 1000);
            assertEq(token.balanceOf(owner), 1000000 * 10 ** 18 - 1000);
        }

        function test_Mint() public {
            token.mint(user1, 500);
            assertEq(token.balanceOf(user1), 500);
            assertEq(token.totalSupply(), 1000000 * 10 ** 18 + 500);
        }

        function test_Burn() public {
            token.burn(1000);
            assertEq(token.totalSupply(), 1000000 * 10 ** 18 - 1000);
        }

        function test_OnlyOwnerCanMint() public {
            vm.prank(user1);
            vm.expectRevert();
            token.mint(user2, 1000);
        }
    }
    ```
  </Tab>

  <Tab title="ERC721 Tests">
    Create `test/SeiNFT.t.sol`:

    ```solidity title="test/SeiNFT.t.sol" theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.22;

    import {Test} from "forge-std/Test.sol";
    import {SeiNFT} from "../src/SeiNFT.sol";

    contract SeiNFTTest is Test {
        SeiNFT public nft;
        address public owner;
        address public user1;
        string public baseURI = "https://example.com/metadata/";

        function setUp() public {
            owner = address(this);
            user1 = address(0x1);
            nft = new SeiNFT(owner, baseURI);
        }

        function test_SafeMint() public {
            uint256 tokenId = nft.safeMint(user1, "1.json");
            assertEq(nft.ownerOf(tokenId), user1);
            assertEq(nft.tokenURI(tokenId), string(abi.encodePacked(baseURI, "1.json")));
        }

        function test_PublicMint() public {
            vm.deal(user1, 1 ether);
            vm.prank(user1);
            uint256 tokenId = nft.publicMint{value: 0.01 ether}("2.json");
            assertEq(nft.ownerOf(tokenId), user1);
        }

        function test_PublicMintInsufficientPayment() public {
            vm.deal(user1, 0.005 ether);
            vm.prank(user1);
            vm.expectRevert("Insufficient payment");
            nft.publicMint{value: 0.005 ether}("3.json");
        }

        function test_TotalSupply() public {
            assertEq(nft.totalSupply(), 0);
            nft.safeMint(user1, "1.json");
            assertEq(nft.totalSupply(), 1);
        }

        function test_Withdraw() public {
            vm.deal(user1, 1 ether);
            vm.prank(user1);
            nft.publicMint{value: 0.01 ether}("1.json");

            uint256 contractBalance = address(nft).balance;
            assertEq(contractBalance, 0.01 ether);

            nft.withdraw();
            assertEq(address(nft).balance, 0);
        }
    }
    ```
  </Tab>
</Tabs>

Run your tests with:

```bash theme={"dark"}
forge test
```

For more verbose output:

```bash theme={"dark"}
forge test -vvv
```

## Deploying to Sei Testnet and Mainnet

Now let's deploy our contracts to the Sei networks. You can use either Forge scripts or direct deployment commands.

### Using Forge Scripts (Recommended)

Deploy to Sei testnet:

```bash theme={"dark"}
forge script script/DeployCounter.s.sol --rpc-url $SEI_TESTNET_RPC --private-key $PRIVATE_KEY --broadcast
```

Deploy to Sei mainnet:

```bash theme={"dark"}
forge script script/DeployCounter.s.sol --rpc-url $SEI_MAINNET_RPC --private-key $PRIVATE_KEY --broadcast
```

### Using Direct Forge Create Commands

Alternatively, you can deploy directly:

```bash theme={"dark"}
# Deploy Counter to testnet
forge create --rpc-url $SEI_TESTNET_RPC --private-key $PRIVATE_KEY src/Counter.sol:Counter

# Deploy SeiToken to testnet
forge create --rpc-url $SEI_TESTNET_RPC --private-key $PRIVATE_KEY src/SeiToken.sol:SeiToken --constructor-args $(cast abi-encode "constructor(address)" "YOUR_ADDRESS")

# Deploy SeiNFT to testnet
forge create --rpc-url $SEI_TESTNET_RPC --private-key $PRIVATE_KEY src/SeiNFT.sol:SeiNFT --constructor-args $(cast abi-encode "constructor(address,string)" "YOUR_ADDRESS" "https://your-metadata-server.com/metadata/")
```

Successful deployment will output:

```bash theme={"dark"}
[⠒] Compiling...
No files changed, compilation skipped
Deployer: 0xYOUR_DEPLOYER_ADDRESS
Deployed to: 0xYOUR_CONTRACT_ADDRESS
Transaction hash: 0xYOUR_TX_HASH
```

## Interacting with Deployed Contracts

Once deployed, you can interact with your contracts using Foundry's `cast` tool or ethers.js.

### Using Cast Commands

```bash theme={"dark"}
# Query the counter value
cast call $CONTRACT_ADDRESS "getCount()(uint256)" --rpc-url $SEI_TESTNET_RPC

# Increment the counter
cast send $CONTRACT_ADDRESS "increment()" --private-key $PRIVATE_KEY --rpc-url $SEI_TESTNET_RPC

# Set a specific number
cast send $CONTRACT_ADDRESS "setNumber(uint256)" 42 --private-key $PRIVATE_KEY --rpc-url $SEI_TESTNET_RPC

# Check ERC20 token balance
cast call $TOKEN_ADDRESS "balanceOf(address)(uint256)" $YOUR_ADDRESS --rpc-url $SEI_TESTNET_RPC

# Transfer ERC20 tokens
cast send $TOKEN_ADDRESS "transfer(address,uint256)" $RECIPIENT_ADDRESS 1000 --private-key $PRIVATE_KEY --rpc-url $SEI_TESTNET_RPC
```

### Using ethers.js

Install ethers.js to interact with your contracts programmatically:

```bash theme={"dark"}
npm install ethers@latest
```

Create a Node.js script to interact with your deployed contracts:

```tsx title="interact.js" theme={"dark"}
import { ethers } from 'ethers';

const privateKey = process.env.PRIVATE_KEY;
const evmRpcEndpoint = process.env.SEI_TESTNET_RPC;
const provider = new ethers.JsonRpcProvider(evmRpcEndpoint);
const signer = new ethers.Wallet(privateKey, provider);

// Counter contract interaction
const counterAbi = ['function getCount() public view returns (uint256)', 'function increment() public', 'function setNumber(uint256 newNumber) public', 'event NumberChanged(uint256 newNumber, address changedBy)'];

const counterAddress = 'YOUR_COUNTER_CONTRACT_ADDRESS';
const counterContract = new ethers.Contract(counterAddress, counterAbi, signer);

// ERC20 token interaction
const tokenAbi = ['function balanceOf(address owner) view returns (uint256)', 'function transfer(address to, uint256 amount) returns (bool)', 'function mint(address to, uint256 amount)', 'event Transfer(address indexed from, address indexed to, uint256 value)'];

const tokenAddress = 'YOUR_TOKEN_CONTRACT_ADDRESS';
const tokenContract = new ethers.Contract(tokenAddress, tokenAbi, signer);

async function interactWithContracts() {
  try {
    // Counter interactions
    console.log('Current count:', await counterContract.getCount());

    const incrementTx = await counterContract.increment();
    await incrementTx.wait();
    console.log('Incremented! New count:', await counterContract.getCount());

    // Token interactions
    const balance = await tokenContract.balanceOf(signer.address);
    console.log('Token balance:', ethers.formatEther(balance));

    // Transfer tokens
    const transferTx = await tokenContract.transfer('0xRecipientAddress', ethers.parseEther('100'));
    await transferTx.wait();
    console.log('Tokens transferred!');
  } catch (error) {
    console.error('Error:', error);
  }
}

interactWithContracts();
```

<Info>Foundry generates the ABI for contracts in the `out` folder. You can use this ABI to interact with contracts from other tools like `ethers.js` or `web3.js`.</Info>

---

URL: https://docs.sei.io/evm/python-quickstart

# Python Quickstart (web3.py)

> Connect to Sei from Python using web3.py — read chain data, then sign and broadcast transactions against the Sei EVM JSON-RPC.

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

Sei is fully EVM-compatible, so any standard Ethereum client works — including Python's [web3.py](https://web3py.readthedocs.io). This guide connects to Sei from a Python script, reads chain data with no credentials, then signs and broadcasts a transaction.

## Install

We recommend an isolated virtual environment:

```bash theme={"dark"}
python3 -m venv venv
source venv/bin/activate          # Windows: venv\Scripts\activate
pip install web3
```

## Reading Chain Data

This is the first milestone — it needs no private key.

```python theme={"dark"}
from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://evm-rpc.sei-apis.com"))

# Any valid Sei EVM address — swap in your own
address = "0x0000000000000000000000000000000000000000"

print("Connected:", w3.is_connected())
print("Chain ID:", w3.eth.chain_id)                                  # 1329 on mainnet
print("Latest block:", w3.eth.block_number)
print("Balance (SEI):", w3.from_wei(w3.eth.get_balance(address), "ether"))
print("Nonce:", w3.eth.get_transaction_count(address))
```

**You're done when you see:**

```text theme={"dark"}
Connected: True
Chain ID: 1329
Latest block: 148203117
Balance (SEI): 12.5
Nonce: 7
```

Values are illustrative — your block number, and the queried address's balance and nonce, will differ. The chain ID is always `1329` on mainnet (`1328` on the atlantic-2 testnet).

## Try it live

`web3.py` issues plain JSON-RPC under the hood — here are the same reads against Sei mainnet, no Python required.

<RunSnippet method="eth_chainId" network="mainnet" title="w3.eth.chain_id" description="The mainnet chain ID — decodes to 1329." />

<RunSnippet method="eth_blockNumber" network="mainnet" title="w3.eth.block_number" description="Latest committed block on pacific-1." />

<RunSnippet method="eth_getBalance" params={['0x0000000000000000000000000000000000000000', 'latest']} network="mainnet" title="w3.eth.get_balance(address)" description="Wei balance of the example address — swap in your own. w3.from_wei(…, 'ether') converts it to SEI." />

## Sending a Transaction

Next step — this requires a funded account. Get testnet SEI from the [faucet](/learn/faucet), then build, **sign locally**, and broadcast with `eth_sendRawTransaction`. Public RPC endpoints don't manage accounts, so you sign the transaction yourself rather than relying on node-managed accounts.

```python theme={"dark"}
import os
from web3 import Web3

# atlantic-2 testnet
w3 = Web3(Web3.HTTPProvider("https://evm-rpc-testnet.sei-apis.com"))

account = w3.eth.account.from_key(os.environ["SEI_PRIVATE_KEY"])

tx = {
    "to": "0xRecipient",
    "value": w3.to_wei(0.001, "ether"),
    "nonce": w3.eth.get_transaction_count(account.address),
    "chainId": w3.eth.chain_id,
    "type": 2,  # EIP-1559
    "maxPriorityFeePerGas": w3.to_wei(1, "gwei"),
    "maxFeePerGas": w3.eth.gas_price * 2 + w3.to_wei(1, "gwei"),
}
tx["gas"] = w3.eth.estimate_gas(tx)  # always estimate rather than hard-coding

signed = w3.eth.account.sign_transaction(tx, account.key)
tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)

receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print("Mined in block:", receipt.blockNumber)  # final immediately — Sei has instant finality
```

<Warning>Never hard-code or commit a private key. Load it from an environment variable or a secrets manager, and use a dedicated throwaway key funded with only what you need.</Warning>

<Note>`signed.raw_transaction` is the attribute name in web3.py v7+. On web3.py v6 it is `signed.rawTransaction`.</Note>

## Reading a Contract

```python theme={"dark"}
abi = [{
    "constant": True,
    "inputs": [{"name": "owner", "type": "address"}],
    "name": "balanceOf",
    "outputs": [{"name": "", "type": "uint256"}],
    "stateMutability": "view",
    "type": "function",
}]

token = w3.eth.contract(address="0xTokenAddress", abi=abi)
print(token.functions.balanceOf(address).call())
```

## Next Steps

* [viem Quickstart](/evm/evm-parity/examples/viem-quickstart) — the TypeScript/Node.js equivalent
* [ethers v6 Quickstart](/evm/evm-parity/examples/ethers-quickstart) — TypeScript with ethers
* [Network information](/evm/networks) — RPC endpoints, chain IDs, and explorers
* [Faucet](/learn/faucet) — get testnet SEI

---

URL: https://docs.sei.io/evm/evm-wizard

# Using the OpenZeppelin Contract Wizard with Sei EVM

> Learn how to use the OpenZeppelin Contract Wizard to create secure, standard-compliant smart contracts for Sei EVM, with step-by-step guidance and best practices.

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

The OpenZeppelin Contract Wizard is a powerful interactive tool that simplifies the creation of secure, standard-compliant smart contracts for Sei EVM. It provides a user-friendly interface for generating production-ready contract code based on OpenZeppelin's battle-tested libraries. Explore and create your custom smart contracts using the embedded wizard below.

<iframe src="https://wizard.openzeppelin.com/embed" style={{ width: "100%", minHeight: "700px", border: "0", background: "white" }} loading="lazy" title="OpenZeppelin Contract Wizard" />

## Benefits of Using the Wizard

* **Security First**: All generated contracts use audited, industry-standard implementations from OpenZeppelin
* **Time-Saving**: Eliminate boilerplate code and common setup configurations
* **Customizable**: Tailor contracts to your specific requirements through an intuitive UI
* **Educational**: Learn best practices by examining professionally structured contract code
* **Up-to-Date**: Always generates code compatible with the latest Solidity versions and standards

## Available Contract Types

| Contract Type    | Description                    | Common Use Cases                                                 |
| ---------------- | ------------------------------ | ---------------------------------------------------------------- |
| ERC20            | Standard fungible token        | Cryptocurrencies, utility tokens, governance tokens              |
| ERC721           | Non-fungible token (NFT)       | Digital collectibles, art, real estate, certifications           |
| ERC1155          | Multi-token standard           | Gaming assets, mixed fungible/non-fungible collections           |
| Governor         | On-chain governance            | DAO voting systems, protocol management                          |
| Stablecoin       | Price-stable cryptocurrency    | Trading pairs, remittances, reducing volatility, payment systems |
| Real-World-Asset | Tokenized physical assets      | Real estate, commodities, securities, debt instruments, invoices |
| Account          | Programmable Wallet (ERC-4337) | Account abstraction, Multi signature wallets, EOA Delegation     |
| Custom           | Specialized contracts          | Access control, payment systems, timelock functions              |

## Step-by-Step Guide

1. **Access the Wizard**: Use the embedded widget from OpenZeppelin above or visit [wizard.openzeppelin.com](https://wizard.openzeppelin.com/)
2. **Select Contract Type**: Choose the standard that matches your project needs (ERC20, ERC721, etc.)
3. **Configure Basic Settings**:
   * Set token name and symbol
   * Choose Solidity version
   * Select access control mechanism (Ownable, Roles, etc.)
4. **Add Security Features**:
   * Pausable functionality
   * Permit extensions
   * Flash minting capabilities
   * Voting mechanisms
5. **Customize Token Behavior**:
   * Premint options
   * Burning capabilities
   * Token transfer rules
   * Supply management
6. **Review Generated Code**: The code updates in real-time as you make selections
7. **Copy and Implement**: Use the "Copy to clipboard" button to export your contract code
8. **Deploy**: The generated code is ready for compilation and deployment

## Tips for Effective Use

* **Start Simple**: Begin with minimal features and add complexity incrementally
* **Understand Each Option**: Hover over the question icons (?) for detailed explanations
* **Review Dependencies**: Note which OpenZeppelin libraries your contract imports
* **Consider Gas Costs**: More features generally mean higher deployment and operation costs
* **Customize Post-Generation**: The wizard provides a starting point—most projects will require additional customization

## Try it: deploy from the browser

Once the wizard generates your contract, you can compile and deploy it to Sei testnet without any local setup. The Remix sandbox below is preloaded with a sample OpenZeppelin ERC-20 — replace it with your generated code, compile under **Solidity Compiler**, then **Deploy & Run** with **Environment** set to **Injected Provider — MetaMask**.

<AddSeiButton network="testnet" label="Add Sei testnet" />

<SandboxEmbed kind="remix" src="https://remix.ethereum.org/?#activate=solidity,fileManager&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVApwcmFnbWEgc29saWRpdHkgXjAuOC4yNDsKCmltcG9ydCAiQG9wZW56ZXBwZWxpbi9jb250cmFjdHMvdG9rZW4vRVJDMjAvRVJDMjAuc29sIjsKCmNvbnRyYWN0IERlbW9Ub2tlbiBpcyBFUkMyMCB7CiAgICBjb25zdHJ1Y3RvcigpIEVSQzIwKCJEZW1vIFRva2VuIiwgIkRFTU8iKSB7CiAgICAgICAgX21pbnQobXNnLnNlbmRlciwgMV8wMDBfMDAwICogMTAgKiogZGVjaW1hbHMoKSk7CiAgICB9Cn0" title="OpenZeppelin ERC-20 · deploy to Sei testnet" description="Remix IDE preloaded with a sample OpenZeppelin ERC-20. Paste in your wizard output, compile, and deploy to Sei testnet." />

## Learn More

* [OpenZeppelin Contracts Documentation](https://docs.openzeppelin.com/contracts/)
* [OpenZeppelin GitHub Repository](https://github.com/OpenZeppelin/openzeppelin-contracts)
* [OpenZeppelin Community Forum](https://forum.openzeppelin.com/)

---

URL: https://docs.sei.io/evm/solidity-resources

# Solidity Development Resources for Sei EVM

> Comprehensive guide on Solidity Development Resources for Sei EVM on Sei. Learn key concepts, commands, and best practices.

Most development resources for developing with Soldity on Ethereum Mainnet also apply to development on Sei.

This page suggests a minimal set of resources for getting started with building a decentralized app for Sei EVM.

## IDEs

* **[Remix](https://remix.ethereum.org)**\
  An interactive Solidity IDE that is the easiest and fastest way to start coding and compiling Solidity smart contracts without any additional installations.
* **[VSCode](https://code.visualstudio.com)** + **[Solidity extension](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity)**

## Basic Solidity

* **[CryptoZombies](https://cryptozombies.io/en/course)**\
  A great end-to-end introduction to building dApps on the EVM. It offers lessons suitable for complete beginners as well as developers from other disciplines.
* **[Solidity by Example](https://solidity-by-example.org)**\
  Introduces Solidity concepts progressively through simple examples – ideal for developers with some programming background.
* **[Blockchain Basics course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/blockchain-basics)**\
  Covers the fundamentals of blockchain, DeFi, and smart contracts.
* **[Solidity Smart Contract Development by Cyfrin Updraft](https://updraft.cyfrin.io/courses/solidity)**\
  Offers hands-on experience to become a smart contract developer.
* **[Ethereum Developer Degree by LearnWeb3](https://learnweb3.io)**\
  A course designed to take you from no background in web3 to building multiple applications and understanding key protocols, frameworks, and concepts.

## Intermediate Solidity

* **[The Solidity Language](https://docs.soliditylang.org)**\
  Official documentation providing an end-to-end description of smart contracts, blockchain basics, compiling, and deployment on an EVM.
* **[Solidity Patterns](https://github.com/fravoll/solidity-patterns)**\
  A repository of code templates with explanations of their usage.
* **[OpenZeppelin](https://www.openzeppelin.com)**\
  Provides a library of customizable template contracts for common Ethereum token deployments (e.g., ERC20, ERC721, ERC1155, Proxy). Note that these are not gas optimized. They provide the defacto standard for smart contract templates and are used across almost all existing smart contracts.
* **[Uniswap](https://github.com/Uniswap)**\
  A professional, easy-to-digest smart contract of the [Uniswap V2 pools](https://github.com/Uniswap/v2-core) that gives an overview of an in-production Solidity dApp. A guided walkthrough is available [here](https://ethereum.org/en/developers/tutorials/uniswap-v2-annotated-code/). For the more advanced Uniswap Pools, check out the Uniswap V3 [here](https://github.com/Uniswap/v3-core) and Uniswap V4 [here](https://github.com/Uniswap/v4-core).
* **[Morpho Finance](https://github.com/morpho-org)**\
  Morpho Finance's contracts provides an excellent real-world example of production-grade Solidity smart contracts, demonstrating how a successful DeFi lending protocol is structured and implemented. By studying Morpho's codebase, you can learn advanced patterns for gas optimization, security best practices, and complex financial logic implementation in a production environment. The accompanying documentation [here](https://docs.morpho.org/overview/) offers additional context to understand the protocol's architecture and design principles.
* **[Sky / Maker DAO](https://github.com/makerdao)**
  A pioneering DeFi protocol that created the DAI and USDS stablecoin. MakerDAO's codebase showcases complex financial mechanisms including collateralized debt positions, oracles, and governance systems. The project demonstrates how to implement a stable cryptocurrency backed by crypto collateral through sophisticated risk management systems.
* **[Rareskills Blog](https://rareskills.io/blog)**\
  Features in-depth articles on various Solidity concepts and their [Book of Gas Optimization](https://www.rareskills.io/post/gas-optimization).
* **[Foundry Fundamentals course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/foundry)**\
  A comprehensive web3 development course covering Foundry—the industry-standard framework for building, deploying, and testing smart contracts.
* **[Smart Contract Programmer YT channel](https://www.youtube.com/@smartcontractprogrammer)**\
  Contains many in-depth videos covering topics from ABI encoding to EVM memory management.
* **[DeFi developer roadmap](https://github.com/OffcierCia/DeFi-Developer-Road-Map)**

## Advanced Solidity

* **[Solmate repository](https://github.com/transmissions11/solmate)** and **[Solady repository](https://github.com/Vectorized/solady)**\
  Gas-optimized contracts using Solidity or Yul.
* **[Yul](https://docs.soliditylang.org/en/latest/yul.html)**\
  An intermediate language for Solidity, akin to inline assembly for the EVM, offering control flow constructs while exposing low-level memory management.
* **[Advanced Foundry course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/advanced-foundry)**\
  Teaches advanced smart contract development including building DeFi protocols, stablecoins, DAOs, and more.
* **[Smart Contract Security course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/security)**\
  Provides comprehensive training on auditing and writing secure protocols.
* **[Assembly and Formal Verification course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/formal-verification)**\
  Covers Assembly, using Yul, EVM opcodes, formal verification testing, and related tools.
* **[Smart Contract DevOps course by Cyfrin Updraft](https://updraft.cyfrin.io/courses/wallets)**\
  Focuses on post-deployment security, wallet access control, and ongoing protocol maintenance.
* **[Secureum YT Channel](https://www.youtube.com/@SecureumVideos)**\
  Features a variety of videos covering topics from Solidity basics to advanced subjects such as fuzzing and auditing.

## Tutorials

* **[Ethernaut](https://ethernaut.openzeppelin.com)**\
  Learn Solidity by solving puzzles.
* **[Damn Vulnerable DeFi](https://www.damnvulnerabledefi.xyz)**\
  A series of smart contract challenges designed to test and improve your Solidity skills.

## Testing

* **[Echidna](https://github.com/crytic/echidna)**\
  Fuzz testing tool for Solidity.
* **[Slither](https://github.com/crytic/slither)**\
  A static analysis framework for detecting vulnerabilities.
* **[solidity-coverage](https://github.com/sc-forks/solidity-coverage)**\
  Provides code coverage metrics for Solidity tests.

## Smart contract archives

* **[Smart contract sanctuary](https://github.com/tintinweb/smart-contract-sanctuary)**\
  A collection of contracts verified on Etherscan.
* **[EVM function signature database](https://www.4byte.directory)**
* **[EVM verified contracts on Etherscan](https://etherscan.io/contractsVerified)**
  If you are adventurous: Check the verified contracts on Etherscan directly.

## Using the OpenZeppelin Wizard

OpenZeppelin provides a convenient web-based wizard to create standard contracts. Visit the docs section for it [here](/evm/evm-wizard) or [https://wizard.openzeppelin.com/](https://wizard.openzeppelin.com/) to access it.

The wizard allows you to:

1. Select the contract type (ERC20, ERC721, ERC1155, etc.)
2. Configure settings, features, and access controls
3. Add custom functionality through a user-friendly interface
4. Generate ready-to-use Solidity code

The wizard is perfect for:

* Beginners learning smart contract development
* Quickly bootstrapping standard token contracts
* Exploring different configuration options
* Understanding best practices in contract development

## Best Practices & Security Considerations

When developing on Sei EVM with OpenZeppelin contracts, follow these best practices:

1. **Always use the latest version** of OpenZeppelin contracts
2. **Start with existing, audited components** rather than building from scratch
3. **Run comprehensive tests** before deploying to mainnet
4. **Consider upgradeability** for complex applications
5. **Use access controls** like `Ownable` or `AccessControl` for privileged functions
6. **Implement reentrancy guards** where needed
7. **Avoid `transfer()` and `send()`** for ETH transfers, use `call()` with reentrancy protection
8. **Validate all inputs** and check for edge cases
9. **Consider gas optimization**, but not at the expense of security
10. **Consider getting an audit** for high-value contracts

---

URL: https://docs.sei.io/evm/best-practices/optimizing-for-parallelization

# Optimizing Contracts for Parallelization

> Design patterns to reduce state conflicts and maximize Sei EVM parallel execution while lowering gas usage.

Sei EVM executes non-conflicting transactions in parallel. You can significantly increase throughput and reduce gas by designing contracts that minimize shared state access and avoid unnecessary storage writes.

<Info>
  This guide is based on Sei's recommendations for reducing gas usage and enhancing parallel execution. For the engine design, see [Parallelization Engine](/learn/parallelization-engine).
</Info>

## Principles for Parallel-Friendly Contracts

* **Minimize shared writes**: The scheduler can parallelize transactions that do not write to the same storage keys. Avoid hot globals (e.g., a single counter updated on every call).
* **Partition state**: Shard storage by user, asset, or id so independent transactions touch disjoint keys.
* **Prefer pull over push**: Let users claim funds instead of mass-paying recipients in loops.
* **Avoid unbounded loops**: Especially loops that write to storage or iterate over dynamic arrays/mappings.
* **Batch internal work; isolate external effects**: Do heavy computation in memory and commit a minimal set of storage writes.
* **Use precompiles when available**: Precompiles are highly optimized and cheaper than replicating logic in Solidity.

<Tip>
  **Parallelization checklist:**

  * Partition storage by user/asset/id; avoid hot globals
  * Minimize number of storage writes per call; batch in-memory, commit once
  * Avoid loops with storage writes; switch to pull-based flows
  * Favor precompiles for supported features
  * Apply standard gas optimizations (`external`, packing, `unchecked`, memory-first)
</Tip>

## Storage Design Patterns

### Partition state by key

Isolate per-user/per-asset data instead of centralizing writes.

```solidity theme={"dark"}
// Good: disjoint keys by user and id enable parallelism
mapping(address => mapping(uint256 => Position)) public positions;

function updatePosition(uint256 id, int256 delta) external {
    Position storage p = positions[msg.sender][id];
    // in-memory arithmetic first
    int256 newQty = p.qty + delta;
    // commit minimal writes
    p.qty = newQty;
}
```

Anti-patterns:

* Writing a global `totalVolume += amount;` in every transaction
* Maintaining a single on-chain queue or registry updated by most calls

Prefer computing aggregates off-chain from events, or update them periodically via a dedicated maintenance transaction and place them in the calldata.

### Prefer pull payments

Avoid writing to many recipients in a single transaction. Emit events and let recipients `withdraw()` when needed.

```solidity theme={"dark"}
// Better: users pull their own rewards, isolating writes to their key
mapping(address => uint256) public accrued;

function accrue(address user, uint256 amount) internal {
    accrued[user] += amount; // isolated write
}

function withdraw() external {
    uint256 due = accrued[msg.sender];
    accrued[msg.sender] = 0; // single-key write
    (bool ok, ) = msg.sender.call{value: due}("");
    require(ok, "TRANSFER_FAILED");
}
```

### Avoid large storage writes in loops

If you must process many items, keep work in memory and commit a compact result, or split work across multiple transactions keyed by different ids.

## Gas-Efficient Solidity Practices

* **Use `external` for externally called functions**; mark pure/read-only with `pure`/`view`.
* **Pack variables** to share storage slots (e.g., multiple `uint8` in one slot).
* Prefer **`bytes32` over `string`** when applicable.
* **Cache array lengths** in loops and short-circuit cheap conditions first.
* Use **`unchecked`** for arithmetic when overflow is impossible.
* Prefer **memory** over storage for temporary data; commit only final values.

These reduce gas and often reduce storage touches, which also improves parallelism.

## Leverage Sei Precompiles

Sei provides precompiled contracts for common functionality—cheaper and simpler than custom Solidity equivalents:

* [JSON](/evm/precompiles/json) (`0x1003`)
* [P256](/evm/precompiles/p256-precompile) (`0x1011`)

See [precompile examples](/evm/precompiles/example-usage) for quick starts.

## Testing and Analysis

* Use Foundry/Hardhat gas reporters to track changes per function.
* Benchmark under concurrent load to detect hot keys (addresses/ids) that serialize execution.
* Inspect execution with [JavaScript tracers](/evm/tracing/javascript-tracers) and runtime logs.

---

URL: https://docs.sei.io/evm/best-practices/zeroing-stale-state

# Zeroing Out Stale State

> Strategies for clearing unused EVM storage on Sei to reduce state growth and improve node performance.

Zeroing out state means setting stored contract values back to their defaults (e.g., `0`, `false`, `address(0)`) by writing `non-zero → zero` into EVM storage slots.

## Why Zero Out State

Non-zero storage contributes to global state size. Clearing stale state reduces state growth pressure and can improve node operations, sync, and restart behavior. This matters especially on high-throughput chains like Sei where state growth can be aggressive.

<Info>Clearing a non-zero storage slot to zero earns a **4,800 gas refund** per slot.</Info>

## Clearing State Variables, Arrays, and Maps

### Simple Fixed-Size State

For value types and fixed-size arrays, use `delete` (or assign the default) to reset values to their defaults (`0`, `address(0)`, `false`).

```solidity theme={"dark"}
uint256 public value;
bool public flag;
address public addr;
uint256[10] public fixedArr;

function clearSimple() external {
    delete value;    // → 0
    delete flag;     // → false
    delete addr;     // → address(0)
    delete fixedArr; // zeroes every element
}
```

### Dynamic Arrays

Using `delete` on a dynamic array resets its length to 0 and clears all elements, but this can be too expensive for large arrays and risks hitting the block gas limit.

The safer approach is **batched clearing** by repeatedly calling `pop()` in chunks.

<Warning>If a dynamic array might exceed **\~500 elements**, use batched clearing to avoid running out of gas.</Warning>

```solidity theme={"dark"}
uint256[] public dynamicArr;

function batchClear(uint256 batchSize) external {
    uint256 len = dynamicArr.length;
    uint256 toClear = batchSize < len ? batchSize : len;
    for (uint256 i = 0; i < toClear; i++) {
        dynamicArr.pop();
    }
}
```

### Mappings

You can't iterate a mapping, so you can't clear it unless you can enumerate keys. The main strategy is to **maintain an index of keys** (e.g., a `holders[]` array plus an `_isHolder` flag) whenever you write, then later delete mapping entries in batches by iterating that key list.

<Info>Maintaining an index costs roughly one extra `SSTORE` per write (Sei: \~72,000 gas; see [EVM Differences](/evm/differences-with-ethereum#sstore-gas-cost)), but makes future clearing possible.</Info>

```solidity theme={"dark"}
mapping(address => uint256) public balances;
address[] public holders;
mapping(address => bool) private _isHolder;

function setBalance(address user, uint256 amount) external {
    if (!_isHolder[user]) {
        _isHolder[user] = true;
        holders.push(user);
    }
    balances[user] = amount;
}

function batchClearBalances(uint256 start, uint256 end) external {
    if (end > holders.length) end = holders.length;
    for (uint256 i = start; i < end; i++) {
        address user = holders[i];
        delete balances[user];
        delete _isHolder[user];
    }
}
```

## Strategies for Existing Contracts

### External Cleaner Contract

If you control permissions and the original contract has callable setters/entrypoints, deploy a separate "cleaner" contract that loops through user/key batches and calls the original contract to set values to zero.

<Warning>This only clears state reachable through the **public/external interface**. Truly internal or private state with no setters can't be touched.</Warning>

See [Appendix A](#appendix-a---external-cleaner-contract) for example code.

### Proxy / Upgradeable Contract

If you have a proxy or upgradeable contract, this is the best-case scenario. Upgrade the implementation to add reset functions while **preserving storage layout**, run batched resets, then optionally upgrade again to remove the reset logic.

See [Appendix B](#appendix-b---proxyupgradeable-contract) for example code.

### Reconstruct Keys from Event Logs

If contract writes emit events (which is common), scan historical logs to recover mapping keys (e.g., recipients from `Transfer` events), deduplicate them, and pass that list into a batch-clear call.

### Use a Subgraph or Custom Indexer

For complex or nested state, use [The Graph](https://thegraph.com/) or your own indexer to build a full set of non-zero keys/entities off-chain, then feed the resulting address/key list into on-chain batch clearing. This moves enumeration complexity off-chain while the on-chain work is just applying clears.

### Brute-Force via Direct Storage Reads

If you have a candidate universe of keys (e.g., all addresses that ever interacted), compute each mapping slot (`keccak256(key, slot)` — tools like `cast index` do this), read storage via RPC, and keep only the non-zero keys to clear.

<Info>This approach is tedious and RPC-heavy but works when events are missing or unreliable.</Info>

## Appendix A - External Cleaner Contract

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IResettableTarget {
    function setBalance(address user, uint256 amount) external;
}

contract StateCleaner {
    IResettableTarget public immutable target;

    constructor(address _target) {
        target = IResettableTarget(_target);
    }

    function clearBalances(address[] calldata users) external {
        for (uint256 i = 0; i < users.length; i++) {
            target.setBalance(users[i], 0);
        }
    }
}
```

## Appendix B - Proxy/Upgradeable Contract

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

/// @notice UUPS upgradeable implementation that supports batched state clearing.
/// @dev Storage lives in the proxy; this implementation provides logic.
contract V2Resettable is UUPSUpgradeable, OwnableUpgradeable {
    uint256 public totalSupply;
    mapping(address => uint256) public balances;

    address[] public holders;
    mapping(address => bool) private isHolder;

    function initialize() external initializer {
        __Ownable_init();
        __UUPSUpgradeable_init();
    }

    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}

    function setBalance(address user, uint256 amount) external onlyOwner {
        if (!isHolder[user]) {
            isHolder[user] = true;
            holders.push(user);
        }
        balances[user] = amount;
    }

    /// @notice Batch-clear balances for a caller-supplied list of users.
    /// @dev Enumerate keys off-chain (events/indexer) and pass them in.
    function resetBalances(address[] calldata users) external onlyOwner {
        for (uint256 i = 0; i < users.length; i++) {
            address u = users[i];
            delete balances[u];
            delete isHolder[u];
        }
    }
}
```

---

URL: https://docs.sei.io/evm/debugging-contracts

# Debugging for EVM

> Advanced debugging techniques for EVM transactions on Sei. Learn transaction template generation and analysis using seid and Foundry cast tools.

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

## Overview

Debugging EVM transactions on Sei requires understanding both the transaction creation process and how to analyze transaction behavior. This guide covers advanced debugging techniques using transaction template generation, analysis tools, and comprehensive transaction inspection methods to help developers identify and resolve issues in their EVM interactions.

## Transaction Template Generation

The `--generate-only` flag transforms any Sei CLI transaction command into a template generator, creating complete transaction structures without broadcasting them. Through the `--generate-only` flag and Foundry's `cast` tool, developers can craft, analyze, and debug transactions across the EVM environment.

### Basic Command Pattern

The general pattern follows this structure:

```bash theme={"dark"}
seid tx <module> <action> <parameters> --from <key> --evm-rpc http://url-to-sei-evm-rpc --generate-only
```

### Generating EVM Transaction Templates

To generate an EVM transaction template, use the `evm` module with `--generate-only`. Here's an example sending SEI to another EVM address:

```bash theme={"dark"}
seid tx evm send 0xRecipientAddress 1000000000000000000 \
--gas-fee-cap=100000000000 \
--gas-limit=21000 \
--evm-rpc=http://url-to-sei-evm-rpc \
--from=mykey \
--generate-only
```

<Info>This command returns a transaction template that you can analyze before broadcasting. The template includes all transaction details without executing the actual transaction.</Info>

***

## Analyzing EVM Transactions with Cast

Once you have a transaction hash, you can use Foundry's `cast` command to inspect the transaction details:

```bash theme={"dark"}
cast tx 0x5010e6600e67f04a9bc3d3b670a7c2de380b180713d9a014a5dbd76b7e2190f1 \
--rpc-url=http://url-to-sei-evm-rpc
```

**Example Output:**

```text theme={"dark"}
blockHash               0x4696d63a9a9ae88b03bcc94ccbd87f407e994b309d1dff9c0626de51ac57b76e
blockNumber             130076639
from                    0xAa55a16dD4E73c48C968928983c2bcC98d913d96
transactionIndex        7
effectiveGasPrice       100000000000
accessList              []
chainId                 1329
gasLimit                2500000
hash                    0x5010e6600e67f04a9bc3d3b670a7c2de380b180713d9a014a5dbd76b7e2190f1
input                   0xc31d960f0000...
maxFeePerGas            100000000000
maxPriorityFeePerGas    100000000000
nonce                   3
to                      0x000000000000000000000000000000000000100b
type                    2
value                   0
```

### Additional Analysis Commands

**Get transaction receipt:**

```bash theme={"dark"}
cast receipt 0x5010e6600e67f04a9bc3d3b670a7c2de380b180713d9a014a5dbd76b7e2190f1 \
--rpc-url=http://url-to-sei-evm-rpc
```

**Decode transaction input data:**

```bash theme={"dark"}
cast 4byte-decode 0xc31d960f0000...
```

<Info>All template generation commands create JSON files that you can inspect, modify, and use for debugging before executing the actual transactions.</Info>

***

## RPC Consistency

<Warning>Always point `cast` commands to an EVM RPC endpoint (for example, `$EVM_RPC_URL`), not a Cosmos RPC URL.</Warning>

***

## Tracing and Revert Reasons

If your endpoint supports debug RPC methods, you can retrieve full execution traces and revert reasons:

```bash theme={"dark"}
# Full transaction trace
cast rpc debug_traceTransaction 0xTX_HASH '{"tracer":"callTracer","timeout":"120s"}' \
  --rpc-url=$EVM_RPC_URL

# Simulate and trace a call without broadcasting
cast rpc debug_traceCall '{"from":"0xFROM","to":"0xTO","data":"0xDATA"}' \
  'latest' '{"tracer":"callTracer","timeout":"120s"}' \
  --rpc-url=$EVM_RPC_URL
```

<Info>
  Many public RPC endpoints disable debug methods. If disabled, run a local fork and trace there. See Tracing docs at <a href="/evm/tracing">/evm/tracing</a>.
</Info>

***

## Reproduce with a Local Fork

Fork the network locally to reproduce issues deterministically and run traces even if remote debug RPC is disabled:

```bash theme={"dark"}
# Start a local fork
anvil --fork-url $EVM_RPC_URL

# Re-run calls against the fork
cast call 0xContract "method(uint256)" 1 --rpc-url=http://127.0.0.1:8545

# Trace the call on the fork via debug RPC
cast rpc debug_traceCall '{"to":"0xContract","data":"0xENCODED_DATA"}' \
  'latest' '{"tracer":"callTracer"}' --rpc-url=http://127.0.0.1:8545
```

***

## Event Logs and Decoding

Use the receipt to inspect logs and decode with the contract ABI:

```bash theme={"dark"}
# Fetch receipt JSON and view logs
cast receipt 0xTX_HASH --rpc-url=$EVM_RPC_URL --json | jq '.logs'

# Compute an event signature for topic[0]
cast keccak "Transfer(address,address,uint256)"
```

<Info>Decode event topics/data using the contract ABI (from your repo or block explorer). Topic\[0] equals the keccak of the event signature.</Info>

***

## Nonce, Balance, and Gas Diagnostics

Check common failure points quickly:

```bash theme={"dark"}
cast nonce 0xYourAddress --rpc-url=$EVM_RPC_URL
cast balance 0xYourAddress --rpc-url=$EVM_RPC_URL
cast gas-price --rpc-url=$EVM_RPC_URL
cast block latest baseFeePerGas --rpc-url=$EVM_RPC_URL
cast chain-id --rpc-url=$EVM_RPC_URL
```

**Checklist:**

* Incorrect nonce (pending tx in mempool)
* Insufficient native balance for gas
* Underpriced `maxFeePerGas`/`maxPriorityFeePerGas`
* Chain ID mismatch

## Try it live

Each `cast` diagnostic above is a plain read-only JSON-RPC call. Run the same four against Sei mainnet right here — the example address (`0xAa55…3d96`) is the sender from the `cast tx` output earlier on this page.

<RunSnippet method="eth_chainId" network="mainnet" title="cast chain-id" description="eth_chainId — decodes to 1329. A mismatch here is the most common cause of a rejected transaction." />

<RunSnippet method="eth_gasPrice" network="mainnet" title="cast gas-price" description="eth_gasPrice — the current gas price in wei. Compare it against your maxFeePerGas when a transaction is stuck as underpriced." />

<RunSnippet method="eth_getTransactionCount" params={['0xAa55a16dD4E73c48C968928983c2bcC98d913d96', 'latest']} network="mainnet" title="cast nonce 0xAa55…3d96" description="eth_getTransactionCount at the latest block — the account's next nonce. Swap in your own address." />

<RunSnippet method="eth_getBalance" params={['0xAa55a16dD4E73c48C968928983c2bcC98d913d96', 'latest']} network="mainnet" title="cast balance 0xAa55…3d96" description="eth_getBalance in wei — confirm the account can cover gas before you dig into a failed send." />

***

## Offline Workflow with --generate-only

Generate, inspect, sign, and broadcast safely:

```bash theme={"dark"}
# 1) Generate a template (no broadcast)
seid tx evm send 0xTO 1000000000000000000 \
  --from=$WALLET_NAME --evm-rpc=$EVM_RPC_URL --generate-only > tx.json

# 2) Sign offline with your key
seid tx sign tx.json --from $WALLET_NAME --chain-id $CHAIN_ID > signed.json

# 3) Broadcast the signed tx
seid tx broadcast signed.json
```

<Warning>Never commit signed transactions or private keys. Use environment variables and `.gitignore` for sensitive data.</Warning>

***

## Precompile Awareness

Calls to system precompiles (for example, addresses like `0x...100b`) may have specific input/output formats and error behavior.

* See [EVM precompiles](/evm/precompiles/example-usage) and [EVM Cosmos precompiles](/evm/precompiles/cosmwasm-precompiles/example-usage)
* Cross-check expected selectors, parameter encoding, and revert messages

***

## Storage Inspection

Verify on-chain state directly when debugging state changes:

```bash theme={"dark"}
cast storage 0xContract 0xSLOT --rpc-url=$EVM_RPC_URL
```

***

## Transaction Analysis

When analyzing transactions, follow these essential practices:

* Always verify EVM transactions thoroughly
* Use `cast` to decode input data when working with EVM transactions
* Keep track of gas parameters
* Monitor transaction status on the EVM layer

**Analysis Tips:**

```bash theme={"dark"}
# Use Foundry's cast tool for detailed transaction inspection
cast tx 0x5010e6600e67f04a9bc3d3b670a7c2de380b180713d9a014a5dbd76b7e2190f1 \
--rpc-url=$EVM_RPC_URL

# Get transaction receipt to verify success
cast receipt 0x5010e6600e67f04a9bc3d3b670a7c2de380b180713d9a014a5dbd76b7e2190f1 \
--rpc-url=$EVM_RPC_URL

# Decode transaction input data
cast 4byte-decode 0xa9059cbb000000...
```

<Info>
  <strong>Transaction Analysis Checklist:</strong> Always verify transaction success before proceeding. Check gas usage to optimize future transactions. Use Foundry's cast tool for detailed transaction inspection.
</Info>

***

## Error Handling

Handle potential EVM transaction issues with proper monitoring:

```javascript theme={"dark"}
try {
  // Check EVM transaction status
  const evmStatus = await checkEvmStatus(txHash);
  if (!evmStatus.success) {
    const evmError = await cast.call(['tx', txHash, '--rpc-url', evmRpcUrl]);
    console.error('EVM transaction failed:', evmError);
  }
} catch (error) {
  console.error('Transaction analysis failed:', error);
}
```

**Best Practices for Error Handling:**

* Always check transaction status on both Cosmos and EVM layers
* Use detailed error logging for debugging failed transactions
* Implement retry logic for network-related failures
* Monitor gas usage and adjust limits accordingly

***

## Security Guidelines

<Warning>
  <strong>Critical Security Requirements:</strong> Keep private keys secure and never include them in templates. Use an `.env` file or other environment variables when working with wallet keys or mnemonics. Never commit sensitive information to version control. Always verify transaction details before signing.
</Warning>

**Environment Variable Setup:**

```bash theme={"dark"}
# Create .env file for sensitive data
WALLET_NAME=mykey
EVM_RPC_URL=http://url-to-sei-evm-rpc
PRIVATE_KEY=your_private_key_here

# Add .env to .gitignore
echo ".env" >> .gitignore
```

**Secure Transaction Execution:**

```bash theme={"dark"}
# Use environment variables in commands
seid tx evm send 0x1234567890abcdef... 1000000000000000000 \
--from=$WALLET_NAME \
--evm-rpc=$EVM_RPC_URL

# Generate transaction template first to verify details
seid tx evm send 0x1234567890abcdef... 1000000000000000000 \
--from=$WALLET_NAME \
--evm-rpc=$EVM_RPC_URL \
--generate-only
```

---

URL: https://docs.sei.io/evm/tracing

# Debug Tracing Overview

> Comprehensive guide to debugging and tracing EVM transactions on Sei. Learn to analyze transaction execution, optimize gas usage, and troubleshoot smart contracts with real examples and end-to-end workflows.

## Requirements

The examples in this guide call the debug JSON-RPC endpoints directly with `curl` — no SDK or additional libraries are required. Optionally install [`jq`](https://jqlang.github.io/jq/) to pretty-print the JSON responses:

```bash theme={"dark"}
# macOS
brew install jq

# Debian/Ubuntu
sudo apt-get install jq
```

Debug tracing is your primary tool for understanding EVM transaction execution on Sei. This comprehensive system allows you to analyze transaction flow, optimize gas usage, debug smart contract interactions, and troubleshoot production issues.

## What You Can Trace

### Transaction Execution

* Step-by-step opcode execution
* Contract call hierarchy
* Gas consumption breakdown
* State changes and storage access

### Contract Interactions

* Cross-contract calls and returns
* Event emission analysis
* Precompile usage tracking
* External library calls

### Performance Analysis

* Gas optimization opportunities
* Bottleneck identification
* Cache hit/miss patterns
* State access efficiency

### Security Analysis

* Suspicious operation detection
* Reentrancy pattern analysis
* Access control verification
* Vulnerability scanning

## Available Tracing Methods

| Method                     | Purpose                    | Use Case                      |
| -------------------------- | -------------------------- | ----------------------------- |
| `debug_traceTransaction`   | Trace specific transaction | Debugging failed transactions |
| `debug_traceBlockByNumber` | Trace entire block         | Block-level analysis          |
| `debug_traceCall`          | Simulate and trace         | Testing before execution      |
| `debug_traceStateAccess`   | State access patterns      | Performance optimization      |

## Transaction Analysis Example

Tracing an ERC-20 transfer transaction:

<Tabs>
  <Tab title="Transaction Details">
    ```bash theme={"dark"}
    # Real transaction on Sei mainnet
    TRANSACTION_HASH="0x75b7ba10248e90db85b224eae587db1728520b6f72c795b9185064f444cee7c3"

    # Transaction details

    curl -X POST -H "Content-Type: application/json" \
     --data '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByHash",
    "params": ["'$TRANSACTION_HASH'"],
    "id": 1
    }' \
     https://evm-rpc.sei-apis.com

    ```

    **Response:**

    ```json theme={"dark"}
    {
      "jsonrpc": "2.0",
      "id": 1,
      "result": {
        "blockHash": "0xbc229fe41605ba2b46fcd7aa7ce328dc2f6da78385dfea84ca8dbef7b4325462",
        "blockNumber": "0x97aefcf",
        "from": "0x4cbee7ad42d33e9d3b41e8b6faca2f6f173c8a94",
        "gas": "0x66f24",
        "gasPrice": "0x565dd756",
        "maxFeePerGas": "0x565dd756",
        "maxPriorityFeePerGas": "0x5e679d6",
        "hash": "0x75b7ba10248e90db85b224eae587db1728520b6f72c795b9185064f444cee7c3",
        "input": "0x733214a3e5f551789f7ee58322679a2b141e64533098b8ba41d9e10cf8061a18a777d6ce00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000004cbee7ad42d33e9d3b41e8b6faca2f6f173c8a940000000000000000000000000000000000000000000000000dd26083bfc745570000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000000f6a756d7065722e65786368616e67650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002a30783030303030303030303030303030303030303030303030303030303030303030303030303030303000000000000000000000000000000000000000000000000000000000000000000000fde9ce4e17b650efdca13d524f132876700d806f000000000000000000000000fde9ce4e17b650efdca13d524f132876700d806f0000000000000000000000003894085ef7ff0f0aedf52e2a2704928d1ec074f10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004faaa00000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000001642646478b0000000000000000000000003894085ef7ff0f0aedf52e2a2704928d1ec074f1000000000000000000000000000000000000000000000000000000000004faaa000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee0000000000000000000000000000000000000000000000000dd26083bfc745570000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae00000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000070023894085ef7ff0f0aedf52e2a2704928d1ec074f101ffff015cfa8db453c9904511c4ea9eb0bfc903e36b9f5f01fde9ce4e17b650efdca13d524f132876700d806f01e30fedd158a2e3b13e9badaeabafc5516e95e8c701ffff02001231deb6f5749ef6ce6943a275a1d3e7486f4eae0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        "nonce": "0x4",
        "to": "0x1231deb6f5749ef6ce6943a275a1d3e7486f4eae",
        "transactionIndex": "0x14",
        "value": "0x0",
        "type": "0x2",
        "accessList": [],
        "chainId": "0x531",
        "v": "0x0",
        "r": "0x3a107aca9cd554a9171a65ea2e8ef56ebeca8cfdc17f4bbecfb0f86837ca90d6",
        "s": "0x426134cf65b701bc8d43162f78bcf787319ff17cc6293188bcbb30fd99feb60",
        "yParity": "0x0"
      }
    }
    ```
  </Tab>

  <Tab title="Basic Trace">
    ```bash theme={"dark"}
    # Trace the transaction execution
    curl -X POST -H "Content-Type: application/json" \
      --data '{
        "jsonrpc": "2.0",
        "method": "debug_traceTransaction",
        "params": [
          "'$TRANSACTION_HASH'",
          {
            "tracer": "callTracer",
            "tracerConfig": {
              "withLog": true
            }
          }
        ],
        "id": 1
      }' \
      https://evm-rpc.sei-apis.com
    ```

    **Response:**

    ```json theme={"dark"}
    {
      "jsonrpc": "2.0",
      "id": 1,
      "result": {
        "from": "0x4cbee7ad42d33e9d3b41e8b6faca2f6f173c8a94",
        "gas": "0x66f24",
        "gasUsed": "0x40f98",
        "to": "0x1231deb6f5749ef6ce6943a275a1d3e7486f4eae",
        "input": "0x733214a3e5f551789f7ee58322679a2b141e64533098b8ba41d9e10cf8061a18a777d6ce00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000004cbee7ad42d33e9d3b41e8b6faca2f6f173c8a940000000000000000000000000000000000000000000000000dd26083bfc745570000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000000f6a756d7065722e65786368616e67650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002a30783030303030303030303030303030303030303030303030303030303030303030303030303030303000000000000000000000000000000000000000000000000000000000000000000000fde9ce4e17b650efdca13d524f132876700d806f000000000000000000000000fde9ce4e17b650efdca13d524f132876700d806f0000000000000000000000003894085ef7ff0f0aedf52e2a2704928d1ec074f10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004faaa00000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000001642646478b0000000000000000000000003894085ef7ff0f0aedf52e2a2704928d1ec074f1000000000000000000000000000000000000000000000000000000000004faaa000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee0000000000000000000000000000000000000000000000000dd26083bfc745570000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae00000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000070023894085ef7ff0f0aedf52e2a2704928d1ec074f101ffff015cfa8db453c9904511c4ea9eb0bfc903e36b9f5f01fde9ce4e17b650efdca13d524f132876700d806f01e30fedd158a2e3b13e9badaeabafc5516e95e8c701ffff02001231deb6f5749ef6ce6943a275a1d3e7486f4eae0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        "calls": [
          {
            "from": "0x1231deb6f5749ef6ce6943a275a1d3e7486f4eae",
            "gas": "0x5d03f",
            "gasUsed": "0x3b0cc",
            "to": "0x31a9b1835864706af10103b31ea2b79bdb995f5f",
            "input": "0x733214a3e5f551789f7ee58322679a2b141e64533098b8ba41d9e10cf8061a18a777d6ce00000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000004cbee7ad42d33e9d3b41e8b6faca2f6f173c8a940000000000000000000000000000000000000000000000000dd26083bfc745570000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000000f6a756d7065722e65786368616e67650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002a30783030303030303030303030303030303030303030303030303030303030303030303030303030303000000000000000000000000000000000000000000000000000000000000000000000fde9ce4e17b650efdca13d524f132876700d806f000000000000000000000000fde9ce4e17b650efdca13d524f132876700d806f0000000000000000000000003894085ef7ff0f0aedf52e2a2704928d1ec074f10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004faaa00000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000001642646478b0000000000000000000000003894085ef7ff0f0aedf52e2a2704928d1ec074f1000000000000000000000000000000000000000000000000000000000004faaa000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee0000000000000000000000000000000000000000000000000dd26083bfc745570000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae00000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000070023894085ef7ff0f0aedf52e2a2704928d1ec074f101ffff015cfa8db453c9904511c4ea9eb0bfc903e36b9f5f01fde9ce4e17b650efdca13d524f132876700d806f01e30fedd158a2e3b13e9badaeabafc5516e95e8c701ffff02001231deb6f5749ef6ce6943a275a1d3e7486f4eae0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
            "calls": [
              {
                "from": "0x1231deb6f5749ef6ce6943a275a1d3e7486f4eae",
                "gas": "0x5aa48",
                "gasUsed": "0xa724",
                "to": "0x3894085ef7ff0f0aedf52e2a2704928d1ec074f1",
                "input": "0x23b872dd0000000000000000000000004cbee7ad42d33e9d3b41e8b6faca2f6f173c8a940000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae000000000000000000000000000000000000000000000000000000000004faaa",
                "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
                "calls": [
                  {
                    "from": "0x3894085ef7ff0f0aedf52e2a2704928d1ec074f1",
                    "gas": "0x54283",
                    "gasUsed": "0x4ad6",
                    "to": "0x0000000000000000000000000000000000001001",
                    "input": "0x5c05961b0000000000000000000000004cbee7ad42d33e9d3b41e8b6faca2f6f173c8a940000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000004faaa00000000000000000000000000000000000000000000000000000000000000446962632f4341364642464146333939343734413036323633453130443043453541454242453135313839443644344232444439414445363130303745363845423944423000000000000000000000000000000000000000000000000000000000",
                    "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
                    "value": "0x0",
                    "type": "CALL"
                  }
                ],
                "logs": [
                  {
                    "address": "0x3894085ef7ff0f0aedf52e2a2704928d1ec074f1",
                    "topics": [
                      "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                      "0x0000000000000000000000004cbee7ad42d33e9d3b41e8b6faca2f6f173c8a94",
                      "0x0000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae"
                    ],
                    "data": "0x000000000000000000000000000000000000000000000000000000000004faaa",
                    "position": "0x1"
                  }
                ],
                "value": "0x0",
                "type": "CALL"
              },
              ...
            ]
          }
        ]
      }
    }
    ```
  </Tab>

  <Tab title="Gas Analysis">
    ```bash theme={"dark"}
    # Analyze gas usage patterns
    curl -X POST -H "Content-Type: application/json" \
      --data '{
        "jsonrpc": "2.0",
        "method": "debug_traceTransaction",
        "params": [
          "0x75b7ba10248e90db85b224eae587db1728520b6f72c795b9185064f444cee7c3",
          {
            "tracer": "{gasUsed: 0, operations: {}, step: function(log, db) { var op = log.op.toString(); var cost = log.getCost(); this.gasUsed += cost; if (!this.operations[op]) { this.operations[op] = { count: 0, totalGas: 0 }; } this.operations[op].count++; this.operations[op].totalGas += cost; }, fault: function(log, db) {}, result: function(ctx, db) { return { totalGas: this.gasUsed, operations: this.operations, efficiency: this.gasUsed / ctx.gasUsed }; }}"
          }
        ],
        "id": 1
      }' \
      https://evm-rpc.sei-apis.com
    ```

    **Response:**

    ```json theme={"dark"}
    {
      "jsonrpc": "2.0",
      "id": 1,
      "result": {
        "totalGas": 6346011,
        "operations": {
          "PUSH1": {
            "count": 1476,
            "totalGas": 4428
          },
          "MSTORE": {
            "count": 342,
            "totalGas": 1690
          },
          "CALLDATASIZE": {
            "count": 41,
            "totalGas": 82
          },
          "PUSH2": {
            "count": 1400,
            "totalGas": 4200
          },

          ...


          "STOP": {
            "count": 5,
            "totalGas": 0
          },
          "LOG2": {
            "count": 2,
            "totalGas": 5578
          },
          "LOG4": {
            "count": 1,
            "totalGas": 2899
          },
          "LOG1": {
            "count": 1,
            "totalGas": 2542
          }
        },
        "efficiency": 23.84499278564343
      }
    }
    ```
  </Tab>
</Tabs>

## Debugging Failed Transactions

Steps to analyze and resolve transaction failures:

### Step 1: Identify the Problem

```bash theme={"dark"}
# Get transaction receipt
FAILED_TX="0xb2a6f4f7f37d8df728968126c05d1a8b0391003cf375ed5abb1b5e02fe66c717"

curl -X POST -H "Content-Type: application/json" \
  --data '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionReceipt",
    "params": ["'$FAILED_TX'"],
    "id": 1
  }' \
  https://evm-rpc.sei-apis.com
```

### Step 2: Trace the Execution

```bash theme={"dark"}
# Trace to see where it failed
curl -X POST -H "Content-Type: application/json" \
  --data '{
    "jsonrpc": "2.0",
    "method": "debug_traceTransaction",
    "params": [
      "'$FAILED_TX'",
      {
        "tracer": "callTracer",
        "tracerConfig": {
          "withLog": true
        }
      }
    ],
    "id": 1
  }' \
  https://evm-rpc.sei-apis.com
```

Response

```json theme={"dark"}
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "from": "0x2c80b1b0473bb765ef536d2526ec63195794d945",
    "gas": "0xc3500",
    "gasUsed": "0x2863d",
    "to": "0xd1efe48b71acd98db16fcb9e7152b086647ef544",
    "input": "0x414bf3890000000000000000000000003894085ef7ff0f0aedf52e2a2704928d1ec074f1000000000000000000000000e30fedd158a2e3b13e9badaeabafc5516e95e8c70000000000000000000000000000000000000000000000000000000000000bb80000000000000000000000002c80b1b0473bb765ef536d2526ec63195794d94500000000000000000000000000000000000000000000000000000000688a24580000000000000000000000000000000000000000000000000000000031aba85500000000000000000000000000000000000000000000009556d1a971e567965b0000000000000000000000000000000000000000000000000000000000000000",
    "output": "0x08c379a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000013546f6f206c6974746c6520726563656976656400000000000000000000000000",
    "error": "execution reverted",
    "revertReason": "Too little received",
    "calls": [
      ...
    ]
  }
}
```

### Step 3: Fix and Test

```bash theme={"dark"}
# Simulate the fix with debug_traceCall
curl -X POST \
  -H "Content-Type: application/json" \
  --data '{
    "jsonrpc": "2.0",
    "method": "debug_traceCall",
    "params": [
      {
        "from": "0x2c80b1b0473bb765ef536d2526ec63195794d945",
        "to": "0xd1efe48b71acd98db16fcb9e7152b086647ef544",
        "gas": "0xc3500",
        "gasPrice": "0x2127ddd32",
        "value": "0x0"
      },
      "0x98a87cc",
      {
        "tracer": "callTracer",
        "tracerConfig": {
          "onlyTopCall": false,
          "withLog": true
        }
      }
    ],
    "id": 1
  }' \
  https://evm-rpc.sei-apis.com
```

## Common Debugging Scenarios

### Transaction Reverted

**Problem**: Transaction failed with revert
**Solution**: Use `callTracer` to find the exact revert reason

### Out of Gas

**Problem**: Transaction ran out of gas
**Solution**: Use gas analysis tracer to optimize gas usage

### Unexpected Behavior

**Problem**: Transaction succeeded but wrong result
**Solution**: Use opcode tracer for step-by-step analysis

### Slow Performance

**Problem**: Transaction uses too much gas
**Solution**: Use state access tracer to find inefficiencies

## Quick Reference

### Essential Commands

```bash theme={"dark"}
# Trace transaction
debug_traceTransaction(hash, {tracer: "callTracer"})

# Trace block
debug_traceBlockByNumber("latest", {tracer: "callTracer"})

# Simulate call
debug_traceCall(tx, "latest", {tracer: "callTracer"})

# State access
debug_traceStateAccess(hash)
```

### Common Tracers

* **`callTracer`**: Contract call hierarchy
* **`opcodeTracer`**: Opcode-level execution
* **Custom JS**: Custom analysis logic

## Next Steps

1. **[JavaScript Tracers](/evm/tracing/javascript-tracers)** - Custom analysis scripts
2. **[Troubleshooting](/evm/tracing/troubleshooting)** - Common issues and solutions

<Info>Start with `callTracer` for general debugging, then use specialized tracers for specific analysis needs.</Info>

---

URL: https://docs.sei.io/evm/tracing/javascript-tracers

# JavaScript Tracers

> Create custom debugging logic with JavaScript tracers for advanced EVM transaction analysis on Sei. Learn performance optimization, memory management, and advanced debugging patterns.

JavaScript tracers allow you to create custom debugging logic for analyzing EVM transactions on Sei. This powerful feature enables sophisticated analysis patterns beyond what built-in tracers provide.

## Interface Overview

Every JavaScript tracer follows this structure:

```javascript theme={"dark"}
{
  "tracer": `{
    // Initialize variables
    data: [],

    // Called for each opcode execution
    step: function(log, db) {
      // Your analysis logic here
    },

    // Called when execution fails (optional)
    fault: function(log, db) {
      return {};
    },

    // Called at the end to return results
    result: function(ctx, db) {
      return {
        // Your analysis results
      };
    }
  }`
}
```

## Core Methods

### step(log, db)

Called for each EVM opcode execution. This is where your main analysis logic goes.

**Parameters:**

* `log`: Current execution context with methods like `getPC()`, `op.toString()`, `getCost()`
* `db`: Database interface for querying state

**Gas Cost**: Varies by tracer complexity

### result(ctx, db)

Called at the end of execution to return your analysis results.

**Parameters:**

* `ctx`: Execution context with `gasUsed`, transaction info
* `db`: Database interface for final queries

## Advanced Tracer Examples

### State Change Tracker

Monitor all state modifications with detailed analysis:

```javascript theme={"dark"}
{
  "tracer": `{
    stateChanges: {},

    step: function(log, db) {
      if (log.op.toString() == "SSTORE") {
        var key = log.stack.peek(0).toString(16);
        var value = log.stack.peek(1).toString(16);
        var address = log.contract.getAddress().toString();

        if (!this.stateChanges[address]) {
          this.stateChanges[address] = {};
        }

        this.stateChanges[address][key] = {
          oldValue: db.getState(address, key),
          newValue: value,
          pc: log.getPC()
        };
      }
    },

    result: function(ctx, db) {
      return {
        modifiedAccounts: Object.keys(this.stateChanges).length,
        stateChanges: this.stateChanges
      };
    }
  }`
}
```

### DeFi Transaction Analysis

Analyze complex DeFi transactions with multiple contract interactions:

```javascript theme={"dark"}
{
  "tracer": `{
    transfers: [],

    step: function(log, db) {
      // Track ERC20 Transfer events (LOG3 with Transfer signature)
      if (log.op.toString() == "LOG3") {
        var topic0 = log.stack.peek(2).toString(16);
        // ERC20 Transfer event signature
        if (topic0 == "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef") {
          this.transfers.push({
            from: log.stack.peek(3).toString(16),
            to: log.stack.peek(4).toString(16),
            value: log.memory.slice(log.stack.peek(0), log.stack.peek(1)),
            contract: log.contract.getAddress().toString()
          });
        }
      }
    },

    result: function(ctx, db) {
      return {
        totalTransfers: this.transfers.length,
        transfers: this.transfers,
        gasEfficiency: this.transfers.length > 0 ? ctx.gasUsed / this.transfers.length : 0
      };
    }
  }`
}
```

### Security Analysis Tracer

Detect suspicious patterns and potential vulnerabilities:

```javascript theme={"dark"}
{
  "tracer": `{
    suspiciousOps: [],
    externalCalls: 0,
    selfDestructs: 0,

    step: function(log, db) {
      var op = log.op.toString();

      // Track external calls
      if (op == "CALL" || op == "DELEGATECALL" || op == "STATICCALL") {
        this.externalCalls++;

        // Flag suspicious delegate calls
        if (op == "DELEGATECALL") {
          this.suspiciousOps.push({
            type: "DELEGATECALL",
            target: log.stack.peek(1).toString(16),
            pc: log.getPC()
          });
        }
      }

      // Track self-destructs
      if (op == "SELFDESTRUCT") {
        this.selfDestructs++;
        this.suspiciousOps.push({
          type: "SELFDESTRUCT",
          beneficiary: log.stack.peek(0).toString(16),
          pc: log.getPC()
        });
      }
    },

    result: function(ctx, db) {
      return {
        riskScore: this.suspiciousOps.length * 10 + this.selfDestructs * 50,
        externalCalls: this.externalCalls,
        suspiciousOperations: this.suspiciousOps,
        recommendations: this.suspiciousOps.length > 0 ?
          ["Review delegate calls", "Verify contract security"] :
          ["Transaction appears safe"]
      };
    }
  }`
}
```

### Gas Optimization Tracer

Identify expensive operations for gas optimization:

```javascript theme={"dark"}
{
  "tracer": `{
    expensive: [],
    threshold: 1000, // Gas cost threshold

    step: function(log, db) {
      var cost = log.getCost();
      if (cost > this.threshold) {
        this.expensive.push({
          pc: log.getPC(),
          op: log.op.toString(),
          cost: cost,
          gas: log.getGas()
        });
      }
    },

    result: function(ctx, db) {
      // Sort by cost descending
      this.expensive.sort((a, b) => b.cost - a.cost);

      return {
        expensiveOperations: this.expensive.slice(0, 20),
        totalExpensiveCost: this.expensive.reduce((sum, op) => sum + op.cost, 0),
        optimizationPotential: this.expensive.length > 0
      };
    }
  }`
}
```

## Performance Optimization

<Warning>**Performance**: JavaScript tracers can significantly slow down tracing. Optimize your tracer code and use timeouts for production use.</Warning>

### Memory-Efficient Patterns

```javascript theme={"dark"}
// ✅ Efficient - Use summary data
{
  "tracer": `{
    summary: {
      totalGas: 0,
      operationCounts: {},
      maxStackDepth: 0
    },

    step: function(log, db) {
      // Update counters instead of storing arrays
      this.summary.totalGas += log.getCost();

      var op = log.op.toString();
      this.summary.operationCounts[op] = (this.summary.operationCounts[op] || 0) + 1;

      var stackDepth = log.stack.length();
      if (stackDepth > this.summary.maxStackDepth) {
        this.summary.maxStackDepth = stackDepth;
      }
    },

    result: function(ctx, db) {
      return this.summary;
    }
  }`
}
```

### Selective Operation Tracking

```javascript theme={"dark"}
{
  "tracer": `{
    data: [],
    counter: 0,
    maxEntries: 1000, // Limit data collection

    step: function(log, db) {
      // Only track specific operations
      var op = log.op.toString();
      if ((op == "SSTORE" || op == "SLOAD") && this.counter < this.maxEntries) {
        this.data.push([
          log.getPC(),
          op,
          log.getCost()
        ]);
        this.counter++;
      }
    },

    result: function(ctx, db) {
      return {
        operations: this.data,
        truncated: this.counter >= this.maxEntries
      };
    }
  }`
}
```

## Configuration Options

### Basic Configuration

```json theme={"dark"}
{
  "tracer": "your-javascript-tracer",
  "tracerConfig": {
    "timeout": "30s",
    "enableMemory": false,
    "enableStack": false,
    "enableStorage": false,
    "enableReturnData": true
  }
}
```

### Production Settings

```json theme={"dark"}
{
  "tracerConfig": {
    "timeout": "60s", // Longer timeout for complex traces
    "enableMemory": false, // Disable to save memory
    "enableStack": false, // Disable to save memory
    "enableStorage": true, // Enable only if needed
    "enableReturnData": true // Usually safe to enable
  }
}
```

## Practical Integration Examples

### Smart Contract Debugger

```solidity theme={"dark"}
contract TransactionAnalyzer {
    struct TraceResult {
        uint256 gasUsed;
        uint256 operationCount;
        bool hasErrors;
    }

    event TransactionTraced(
        bytes32 indexed txHash,
        uint256 gasUsed,
        uint256 operationCount
    );

    function analyzeTransaction(
        bytes32 txHash,
        string memory tracerCode
    ) external {
        // Off-chain: Use the tracer to analyze the transaction
        // On-chain: Process and store the results

        // This would typically be called by an oracle or off-chain service
        // that performs the tracing and submits results
    }
}
```

### DeFi Analytics Dashboard

```javascript theme={"dark"}
// Off-chain analytics service
class DeFiAnalytics {
  async analyzeSwap(txHash) {
    const swapTracer = `{
            swaps: [],
            
            step: function(log, db) {
                if (log.op.toString() == "LOG3") {
                    // Detect swap events
                    var topic0 = log.stack.peek(2).toString(16);
                    if (topic0 == "swap_event_signature") {
                        this.swaps.push({
                            contract: log.contract.getAddress().toString(),
                            // ... extract swap data
                        });
                    }
                }
            },
            
            result: function(ctx, db) {
                return { swaps: this.swaps };
            }
        }`;

    const result = await this.traceTransaction(txHash, swapTracer);
    return this.processSwapData(result);
  }
}
```

## Best Practices

1. **Start Simple**: Begin with basic tracers before adding complexity
2. **Limit Data Collection**: Only collect necessary information
3. **Use Efficient Data Structures**: Prefer counters over arrays when possible
4. **Set Appropriate Timeouts**: Balance thoroughness with performance
5. **Test Incrementally**: Validate tracers on simple transactions first
6. **Handle Errors Gracefully**: Include error handling in your tracers

## Common Use Cases

### Gas Profiling

```javascript theme={"dark"}
const gasProfiler = `{
  profile: {},
  
  step: function(log, db) {
    var op = log.op.toString();
    var cost = log.getCost();
    
    if (!this.profile[op]) {
      this.profile[op] = { count: 0, totalCost: 0 };
    }
    
    this.profile[op].count++;
    this.profile[op].totalCost += cost;
  },
  
  result: function(ctx, db) {
    // Calculate averages
    for (var op in this.profile) {
      this.profile[op].avgCost = this.profile[op].totalCost / this.profile[op].count;
    }
    return this.profile;
  }
}`;
```

### Event Extraction

```javascript theme={"dark"}
const eventExtractor = `{
  events: [],
  
  step: function(log, db) {
    var op = log.op.toString();
    if (op.startsWith("LOG")) {
      this.events.push({
        address: log.contract.getAddress().toString(),
        topics: this.extractTopics(log),
        data: this.extractData(log)
      });
    }
  },
  
  extractTopics: function(log) {
    // Implementation depends on log structure
    return [];
  },
  
  result: function(ctx, db) {
    return { events: this.events };
  }
}`;
```

<Info>**Need Help?** If you encounter issues with JavaScript tracers, check out our [Troubleshooting Guide](/evm/tracing/troubleshooting) for common solutions and debugging tips.</Info>

---

URL: https://docs.sei.io/evm/tracing/troubleshooting

# Troubleshooting Guide

> Comprehensive troubleshooting guide for EVM transaction tracing on Sei. Resolve common issues with timeouts, memory limits, JavaScript errors, and performance optimization.

This guide covers common issues encountered when using EVM transaction tracing on Sei and provides practical solutions to resolve them.

## Common Error Categories

### 1. Timeout Errors

**Error**: `execution timeout`

**Cause**: Tracer execution exceeded the configured timeout duration.

**Solutions**:

```json theme={"dark"}
{
  "tracerConfig": {
    "timeout": "120s" // Increase timeout for complex traces
  }
}
```

**Best Practices**:

* Start with shorter timeouts (30s) for testing
* Increase gradually based on transaction complexity
* Use built-in tracers when possible (they're faster)
* Optimize JavaScript tracer code for performance

### 2. Memory Limit Errors

**Error**: `out of memory` or `memory limit exceeded`

**Cause**: Tracer collected too much data or inefficient memory usage.

**Solutions**:

```json theme={"dark"}
{
  "tracerConfig": {
    "enableMemory": false, // Disable memory tracing
    "enableStack": false, // Disable stack tracing
    "enableStorage": false // Disable storage tracing
  }
}
```

**Memory-Efficient Tracer Pattern**:

```javascript theme={"dark"}
{
  "tracer": `{
    // Use counters instead of arrays
    summary: {
      totalGas: 0,
      operationCount: 0,
      expensiveOps: 0
    },

    step: function(log, db) {
      this.summary.totalGas += log.getCost();
      this.summary.operationCount++;

      // Only track expensive operations
      if (log.getCost() > 1000) {
        this.summary.expensiveOps++;
      }
    },

    result: function(ctx, db) {
      return this.summary; // Return summary, not raw data
    }
  }`
}
```

### 3. JavaScript Tracer Errors

**Error**: `SyntaxError` or `ReferenceError` in JavaScript tracer

**Common Issues**:

```javascript theme={"dark"}
// ❌ Incorrect - Missing quotes
{
  "tracer": `{
    step: function(log, db) {
      var op = log.op.toString();
      if (op == SSTORE) { // Missing quotes around SSTORE
        // ...
      }
    }
  }`
}

// ✅ Correct - Proper quotes
{
  "tracer": `{
    step: function(log, db) {
      var op = log.op.toString();
      if (op == "SSTORE") { // Quoted properly
        // ...
      }
    }
  }`
}
```

**Debugging JavaScript Tracers**:

```javascript theme={"dark"}
{
  "tracer": `{
    errors: [],

    step: function(log, db) {
      try {
        // Your tracer logic here
        var op = log.op.toString();
        // ...
      } catch (e) {
        this.errors.push({
          error: e.toString(),
          pc: log.getPC(),
          op: log.op.toString()
        });
      }
    },

    result: function(ctx, db) {
      return {
        data: this.data,
        errors: this.errors // Check for errors
      };
    }
  }`
}
```

### 4. Network and Connection Issues

**Error**: `connection refused` or `network timeout`

**Solutions**:

```bash theme={"dark"}
# Check if node is running
curl -X POST -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
  http://localhost:8545

# Test with different timeout
curl --connect-timeout 30 --max-time 120 \
  -X POST -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"debug_traceTransaction","params":["0x..."],"id":1}' \
  http://localhost:8545
```

### 5. Transaction Not Found

**Error**: `transaction not found`

**Debugging Steps**:

```bash theme={"dark"}
# 1. Verify transaction exists
curl -X POST -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":["0x..."],"id":1}' \
  http://localhost:8545

# 2. Check if transaction is in a finalized block
curl -X POST -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","params":["0x..."],"id":1}' \
  http://localhost:8545

# 3. Ensure node is fully synced
curl -X POST -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_syncing","params":[],"id":1}' \
  http://localhost:8545
```

## Performance Optimization

### Tracer Performance Tips

1. **Limit Data Collection**:

```javascript theme={"dark"}
{
  "tracer": `{
    data: [],
    maxEntries: 1000, // Limit data collection

    step: function(log, db) {
      if (this.data.length < this.maxEntries) {
        // Only collect limited data
        this.data.push({
          pc: log.getPC(),
          op: log.op.toString(),
          gas: log.getGas()
        });
      }
    }
  }`
}
```

2. **Use Efficient Data Structures**:

```javascript theme={"dark"}
// ❌ Inefficient - Object lookups
{
  "tracer": `{
    operations: {},

    step: function(log, db) {
      var op = log.op.toString();
      if (!this.operations[op]) {
        this.operations[op] = 0;
      }
      this.operations[op]++;
    }
  }`
}

// ✅ Efficient - Direct assignment
{
  "tracer": `{
    operations: {},

    step: function(log, db) {
      var op = log.op.toString();
      this.operations[op] = (this.operations[op] || 0) + 1;
    }
  }`
}
```

3. **Selective Tracing**:

```javascript theme={"dark"}
{
  "tracer": `{
    step: function(log, db) {
      var op = log.op.toString();

      // Only trace specific operations
      if (op == "SSTORE" || op == "SLOAD" || op == "CALL") {
        // Process only important operations
        this.processOperation(log, db);
      }
    }
  }`
}
```

### Node Configuration for Better Performance

```toml theme={"dark"}
# In your node configuration
[evm]
# Increase trace timeout
trace-timeout = "300s"

# Increase memory limits
trace-memory-limit = "1GB"

# Enable trace caching
trace-cache-size = 1000
```

## Debugging Workflows

### 1. Failed Transaction Analysis

```bash theme={"dark"}
#!/bin/bash

TX_HASH="0x..."

echo "1. Checking if transaction exists..."
curl -s -X POST -H "Content-Type: application/json" \
  --data "{\"jsonrpc\":\"2.0\",\"method\":\"eth_getTransactionByHash\",\"params\":[\"$TX_HASH\"],\"id\":1}" \
  http://localhost:8545 | jq '.result'

echo "2. Getting transaction receipt..."
curl -s -X POST -H "Content-Type: application/json" \
  --data "{\"jsonrpc\":\"2.0\",\"method\":\"eth_getTransactionReceipt\",\"params\":[\"$TX_HASH\"],\"id\":1}" \
  http://localhost:8545 | jq '.result.status'

echo "3. Tracing transaction..."
curl -s -X POST -H "Content-Type: application/json" \
  --data "{\"jsonrpc\":\"2.0\",\"method\":\"debug_traceTransaction\",\"params\":[\"$TX_HASH\",{\"tracer\":\"callTracer\"}],\"id\":1}" \
  http://localhost:8545 | jq '.result'
```

### 2. Gas Optimization Workflow

```javascript theme={"dark"}
// Step 1: Identify expensive operations
const expensiveOpsTracer = `{
  expensive: [],
  threshold: 1000,
  
  step: function(log, db) {
    var cost = log.getCost();
    if (cost > this.threshold) {
      this.expensive.push({
        pc: log.getPC(),
        op: log.op.toString(),
        cost: cost
      });
    }
  },
  
  result: function(ctx, db) {
    this.expensive.sort((a, b) => b.cost - a.cost);
    return {
      totalExpensive: this.expensive.length,
      topExpensive: this.expensive.slice(0, 10)
    };
  }
}`;

// Step 2: Analyze storage operations
const storageTracer = `{
  storageOps: 0,
  storageGas: 0,
  
  step: function(log, db) {
    var op = log.op.toString();
    if (op == "SSTORE" || op == "SLOAD") {
      this.storageOps++;
      this.storageGas += log.getCost();
    }
  },
  
  result: function(ctx, db) {
    return {
      storageOperations: this.storageOps,
      storageGasCost: this.storageGas,
      averageCost: this.storageOps > 0 ? this.storageGas / this.storageOps : 0
    };
  }
}`;
```

## Error Code Reference

### Common HTTP Error Codes

| Code | Error                 | Solution                                     |
| ---- | --------------------- | -------------------------------------------- |
| 400  | Bad Request           | Check JSON-RPC format and parameters         |
| 404  | Not Found             | Verify transaction hash and node sync status |
| 500  | Internal Server Error | Check node logs and resource limits          |
| 503  | Service Unavailable   | Node may be syncing or overloaded            |

### Tracer-Specific Errors

| Error               | Cause                         | Solution                                         |
| ------------------- | ----------------------------- | ------------------------------------------------ |
| `execution timeout` | Tracer took too long          | Increase timeout or optimize tracer              |
| `out of memory`     | Too much data collected       | Reduce data collection or disable memory tracing |
| `invalid tracer`    | JavaScript syntax error       | Validate tracer syntax                           |
| `tracer not found`  | Built-in tracer doesn't exist | Check available tracers                          |

## Best Practices Summary

### ✅ Do's

* **Start Simple**: Begin with built-in tracers before custom JavaScript
* **Set Timeouts**: Always configure appropriate timeouts
* **Limit Data**: Collect only necessary information
* **Test Incrementally**: Test tracers on simple transactions first
* **Monitor Resources**: Watch memory and CPU usage
* **Cache Results**: Store expensive trace results when possible

### ❌ Don'ts

* **Don't Collect Everything**: Avoid tracing all operations unnecessarily
* **Don't Ignore Errors**: Always handle tracer errors gracefully
* **Don't Use Complex Logic**: Keep tracer step functions simple
* **Don't Forget Timeouts**: Never run tracers without timeout limits
* **Don't Trace in Production**: Avoid heavy tracing on production nodes

## Getting Help

If you encounter issues not covered in this guide:

1. **Check Node Logs**: Look for error messages in your Sei node logs
2. **Verify Configuration**: Ensure your node has tracing enabled
3. **Test Connectivity**: Confirm RPC endpoints are accessible
4. **Simplify Tracers**: Try built-in tracers first
5. **Community Support**: Ask in the [Sei Discord](https://discord.gg/sei) #dev-support channel

<Info>When reporting issues, include your tracer code, the transaction hash, and any error messages you receive. This helps the community provide better assistance.</Info>

---

URL: https://docs.sei.io/evm/evm-verify-contracts

# Verify Contracts

> Comprehensive guide on how to verify your EVM smart contracts on Sei

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

Verify your deployed contract using flattened source code, JSON input, Sourcify and more. Verifying your deployed contract ensures transparency and trust by making the source code publicly available and verifiable.

## Benefits of Verification

* **Transparency**: Publicly available source code.
* **Trust**: Community can verify the contract's functionality.
* **Security**: Greater confidence in the contract's integrity.

## Sourcify

[Sourcify](https://sourcify.dev/) provides decentralized, open-source contract verification. Sei has full Sourcify support on both **mainnet** (chain ID 1329) and **testnet** (chain ID 1328).

Sourcify performs byte-by-byte verification by recompiling your source code with the exact same compiler settings and comparing the output against the on-chain bytecode. No API key is required.

### Verify with Foundry

After deploying your contract with Foundry, verify it on Sourcify:

```bash theme={"dark"}
forge verify-contract \
  --verifier sourcify \
  --chain-id <CHAIN_ID> \
  <DEPLOYED_CONTRACT_ADDRESS> \
  <PATH:CONTRACT_NAME>
```

**Testnet example:**

```bash theme={"dark"}
forge verify-contract \
  --verifier sourcify \
  --chain-id 1328 \
  0x1234567890abcdef1234567890abcdef12345678 \
  src/Counter.sol:Counter
```

**Mainnet example:**

```bash theme={"dark"}
forge verify-contract \
  --verifier sourcify \
  --chain-id 1329 \
  0x1234567890abcdef1234567890abcdef12345678 \
  src/Counter.sol:Counter
```

To check verification status:

```bash theme={"dark"}
forge verify-check \
  --verifier sourcify \
  --chain-id 1328 \
  <VERIFICATION_JOB_ID>
```

You can also deploy and verify in a single step using `forge create`:

```bash theme={"dark"}
forge create src/Counter.sol:Counter \
  --rpc-url https://evm-rpc-testnet.sei-apis.com \
  --private-key $PRIVATE_KEY \
  --verify \
  --verifier sourcify \
  --chain-id 1328
```

<Info>If you need to pass constructor arguments, append them after the contract path. For example: `forge create src/Token.sol:Token --constructor-args "MyToken" "MTK" 18`</Info>

### Verify with Hardhat

The [`hardhat-verify`](https://hardhat.org/docs/learn-more/smart-contract-verification) plugin supports Sourcify out of the box with no additional configuration or API key.

#### 1. Install dependencies

```bash theme={"dark"}
npm install --save-dev hardhat @nomicfoundation/hardhat-verify
```

#### 2. Configure `hardhat.config.ts`

```ts theme={"dark"}
import { defineConfig, configVariable } from "hardhat/config";
import hardhatVerify from "@nomicfoundation/hardhat-verify";

export default defineConfig({
  networks: {
    sei_testnet: {
      type: "http",
      chainId: 1328,
      url: "https://evm-rpc-testnet.sei-apis.com",
      accounts: [configVariable("SEI_PRIVATE_KEY")],
    },
    sei_mainnet: {
      type: "http",
      chainId: 1329,
      url: "https://evm-rpc.sei-apis.com",
      accounts: [configVariable("SEI_PRIVATE_KEY")],
    },
  },

  solidity: {
    compilers: [
      {
        version: "0.8.28",
        settings: {
          optimizer: { enabled: true, runs: 200 },
        },
      },
    ],
  },

  plugins: [hardhatVerify],
});
```

<Info>Sourcify verification is enabled by default in `hardhat-verify`. No `verify` config block is needed for Sourcify.</Info>

#### 3. Deploy

```bash theme={"dark"}
npx hardhat ignition deploy ignition/modules/Counter.ts --network sei_testnet
```

#### 4. Verify with Sourcify

```bash theme={"dark"}
npx hardhat verify sourcify --network sei_testnet <CONTRACT_ADDRESS>
```

If your contract has constructor arguments:

```bash theme={"dark"}
npx hardhat verify sourcify --network sei_testnet <CONTRACT_ADDRESS> "arg1" "arg2"
```

Running `npx hardhat verify` without a subtask will attempt verification on all enabled providers (Etherscan, Blockscout, and Sourcify) simultaneously.

### Verify via Sourcify UI

You can also verify contracts directly through the [Sourcify web interface](https://verify.sourcify.dev/):

1. Go to [verify.sourcify.dev](https://verify.sourcify.dev/)
2. Select **Sei** (chain ID 1329) or **Sei Testnet** (chain ID 1328)
3. Enter your contract address
4. Upload your source files or standard JSON input
5. Click **Verify**

## Remix Contract Verification Plugin

Remix IDE offers an automated contract verification solution through its Contract Verification plugin, which integrates with both Sourcify and Etherscan verification services.

Don't have a contract deployed yet? Spin up Remix with a sample `Counter.sol`, deploy it to Sei testnet, then follow the steps below to verify it.

<AddSeiButton network="testnet" label="Add Sei testnet" />

<SandboxEmbed kind="remix" src="https://remix.ethereum.org/?#activate=solidity,fileManager&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVApwcmFnbWEgc29saWRpdHkgXjAuOC4yNDsKCi8vLyBAdGl0bGUgQ291bnRlciDigJQgbWluaW1hbCBjb250cmFjdCB0byBjb21waWxlICYgZGVwbG95IHRvIFNlaSB0ZXN0bmV0Lgpjb250cmFjdCBDb3VudGVyIHsKICAgIHVpbnQyNTYgcHVibGljIGNvdW50OwogICAgZnVuY3Rpb24gaW5jcmVtZW50KCkgZXh0ZXJuYWwgeyBjb3VudCsrOyB9CiAgICBmdW5jdGlvbiBkZWNyZW1lbnQoKSBleHRlcm5hbCB7IGNvdW50LS07IH0KfQ" title="Counter.sol · deploy to Sei testnet" description="Remix IDE with a minimal Counter contract preloaded. Deploy it to Sei testnet, then verify it with the Contract Verification plugin below." />

### Setup and Configuration

1. **Activate the Plugin**: In Remix IDE, navigate to the Plugin Manager and activate the **Contract Verification** plugin.

2. **Configure Network Settings**:
   * Search for and select **Sei** as your blockchain
   * Choose your deployment environment:
     * **Testnet** (1328) for development
     * **Mainnet** (1329) for production

3. **Enable Verification Services**: Activate both verification methods:
   * ✅ **Sourcify**
   * ✅ **Etherscan**

4. **Etherscan Configuration**: Configure the following settings:
   * **API Key**: Obtain from [seiscan.io](https://seiscan.io)
   * **URL**: `https://seiscan.io`

### Deploy and Verify

Once configured, deploy your contract through Remix as usual. The Contract Verification plugin will automatically verify your contract upon successful deployment, submitting to both Sourcify and Seiscan simultaneously.

Verification status will be displayed in the plugin interface, and your verified contract will be publicly viewable on Seiscan explorer.

## Verify via 0xngmi Etherscan Verification (third‑party)

You can batch‑verify a contract that is already verified on another chain using the community tool [Etherscan Verification by 0xngmi](https://etherscan-verification.0xngmi.com/). This copies the verified source from a "source chain" and submits it to [Seiscan](https://seiscan.io), as long as the bytecode and compiler settings match.

<Warning>Prerequisite: The contract is already verified on at least one supported chain (same compiler version, optimization runs, constructor args, and library addresses as on Sei).</Warning>

Steps:

1. Open [Etherscan Verification by 0xngmi](https://etherscan-verification.0xngmi.com/).
2. In "Source Contract", paste the address of the contract that is already verified and select its chain.
3. In "Target Contracts", add your Sei deployment address and select "Sei" as the target chain.
4. Click "Verify Contracts" and wait for the result.
5. Confirm the result on [Seiscan](https://seiscan.io) by visiting the contract page and checking the Contract tab.

<Info>If verification fails with a bytecode mismatch, re‑check compiler version, optimization runs, constructor arguments, and linked library addresses; they must be identical to the deployment on Sei.</Info>

---

URL: https://docs.sei.io/evm/precompiles/example-usage

# Precompile Example Usage

> Learn how to interact with Sei's precompiles through viem and ethers, covering all available precompiles with quick examples and common patterns for seamless integration between EVM and Sei-native functionality.

Sei precompiles are special smart contracts deployed at fixed addresses that expose native Sei functionality to EVM applications. They can be called like any standard smart contract using viem, ethers, or wagmi.

<Info>
  **Available Precompiles:**

  | Precompile   | Address  | Description                                        |
  | ------------ | -------- | -------------------------------------------------- |
  | Bank         | `0x1001` | Query native denom balances (usei, factory tokens) |
  | JSON         | `0x1003` | Parse JSON data within contracts                   |
  | Staking      | `0x1005` | Delegation and staking operations                  |
  | Governance   | `0x1006` | Proposal voting                                    |
  | Distribution | `0x1007` | Claim staking rewards                              |
  | P256         | `0x1011` | Verify P-256 elliptic curve signatures             |
</Info>

## Setup

```bash theme={"dark"}
npm install viem ethers @sei-js/precompiles
```

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, createWalletClient, http, custom } from 'viem';
  import { sei } from 'viem/chains';

  // Read-only
  const client = createPublicClient({ chain: sei, transport: http() });

  // Browser wallet (write)
  const walletClient = createWalletClient({ chain: sei, transport: custom(window.ethereum) });
  const [account] = await walletClient.getAddresses();
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  // Browser environment
  const provider = new ethers.BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();

  // Node.js / scripts
  // const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
  // const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
  ```
</CodeGroup>

## Bank Precompile

`eth_getBalance` only returns the EVM-side SEI balance. The Bank precompile lets you query any native denom — including factory tokens — from any address:

<CodeGroup>
  ```ts viem theme={"dark"}
  import { BANK_PRECOMPILE_ABI, BANK_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  // Query a specific denom balance
  const balance = await client.readContract({
    address: BANK_PRECOMPILE_ADDRESS,
    abi: BANK_PRECOMPILE_ABI,
    functionName: 'balance',
    args: ['0xYourAddress', 'usei'],
  });

  // Query all native balances for an address
  const allBalances = await client.readContract({
    address: BANK_PRECOMPILE_ADDRESS,
    abi: BANK_PRECOMPILE_ABI,
    functionName: 'all_balances',
    args: ['0xYourAddress'],
  });
  // Returns: [{ denom: 'usei', amount: '1000000' }, ...]
  ```

  ```ts ethers theme={"dark"}
  import { BANK_PRECOMPILE_ABI, BANK_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  const bank = new ethers.Contract(BANK_PRECOMPILE_ADDRESS, BANK_PRECOMPILE_ABI, provider);

  const balance = await bank.balance('0xYourAddress', 'usei');
  const allBalances = await bank.all_balances('0xYourAddress');
  ```
</CodeGroup>

## Staking Precompile

Delegate, undelegate, and query staking state:

<CodeGroup>
  ```ts viem theme={"dark"}
  import { parseEther } from 'viem';
  import { STAKING_PRECOMPILE_ABI, STAKING_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  // Delegate SEI to a validator
  const delegateHash = await walletClient.writeContract({
    address: STAKING_PRECOMPILE_ADDRESS,
    abi: STAKING_PRECOMPILE_ABI,
    functionName: 'delegate',
    args: ['seivaloper1...'],
    value: parseEther('10'),
  });

  // Query delegation
  const delegation = await client.readContract({
    address: STAKING_PRECOMPILE_ADDRESS,
    abi: STAKING_PRECOMPILE_ABI,
    functionName: 'delegation',
    args: [account, 'seivaloper1...'],
  });

  // Undelegate 5 SEI — amount is in 6-decimal usei (1 SEI = 1_000_000 usei), not wei
  const undelegateHash = await walletClient.writeContract({
    address: STAKING_PRECOMPILE_ADDRESS,
    abi: STAKING_PRECOMPILE_ABI,
    functionName: 'undelegate',
    args: ['seivaloper1...', 5_000_000n],
  });
  ```

  ```ts ethers theme={"dark"}
  import { STAKING_PRECOMPILE_ABI, STAKING_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  const staking = new ethers.Contract(STAKING_PRECOMPILE_ADDRESS, STAKING_PRECOMPILE_ABI, signer);
  const readStaking = new ethers.Contract(STAKING_PRECOMPILE_ADDRESS, STAKING_PRECOMPILE_ABI, provider);

  // Delegate 10 SEI
  const tx = await staking.delegate('seivaloper1...', { value: ethers.parseEther('10') });
  await tx.wait();

  // Query delegation
  const delegation = await readStaking.delegation(await signer.getAddress(), 'seivaloper1...');
  console.log('Delegated:', delegation.balance.amount.toString());

  // Undelegate 5 SEI — amount is in 6-decimal usei (1 SEI = 1_000_000 usei), not wei
  const undelegateTx = await staking.undelegate('seivaloper1...', ethers.parseUnits('5', 6));
  await undelegateTx.wait();
  ```
</CodeGroup>

## Governance Precompile

Vote on an active governance proposal:

<CodeGroup>
  ```ts viem theme={"dark"}
  import { GOVERNANCE_PRECOMPILE_ABI, GOVERNANCE_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  // Vote options: 1 = Yes, 2 = Abstain, 3 = No, 4 = NoWithVeto
  const hash = await walletClient.writeContract({
    address: GOVERNANCE_PRECOMPILE_ADDRESS,
    abi: GOVERNANCE_PRECOMPILE_ABI,
    functionName: 'vote',
    args: [99n, 1],
  });
  ```

  ```ts ethers theme={"dark"}
  import { GOVERNANCE_PRECOMPILE_ABI, GOVERNANCE_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  const governance = new ethers.Contract(GOVERNANCE_PRECOMPILE_ADDRESS, GOVERNANCE_PRECOMPILE_ABI, signer);

  // 1 = Yes, 2 = Abstain, 3 = No, 4 = NoWithVeto
  const tx = await governance.vote(99n, 1);
  await tx.wait();
  ```
</CodeGroup>

## Distribution Precompile

Claim staking rewards from a validator:

<CodeGroup>
  ```ts viem theme={"dark"}
  import { DISTRIBUTION_PRECOMPILE_ABI, DISTRIBUTION_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  const hash = await walletClient.writeContract({
    address: DISTRIBUTION_PRECOMPILE_ADDRESS,
    abi: DISTRIBUTION_PRECOMPILE_ABI,
    functionName: 'withdrawDelegationRewards',
    args: ['seivaloper1...'],
  });
  ```

  ```ts ethers theme={"dark"}
  import { DISTRIBUTION_PRECOMPILE_ABI, DISTRIBUTION_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  const distribution = new ethers.Contract(
    DISTRIBUTION_PRECOMPILE_ADDRESS,
    DISTRIBUTION_PRECOMPILE_ABI,
    signer,
  );

  const tx = await distribution.withdrawDelegationRewards('seivaloper1...');
  await tx.wait();
  ```
</CodeGroup>

## JSON Precompile

Parse JSON data within EVM contracts or dApps — useful for processing oracle responses, NFT metadata, and structured payloads:

<CodeGroup>
  ```ts viem theme={"dark"}
  import { toHex, toBytes } from 'viem';
  import { JSON_PRECOMPILE_ABI, JSON_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  const data = { price: 100, symbol: 'SEI' };
  const inputBytes = toBytes(JSON.stringify(data));

  // Extract a string value
  const symbolBytes = await client.readContract({
    address: JSON_PRECOMPILE_ADDRESS,
    abi: JSON_PRECOMPILE_ABI,
    functionName: 'extractAsBytes',
    args: [inputBytes, 'symbol'],
  });

  // Extract a numeric value
  const price = await client.readContract({
    address: JSON_PRECOMPILE_ADDRESS,
    abi: JSON_PRECOMPILE_ABI,
    functionName: 'extractAsUint256',
    args: [inputBytes, 'price'],
  });
  ```

  ```ts ethers theme={"dark"}
  import { JSON_PRECOMPILE_ABI, JSON_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';

  const jsonPrecompile = new ethers.Contract(JSON_PRECOMPILE_ADDRESS, JSON_PRECOMPILE_ABI, provider);

  const data = { price: 100, symbol: 'SEI' };
  const inputData = ethers.toUtf8Bytes(JSON.stringify(data));

  // Extract a string value
  const symbolBytes = await jsonPrecompile.extractAsBytes(inputData, 'symbol');
  const symbol = ethers.toUtf8String(symbolBytes);

  // Extract a numeric value
  const price = await jsonPrecompile.extractAsUint256(inputData, 'price');

  console.log(`${symbol}: ${price}`);
  ```
</CodeGroup>

## Common Patterns

### Error Handling

Wrap precompile calls in try/catch and check for specific error codes:

```ts theme={"dark"}
try {
  const tx = await staking.delegate('seivaloper1...', { value: ethers.parseEther('10') });
  const receipt = await tx.wait();
  console.log('Success:', receipt.hash);
} catch (err: any) {
  if (err.code === 'INSUFFICIENT_FUNDS') {
    console.error('Not enough SEI');
  } else if (err.code === 4001 || err.code === 'ACTION_REJECTED') {
    console.log('User rejected');
  } else {
    console.error('Transaction failed:', err.message);
  }
}
```

### Batch Read Operations

Fetch multiple precompile values in parallel:

```ts theme={"dark"}
const [delegation1, delegation2, rewards] = await Promise.all([
  readStaking.delegation(address, validator1),
  readStaking.delegation(address, validator2),
  distribution.delegationTotalRewards(address),
]);
```

### Gas Limits

Precompile calls that write state need enough gas. Use `estimateGas` rather than hard-coding:

```ts viem theme={"dark"}
const gas = await client.estimateGas({
  account,
  address: STAKING_PRECOMPILE_ADDRESS,
  abi: STAKING_PRECOMPILE_ABI,
  functionName: 'delegate',
  args: ['seivaloper1...'],
  value: parseEther('10'),
});
```

## Full Working Example

A Node.js script that delegates SEI and then casts a governance vote:

```ts theme={"dark"}
import { ethers } from 'ethers';
import {
  STAKING_PRECOMPILE_ABI, STAKING_PRECOMPILE_ADDRESS,
  GOVERNANCE_PRECOMPILE_ABI, GOVERNANCE_PRECOMPILE_ADDRESS,
} from '@sei-js/precompiles';

async function main() {
  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);

  const staking = new ethers.Contract(STAKING_PRECOMPILE_ADDRESS, STAKING_PRECOMPILE_ABI, wallet);
  const governance = new ethers.Contract(GOVERNANCE_PRECOMPILE_ADDRESS, GOVERNANCE_PRECOMPILE_ABI, wallet);

  // Check current delegation
  const readStaking = staking.connect(provider) as typeof staking;
  const delegation = await readStaking.delegation(wallet.address, 'seivaloper1...');
  console.log('Current delegation:', delegation.balance.amount.toString());

  // Delegate 1 SEI
  const delegateTx = await staking.delegate('seivaloper1...', { value: ethers.parseEther('1') });
  await delegateTx.wait();
  console.log('Delegated 1 SEI');

  // Vote Yes on proposal 99
  const voteTx = await governance.vote(99n, 1);
  await voteTx.wait();
  console.log('Vote cast');
}

main().catch(console.error);
```

Run with:

```bash theme={"dark"}
PRIVATE_KEY=your_key npx tsx script.ts
```

## Next Steps

For full ABI reference and all available functions on each precompile:

* [Staking Precompile →](/evm/precompiles/staking)
* [Governance Precompile →](/evm/precompiles/governance)
* [Distribution Precompile →](/evm/precompiles/distribution)
* [JSON Precompile →](/evm/precompiles/json)
* [P256 Precompile →](/evm/precompiles/p256-precompile)

---

URL: https://docs.sei.io/evm/precompiles/distribution

# Distribution Precompile

> Manage staking rewards and validator commissions through Sei's distribution precompile. EVM applications can withdraw rewards, set withdrawal addresses, and interact with Cosmos SDK distribution functionality.

<Info>Watch the video walkthrough for this topic in the [Video Tutorials](/evm/videos) section.</Info>

**Address**: `0x0000000000000000000000000000000000001007`

The distribution precompile provides EVM access to Cosmos SDK's distribution module. Smart contracts can manage staking rewards, validator commissions, and withdrawal addresses. This precompile is essential for DeFi applications that need to handle staking rewards programmatically.

## Key Features

* **Reward Management**: Withdraw delegation rewards from validators
* **Commission Handling**: Validators can withdraw earned commissions
* **Batch Operations**: Withdraw from multiple validators efficiently
* **Flexible Withdrawals**: Set custom withdrawal addresses
* **Comprehensive Queries**: Access detailed reward information

## Interface Overview

```solidity theme={"dark"}
interface IDistr {
    // Events
    event WithdrawAddressSet(address indexed delegator, address withdrawAddr);
    event DelegationRewardsWithdrawn(address indexed delegator, string validator, uint256 amount);
    event MultipleDelegationRewardsWithdrawn(address indexed delegator, string[] validators, uint256[] amounts);
    event ValidatorCommissionWithdrawn(string indexed validator, uint256 amount);

    // Transaction Methods
    function setWithdrawAddress(address withdrawAddr) external returns (bool);
    function withdrawDelegationRewards(string memory validator) external returns (bool);
    function withdrawMultipleDelegationRewards(string[] memory validators) external returns (bool);
    function withdrawValidatorCommission() external returns (bool);

    // Query Methods
    function rewards(address delegatorAddress) external view returns (Rewards);
}
```

## Events

The distribution precompile emits events for all state-changing operations, allowing off-chain services to track reward distributions and configuration changes.

### WithdrawAddressSet

Emitted when a delegator changes their reward withdrawal address.

```solidity theme={"dark"}
event WithdrawAddressSet(address indexed delegator, address withdrawAddr);
```

**Parameters:**

* `delegator` (indexed): The EVM address of the delegator changing their settings
* `withdrawAddr`: The new address where rewards will be sent

**Example usage:**

```typescript theme={"dark"}
// Listen for withdrawal address changes
distrContract.on('WithdrawAddressSet', (delegator, withdrawAddr) => {
  console.log(`${delegator} set withdrawal address to ${withdrawAddr}`);
});
```

### DelegationRewardsWithdrawn

Emitted when a delegator withdraws rewards from a single validator.

```solidity theme={"dark"}
event DelegationRewardsWithdrawn(address indexed delegator, string validator, uint256 amount);
```

**Parameters:**

* `delegator` (indexed): The EVM address of the delegator withdrawing rewards
* `validator`: The Sei validator address (e.g., "seivaloper1...")
* `amount`: The amount of rewards withdrawn (in usei, 6 decimal precision)

**Example usage:**

```typescript theme={"dark"}
// Track individual reward withdrawals
distrContract.on('DelegationRewardsWithdrawn', (delegator, validator, amount) => {
  const seiAmount = Number(amount) / 1e6;
  console.log(`${delegator} withdrew ${seiAmount} SEI from ${validator}`);
});
```

### MultipleDelegationRewardsWithdrawn

Emitted when a delegator withdraws rewards from multiple validators in a single transaction.

```solidity theme={"dark"}
event MultipleDelegationRewardsWithdrawn(address indexed delegator, string[] validators, uint256[] amounts);
```

**Parameters:**

* `delegator` (indexed): The EVM address of the delegator withdrawing rewards
* `validators`: Array of Sei validator addresses
* `amounts`: Array of reward amounts corresponding to each validator (in usei, 6 decimal precision)

**Example usage:**

```typescript theme={"dark"}
// Track batch reward withdrawals
distrContract.on('MultipleDelegationRewardsWithdrawn', (delegator, validators, amounts) => {
  for (let i = 0; i < validators.length; i++) {
    const seiAmount = Number(amounts[i]) / 1e6;
    console.log(`${delegator} withdrew ${seiAmount} SEI from ${validators[i]}`);
  }
});
```

### ValidatorCommissionWithdrawn

Emitted when a validator operator withdraws their earned commission.

```solidity theme={"dark"}
event ValidatorCommissionWithdrawn(string indexed validator, uint256 amount);
```

**Parameters:**

* `validator` (indexed): The Sei validator address
* `amount`: The commission amount withdrawn (in usei, 6 decimal precision)

**Example usage:**

```typescript theme={"dark"}
// Track validator commission withdrawals
distrContract.on('ValidatorCommissionWithdrawn', (validator, amount) => {
  const seiAmount = Number(amount) / 1e6;
  console.log(`Validator ${validator} withdrew ${seiAmount} SEI commission`);
});
```

<Info>**Event Amounts**: All event amounts use 6 decimal precision (usei), matching the actual withdrawn token amounts. This differs from the `rewards()` query which returns 18 decimal precision.</Info>

## Transaction Methods

### setWithdrawAddress

Sets the withdrawal address for staking rewards. By default, rewards are sent to the delegator's address, but this can be customized.

```solidity theme={"dark"}
function setWithdrawAddress(address withdrawAddr) external returns (bool success);
```

**Parameters:**

* `withdrawAddr`: EVM address where future rewards should be sent

**Gas Cost**: \~30,000 gas

**Example:**

```solidity theme={"dark"}
// Set rewards to go to a treasury contract
bool success = DISTR_CONTRACT.setWithdrawAddress(0x742d35Cc6634C0532925a3b8D4C9db96590c6C8C);
require(success, "Failed to set withdraw address");
```

### withdrawDelegationRewards

Withdraws accumulated rewards from a specific validator.

```solidity theme={"dark"}
function withdrawDelegationRewards(string memory validator) external returns (bool success);
```

**Parameters:**

* `validator`: Sei validator address (e.g., "seivaloper1...")

**Gas Cost**: \~50,000-80,000 gas (varies by reward amount)

**Example:**

```solidity theme={"dark"}
string memory validator = "seivaloper1xyz...";
bool success = DISTR_CONTRACT.withdrawDelegationRewards(validator);
require(success, "Failed to withdraw rewards");
```

### withdrawMultipleDelegationRewards

Efficiently withdraws rewards from multiple validators in a single transaction.

```solidity theme={"dark"}
function withdrawMultipleDelegationRewards(string[] memory validators) external returns (bool success);
```

**Parameters:**

* `validators`: Array of Sei validator addresses

**Gas Cost**: \~40,000 + (30,000 × number of validators)

**Example:**

```solidity theme={"dark"}
string[] memory validators = new string[](3);
validators[0] = "seivaloper1abc...";
validators[1] = "seivaloper1def...";
validators[2] = "seivaloper1ghi...";

bool success = DISTR_CONTRACT.withdrawMultipleDelegationRewards(validators);
require(success, "Failed to withdraw multiple rewards");
```

<Info>**Batch Efficiency**: Using `withdrawMultipleDelegationRewards` is significantly more gas-efficient than multiple individual calls, especially when withdrawing from 3+ validators.</Info>

### withdrawValidatorCommission

Allows validators to withdraw their earned commission. Only callable by the validator operator address.

```solidity theme={"dark"}
function withdrawValidatorCommission() external returns (bool success);
```

**Parameters:** None - the validator is automatically determined from the caller's associated Sei address.

**Gas Cost**: \~60,000-90,000 gas

**Example:**

```solidity theme={"dark"}
// Only works if caller is the validator operator
bool success = DISTR_CONTRACT.withdrawValidatorCommission();
require(success, "Failed to withdraw commission");
```

<Warning>**Validator Only**: This method can only be called by the validator's operator address. The precompile automatically identifies the validator based on the caller's associated Sei address. If the caller is not a validator operator, the call will fail.</Warning>

## Query Methods

### rewards

Retrieves comprehensive reward information for a delegator across all validators.

```solidity theme={"dark"}
function rewards(address delegatorAddress) external view returns (Rewards rewards);
```

**Data Structures:**

```solidity theme={"dark"}
struct Coin {
    uint256 amount;    // Token amount in 18 decimal precision (DecCoins)
    uint256 decimals;  // Always 18 - decimal precision for the amount
    string denom;      // Token denomination (e.g., "usei")
}

struct Reward {
    Coin[] coins;              // Reward coins from this validator
    string validator_address;  // Validator's Sei address
}

struct Rewards {
    Reward[] rewards;  // Per-validator breakdown
    Coin[] total;      // Total rewards across all validators
}
```

<Warning>
  **Critical: Decimal Precision for Rewards**

  The `rewards()` query returns amounts with **18 decimal precision** (`DecCoins` from Cosmos SDK).

  This is different from the actual withdrawn reward amounts, which use **6 decimal precision** (`sdk.Coins`).

  **To convert pending rewards to SEI for display:**

  ```javascript theme={"dark"}
  const pendingRewardsSei = amount / 1e18; // rewards() query uses 18 decimals
  ```

  **Withdrawn rewards are in usei (6 decimals):**

  ```javascript theme={"dark"}
  const withdrawnSei = withdrawnAmount / 1e6; // actual withdrawals use 6 decimals
  ```
</Warning>

**Example:**

```solidity theme={"dark"}
Rewards memory userRewards = DISTR_CONTRACT.rewards(msg.sender);

// Check total rewards - uses 18 decimal precision
for (uint i = 0; i < userRewards.total.length; i++) {
    Coin memory coin = userRewards.total[i];
    // coin.decimals is always 18 for rewards
    uint256 displayAmount = coin.amount / (10 ** coin.decimals);
    // Process reward amount for coin.denom
}

// Check per-validator rewards
for (uint i = 0; i < userRewards.rewards.length; i++) {
    Reward memory reward = userRewards.rewards[i];
    // Process rewards from reward.validator_address
}
```

## Understanding Decimal Precision

The distribution precompile has **different decimal precision for queries vs actual withdrawals** due to how rewards are tracked in the Cosmos SDK:

| Function                                | Type                     | Decimal Precision      | Conversion to SEI |
| --------------------------------------- | ------------------------ | ---------------------- | ----------------- |
| **rewards()**                           | Query (pending rewards)  | 18 decimals (DecCoins) | `amount / 1e18`   |
| **withdrawDelegationRewards()**         | Withdrawn amount (event) | 6 decimals (usei)      | `amount / 1e6`    |
| **withdrawMultipleDelegationRewards()** | Withdrawn amount (event) | 6 decimals (usei)      | `amount / 1e6`    |
| **withdrawValidatorCommission()**       | Withdrawn amount (event) | 6 decimals (usei)      | `amount / 1e6`    |

### Why Different Precisions?

1. **Pending Rewards (18 decimals)**: The Cosmos SDK tracks pending rewards using `DecCoins` (decimal coins) with 18 decimal precision for higher accuracy during reward accumulation.

2. **Withdrawn Rewards (6 decimals)**: When rewards are actually withdrawn, they are converted to `sdk.Coins` (usei) with 6 decimal precision to match Sei's native token units.

### Conversion Helper Functions

```typescript theme={"dark"}
// Convert pending rewards (18 decimals) to SEI
function pendingRewardsToSei(amount: bigint): number {
  return Number(amount) / 1e18;
}

// Convert withdrawn rewards (6 decimals) to SEI
function withdrawnRewardsToSei(amount: bigint): number {
  return Number(amount) / 1e6;
}

// Example usage
const pendingRewards = await distrContract.rewards(delegatorAddress);
const pendingSei = pendingRewardsToSei(pendingRewards.total[0].amount);
console.log(`Pending rewards: ${pendingSei} SEI`);
```

<Info>**Note**: When reconciling pending rewards with actual withdrawals, be aware of the 12-decimal difference (10^12 factor) between query results and withdrawal amounts.</Info>

## Practical Examples

### DeFi Yield Aggregator

```solidity theme={"dark"}
contract YieldAggregator {
    IDistr constant DISTR = IDistr(0x0000000000000000000000000000000000001007);

    mapping(address => string[]) public userValidators;

    function harvestRewards() external {
        string[] memory validators = userValidators[msg.sender];
        require(validators.length > 0, "No validators to harvest from");

        // Efficiently withdraw from all validators
        bool success = DISTR.withdrawMultipleDelegationRewards(validators);
        require(success, "Harvest failed");

        // Additional logic to compound or distribute rewards
    }

    function checkPendingRewards(address user) external view returns (uint256 totalSei) {
        Rewards memory rewards = DISTR.rewards(user);

        for (uint i = 0; i < rewards.total.length; i++) {
            if (keccak256(bytes(rewards.total[i].denom)) == keccak256(bytes("usei"))) {
                totalSei = rewards.total[i].amount;
                break;
            }
        }
    }
}
```

### Validator Commission Manager

```solidity theme={"dark"}
contract ValidatorManager {
    IDistr constant DISTR = IDistr(0x0000000000000000000000000000000000001007);

    address public treasury;

    constructor(address _treasury) {
        treasury = _treasury;

        // Set commission withdrawals to go to treasury
        DISTR.setWithdrawAddress(treasury);
    }

    // Only callable by the validator operator
    function withdrawCommission() external {
        bool success = DISTR.withdrawValidatorCommission();
        require(success, "Commission withdrawal failed");
    }
}
```

## Error Handling

Common error scenarios and how to handle them:

```solidity theme={"dark"}
contract SafeDistribution {
    IDistr constant DISTR = IDistr(0x0000000000000000000000000000000000001007);

    function safeWithdrawRewards(string memory validator) external returns (bool) {
        // Check if there are rewards to withdraw first
        Rewards memory rewards = DISTR.rewards(msg.sender);

        bool hasRewards = false;
        for (uint i = 0; i < rewards.rewards.length; i++) {
            if (keccak256(bytes(rewards.rewards[i].validator_address)) ==
                keccak256(bytes(validator))) {
                hasRewards = rewards.rewards[i].coins.length > 0;
                break;
            }
        }

        if (!hasRewards) {
            return false; // No rewards to withdraw
        }

        try DISTR.withdrawDelegationRewards(validator) returns (bool success) {
            return success;
        } catch {
            return false; // Handle withdrawal failure gracefully
        }
    }
}
```

## Gas Optimization Tips

1. **Batch Operations**: Use `withdrawMultipleDelegationRewards` for multiple validators
2. **Check Before Withdraw**: Query rewards first to avoid unnecessary transactions
3. **Set Withdraw Address Once**: Avoid repeated `setWithdrawAddress` calls
4. **Commission Timing**: Withdraw validator commission when amounts are substantial

## Integration Patterns

### Auto-Compounding Strategy

```solidity theme={"dark"}
// Automatically reinvest rewards back into staking
function autoCompound() external {
    // 1. Withdraw rewards
    DISTR.withdrawMultipleDelegationRewards(getMyValidators());

    // 2. Use staking precompile to re-delegate
    // (Implementation depends on staking precompile integration)
}
```

### Treasury Management

```solidity theme={"dark"}
// Route all rewards to a DAO treasury
function setupTreasuryWithdrawals(address treasury) external onlyOwner {
    DISTR.setWithdrawAddress(treasury);
}
```

<Info>View the complete distribution precompile source code and ABI [here](https://github.com/sei-protocol/sei-chain/tree/main/precompiles/distribution).</Info>

---

URL: https://docs.sei.io/evm/precompiles/governance

# Governance Precompile Usage

> Learn how to interact with Sei's governance precompile through ethers.js, enabling proposal submission, voting, token deposits, and governance queries to participate in on-chain governance directly from EVM applications.

**Address:** `0x0000000000000000000000000000000000001006`

The Sei governance precompile enables EVM applications to participate in Sei's on-chain governance process. This allows users and smart contracts to submit proposals, vote on them, deposit tokens, and query governance information directly through the EVM interface.

<Info>**What is a precompile?** A precompile is a special smart contract deployed at a fixed address by the Sei protocol itself, that exposes custom native chain logic to EVM-based applications. It acts like a regular contract from the EVM's perspective, but executes privileged, low-level logic efficiently.</Info>

## How Does the Governance Precompile Work?

The governance precompile at address `0x0000000000000000000000000000000000001006` exposes functions like `vote()`, `voteWeighted()`, `deposit()`, and `submitProposal()`.

* **Direct Integration:** EVM contracts and dApps can interact with governance like any other smart contract method.
* **Native Execution:** Governance operations are executed at the chain level for maximum efficiency.
* **Seamless:** No need for separate wallet integrations.

## Use Cases

* **Voting Interfaces:** Create user-friendly governance participation tools.
* **Automated Governance:** Smart contracts that vote based on predetermined strategies.
* **Governance Aggregators:** Build platforms that aggregate and simplify governance participation.

## Sei Governance Overview

Sei governance operates on a structured timeline with specific parameters:

### Governance Process

1. **Proposal Submission:** Submit proposal with minimum 3,500 SEI deposit
2. **Deposit Period:** 2 days to accumulate minimum deposit or reach expedited threshold
3. **Voting Period:** 3 days (1 day for expedited) of active voting once minimum deposit is met
4. **Tallying:** Results calculated based on quorum and voting thresholds

<Info> To find out all about the governance process on Sei, go to the [governance explainer](/learn/general-governance).</Info>

<Warning>
  **Critical Mainnet Considerations:**

  * **High Stakes:** Mainnet governance involves real SEI tokens and binding decisions
  * **Minimum Deposit:** 3500 SEI minimum, 7000 SEI for expedited
  * **Deposit Risk:** Deposits will be burned if your proposal receives >33.4% NoWithVeto votes
  * **Voting Power Required:** Must stake SEI with validators to participate
  * **Time Limits:** Strict 2-day deposit period and 3-day voting period
  * **Real Impact:** Successful proposals can change network parameters
</Warning>

## Functions

The governance precompile exposes the following functions:

### Transaction Functions

```solidity theme={"dark"}
/// Cast a vote on the specified proposal.
/// @param proposalID The ID of the proposal to vote on.
/// @param option The option to vote for. (1=Yes, 2=Abstain, 3=No, 4=NoWithVeto)
/// @return Whether the vote was successfully cast.
function vote(
    uint64 proposalID,
    int32 option
) external returns (bool success);

struct WeightedVoteOption {
    int32 option;   // Vote option (1=Yes, 2=Abstain, 3=No, 4=NoWithVeto)
    string weight;  // Weight as decimal string (e.g., "0.7") - MUST sum to exactly 1.0 across all options
}

/// Cast a weighted vote on a governance proposal (vote splitting)
/// @param proposalID The ID of the proposal to vote on
/// @param options Array of weighted vote options, weights MUST sum to exactly 1.0 or transaction will fail
/// @return success Whether the vote was successfully cast
function voteWeighted(
    uint64 proposalID,
    WeightedVoteOption[] calldata options
) external returns (bool success);

/// Deposit funds into the specified proposal.
/// @param proposalID The ID of the proposal to deposit to.
/// @return Whether the tokens were successfully deposited.
function deposit(
    uint64 proposalID
) payable external returns (bool success);

/// Submit a new governance proposal. Deposit should be provided via msg.value
/// @param proposalJSON JSON string containing proposal details e.g.:
///        {
///          "title": "Proposal Title",
///          "description": "Proposal Description",
///          "type": "Text", // Optional, defaults to "Text" if empty
///          "is_expedited": false // Optional
///        }
/// @return proposalID The ID of the created proposal

function submitProposal(
    string calldata proposalJSON
) payable external returns (uint64 proposalID);
```

## Using the Contract

### Setup

#### Prerequisites

Before getting started, ensure you have:

* **Node.js** (v18 or higher)
* **npm** or **yarn** package manager
* **MetaMask** or compatible EVM wallet configured for Sei Mainnet
* **SEI tokens** for gas and governance deposits (minimum 3,500 SEI for proposals)

#### Install Dependencies

Install the required packages for interacting with Sei precompiles:

```bash theme={"dark"}
# Install ethers.js for smart contract interactions
npm install ethers

# Install Sei EVM bindings for precompile addresses and ABIs
npm install @sei-js/precompiles@2.1.2

# Install dotenv for managing private keys (optional but recommended)
npm install dotenv
```

#### Import Precompile Components

```typescript theme={"dark"}
// Import Governance precompile address and ABI
// View the entire ABI here: https://github.com/sei-protocol/sei-chain/tree/main/precompiles/gov
import { GOVERNANCE_PRECOMPILE_ABI, GOVERNANCE_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';
import { ethers } from 'ethers';
```

<Info>**Precompile Address:** The governance precompile is deployed at `0x0000000000000000000000000000000000001006`</Info>

#### Get SEI Tokens

Purchase SEI tokens from supported exchanges:

* **Centralized Exchanges:** Binance, Coinbase, KuCoin, Gate.io
* **Decentralized Exchanges:** Astroport, Dragonswap (on Sei)
* **Bridge Options:** Various cross-chain bridges support SEI

<Warning>**Minimum Requirements:** You need at least 3,500 SEI to submit a governance proposal, plus additional tokens for gas and potential additional deposits.</Warning>

### Contract Initialization

Set up your provider, signer, and contract instance:

```typescript theme={"dark"}
// Using MetaMask as the signer and provider (browser environment)
const provider = new ethers.BrowserProvider(window.ethereum);
await provider.send('eth_requestAccounts', []);
const signer = await provider.getSigner();

// Or for Node.js environment
const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
const signer = new ethers.Wallet('YOUR_PRIVATE_KEY', provider);

// Create a contract instance for the governance precompile
const governance = new ethers.Contract(GOVERNANCE_PRECOMPILE_ADDRESS, GOVERNANCE_PRECOMPILE_ABI, signer);
```

## Vote Options

The governance system uses the following vote options:

| Option     | Value | Description                   | Impact                                      |
| ---------- | ----- | ----------------------------- | ------------------------------------------- |
| Yes        | 1     | Vote in favor of the proposal | Proposal passes if threshold met            |
| Abstain    | 2     | Abstain from voting           | Counts toward quorum only                   |
| No         | 3     | Vote against the proposal     | Opposes proposal                            |
| NoWithVeto | 4     | Vote against with veto        | Opposes Proposal & burns deposit if > 33.4% |

### Voting Power

Your voting power is determined by:

* **Staked SEI:** Amount of SEI you have staked with validators
* **Delegation:** SEI delegated to validators counts toward voting power
* **Liquid SEI:** Unstaked SEI does not provide voting power

<Info>**Important:** Only staked SEI provides voting power. You must delegate your tokens to validators to participate in governance voting.</Info>

## Validation Functions

Before making governance transactions, use these helper functions to validate inputs:

```typescript theme={"dark"}
// Validate vote option
function isValidVoteOption(option: number): boolean {
  return option >= 1 && option <= 4;
}

// Validate weighted vote options sum to 1.0 - CRITICAL FOR TRANSACTION SUCCESS
function validateWeightedOptions(options: Array<{ option: number; weight: string }>): boolean {
  const totalWeight = options.reduce((sum, opt) => sum + parseFloat(opt.weight), 0);

  // Check if total weight equals 1.0 (with small tolerance for floating point precision)
  // Note: Sei governance is strict - even small deviations will cause transaction failure
  const isValidTotal = Math.abs(totalWeight - 1.0) < 0.000001;

  // Check if all options are valid
  const allOptionsValid = options.every((opt) => isValidVoteOption(opt.option));

  if (!isValidTotal) {
    console.error(`Weights sum to ${totalWeight}, but MUST equal exactly 1.0`);
  }

  return isValidTotal && allOptionsValid;
}

// Validate proposal JSON structure
function validateProposalJSON(proposalJSON: string): boolean {
  try {
    const proposal = JSON.parse(proposalJSON);
    return proposal.title && proposal.description && typeof proposal.title === 'string' && typeof proposal.description === 'string' && proposal.title.length > 0 && proposal.description.length > 0;
  } catch {
    return false;
  }
}

// Check if deposit meets minimum requirement
function validateDepositAmount(depositAmount: bigint, isExpedited: boolean = false): boolean {
  const MINIMUM_DEPOSIT = ethers.parseUnits('3500', 18); // 3,500 SEI minimum
  const EXPEDITED_DEPOSIT = ethers.parseUnits('7000', 18); // 7,000 SEI for expedited

  const requiredAmount = isExpedited ? EXPEDITED_DEPOSIT : MINIMUM_DEPOSIT;
  return depositAmount >= requiredAmount;
}

// Check if user has sufficient voting power
async function checkVotingPower(userAddress: string): Promise<bigint> {
  // This would typically query staking information
  // Implementation depends on your specific setup
  console.log(`Checking voting power for ${userAddress}`);
  return ethers.parseUnits('0', 18); // Placeholder - implement actual check
}
```

## Step-by-Step Guide: Using the Governance Precompile

### Submit a Proposal

<Info>
  **Important Deposit Requirements:**

  * **Minimum deposit:** 3,500 SEI required for proposal to enter voting period
  * **Expedited processing:** 7,000 SEI if the voting period should only be 1 day long
  * **Deposit period:** 2 days to meet minimum or proposal fails and deposits are burned
  * **Multiple deposits:** Anyone can contribute to reach the minimum threshold
</Info>

```typescript theme={"dark"}
async function submitGovernanceProposal(title: string, description: string, depositAmount: bigint, isExpedited: boolean = false): Promise<bigint> {
  // Validate inputs
  if (!title || !description) {
    throw new Error('Title and description are required');
  }

  if (title.length < 5 || title.length > 200) {
    throw new Error('Title must be between 5 and 200 characters');
  }

  if (description.length < 20 || description.length > 10000) {
    throw new Error('Description must be between 20 and 10,000 characters');
  }

  // Proposal details
  const proposal = {
    title: title.trim(),
    description: description.trim(),
    type: 'Text',
    is_expedited: isExpedited
  };

  // Convert to JSON string and validate
  const proposalJSON = JSON.stringify(proposal);
  if (!validateProposalJSON(proposalJSON)) {
    throw new Error('Invalid proposal JSON structure');
  }

  // Validate deposit amount
  if (!validateDepositAmount(depositAmount, isExpedited)) {
    const required = isExpedited ? '7,000 SEI' : '3,500 SEI';
    const provided = ethers.formatEther(depositAmount);
    throw new Error(`Insufficient deposit. Required: ${required}, Provided: ${provided} SEI`);
  }

  // Check balance before submitting
  const balance = await provider.getBalance(await signer.getAddress());
  const totalCost = depositAmount + ethers.parseUnits('0.1', 18); // Add gas buffer

  if (balance < totalCost) {
    throw new Error(`Insufficient balance. Need ${ethers.formatEther(totalCost)} SEI (including gas)`);
  }

  try {
    console.log('Submitting governance proposal...');
    console.log(`Title: ${title}`);
    console.log(`Deposit: ${ethers.formatEther(depositAmount)} SEI`);
    console.log(`Expedited: ${isExpedited}`);

    const tx = await governance.submitProposal(proposalJSON, {
      value: depositAmount,
      gasLimit: 500000
    });

    console.log('Transaction submitted:', tx.hash);
    console.log('Waiting for confirmation...');

    const receipt = await tx.wait();

    // Extract proposal ID from events
    let proposalID: bigint | null = null;
    for (const log of receipt.logs) {
      try {
        const parsed = governance.interface.parseLog(log);
        if (parsed && parsed.name === 'ProposalSubmitted') {
          proposalID = parsed.args.proposalID;
          break;
        }
      } catch {
        continue;
      }
    }

    if (!proposalID) {
      throw new Error('Could not extract proposal ID from transaction receipt');
    }

    console.log('✅ Proposal submitted successfully!');
    console.log(`Proposal ID: ${proposalID.toString()}`);
    console.log(`Transaction hash: ${receipt.hash}`);
    console.log(`View proposal: https://sei.explorers.guru/proposal/${proposalID.toString()}`);

    return proposalID;
  } catch (error: any) {
    console.error('Failed to submit proposal:', error);

    if (error.message.includes('insufficient funds')) {
      throw new Error('Insufficient funds for proposal deposit and gas fees');
    } else if (error.message.includes('invalid deposit')) {
      throw new Error('Deposit amount does not meet minimum requirements');
    } else {
      throw error;
    }
  }
}

// Usage example
const proposalTitle = 'Increase Block Size Limit';
const proposalDescription = `
This proposal suggests increasing the block size limit from the current value to improve transaction throughput on the Sei network.

## Rationale
Current network usage patterns show we are approaching capacity limits during peak times. Increasing the block size will:

1. Reduce transaction fees during high usage periods
2. Improve user experience with faster confirmation times
3. Support growing ecosystem adoption

## Implementation
The parameter change would be implemented through the existing governance mechanism with a 2-week transition period.

## Risks
- Slightly increased hardware requirements for validators
- Potential centralization concerns (mitigated by current validator distribution)

The benefits significantly outweigh the minimal risks involved.
`.trim();

const depositAmount = ethers.parseUnits('4000', 18); // 4,000 SEI deposit
await submitGovernanceProposal(proposalTitle, proposalDescription, depositAmount, false);
```

### Vote on a Proposal

```typescript theme={"dark"}
// Simple voting with comprehensive validation
async function voteOnProposal(proposalID: bigint, voteOption: number): Promise<void> {
  // Validate vote option
  if (!isValidVoteOption(voteOption)) {
    throw new Error('Invalid vote option. Must be 1 (Yes), 2 (Abstain), 3 (No), or 4 (NoWithVeto)');
  }

  // Check voting power (implement based on your staking setup)
  const userAddress = await signer.getAddress();
  console.log(`Checking voting eligibility for ${userAddress}...`);

  // Verify proposal exists and is in voting period
  try {
    // You would typically query proposal status here
    console.log(`Voting on proposal ${proposalID.toString()}...`);

    const voteOptionNames = {
      1: 'Yes',
      2: 'Abstain',
      3: 'No',
      4: 'NoWithVeto'
    };

    console.log(`Vote option: ${voteOptionNames[voteOption as keyof typeof voteOptionNames]}`);

    const tx = await governance.vote(proposalID, voteOption, {
      gasLimit: 200000
    });

    console.log('Transaction submitted:', tx.hash);
    const receipt = await tx.wait();

    console.log('✅ Vote cast successfully!');
    console.log(`Proposal ID: ${proposalID.toString()}`);
    console.log(`Vote: ${voteOptionNames[voteOption as keyof typeof voteOptionNames]}`);
    console.log(`Transaction hash: ${receipt.hash}`);
    console.log(`View on explorer: https://seiscan.io/tx/${receipt.hash}`);
  } catch (error: any) {
    console.error('Failed to cast vote:', error);

    if (error.message.includes('proposal does not exist')) {
      throw new Error('Proposal does not exist or voting period has ended');
    } else if (error.message.includes('already voted')) {
      throw new Error('You have already voted on this proposal');
    } else if (error.message.includes('insufficient voting power')) {
      throw new Error('No voting power - you must stake SEI to participate in governance');
    } else {
      throw error;
    }
  }
}

// Usage examples
const proposalID = 1n;

// Vote Yes
await voteOnProposal(proposalID, 1);

// Vote No with Veto (burns deposit if >33.4% of votes)
await voteOnProposal(proposalID, 4);
```

### Weighted Voting

<Danger>**Critical Requirement:** Weighted vote options MUST sum to exactly 1.0 or the transaction will fail. The Sei governance module enforces this strictly - even small rounding errors will cause rejection.</Danger>

```typescript theme={"dark"}
// Weighted voting with comprehensive validation
async function castWeightedVote(proposalID: bigint, weightedOptions: Array<{ option: number; weight: string }>): Promise<void> {
  // Comprehensive validation
  if (weightedOptions.length === 0) {
    throw new Error('At least one vote option is required');
  }

  if (weightedOptions.length > 4) {
    throw new Error('Cannot have more than 4 vote options');
  }

  // Validate each option and check for duplicates
  const seenOptions = new Set<number>();
  let totalWeight = 0;

  for (const { option, weight } of weightedOptions) {
    // Validate option
    if (!isValidVoteOption(option)) {
      throw new Error(`Invalid vote option: ${option}. Must be 1-4`);
    }

    // Check for duplicates
    if (seenOptions.has(option)) {
      throw new Error(`Duplicate vote option: ${option}`);
    }
    seenOptions.add(option);

    // Validate weight
    const weightNum = parseFloat(weight);
    if (isNaN(weightNum) || weightNum <= 0 || weightNum > 1) {
      throw new Error(`Invalid weight: ${weight}. Must be number between 0 and 1`);
    }

    totalWeight += weightNum;
  }

  // CRITICAL: Check total weight
  if (Math.abs(totalWeight - 1.0) > 0.000001) {
    throw new Error(`CRITICAL: Total weight must equal exactly 1.0, got ${totalWeight.toFixed(6)}. Transaction will fail.`);
  }

  try {
    console.log('Casting weighted vote...');
    console.log(`Proposal ID: ${proposalID.toString()}`);
    console.log('Vote distribution:');

    const voteOptionNames = { 1: 'Yes', 2: 'Abstain', 3: 'No', 4: 'NoWithVeto' };
    let totalPercent = 0;

    for (const { option, weight } of weightedOptions) {
      const percentage = (parseFloat(weight) * 100).toFixed(1);
      console.log(`  ${percentage}% ${voteOptionNames[option as keyof typeof voteOptionNames]}`);
      totalPercent += parseFloat(percentage);
    }

    console.log(`Total: ${totalPercent.toFixed(1)}%`);

    const tx = await governance.voteWeighted(proposalID, weightedOptions, {
      gasLimit: 300000 // Higher gas limit for weighted voting
    });

    console.log('Transaction submitted:', tx.hash);
    const receipt = await tx.wait();

    console.log('✅ Weighted vote cast successfully!');
    console.log(`Transaction hash: ${receipt.hash}`);
    console.log(`View on explorer: https://seiscan.io/tx/${receipt.hash}`);
  } catch (error: any) {
    console.error('Failed to cast weighted vote:', error);

    if (error.message.includes('weights must sum to 1')) {
      throw new Error('Vote weights must sum to exactly 1.0. Check your weight calculations.');
    } else {
      throw error;
    }
  }
}

// Usage examples

// Example 1: Split decision (60% Yes, 40% Abstain)
const splitVote = [
  { option: 1, weight: '0.6' }, // 60% Yes
  { option: 2, weight: '0.4' } // 40% Abstain
  // Total: 0.6 + 0.4 = 1.0 ✅
];

await castWeightedVote(proposalID, splitVote);

// Example 2: Complex distribution
const complexVote = [
  { option: 1, weight: '0.45' }, // 45% Yes
  { option: 2, weight: '0.25' }, // 25% Abstain
  { option: 3, weight: '0.20' }, // 20% No
  { option: 4, weight: '0.10' } // 10% NoWithVeto
  // Total: 0.45 + 0.25 + 0.20 + 0.10 = 1.0 ✅
];

await castWeightedVote(proposalID, complexVote);

// Example 3: This would FAIL - weights don't sum to 1.0
const badVote = [
  { option: 1, weight: '0.7' },
  { option: 2, weight: '0.2' }
  // Total: 0.7 + 0.2 = 0.9 ❌ WILL FAIL
];
// await castWeightedVote(proposalID, badVote); // Don't run this!
```

### Deposit to a Proposal

```typescript theme={"dark"}
// Add deposit to help proposal reach minimum threshold
async function addDepositToProposal(proposalID: bigint, depositAmount: bigint): Promise<void> {
  if (depositAmount <= 0) {
    throw new Error('Deposit amount must be greater than 0');
  }

  // Check balance
  const userAddress = await signer.getAddress();
  const balance = await provider.getBalance(userAddress);
  const totalCost = depositAmount + ethers.parseUnits('0.05', 18); // Add gas buffer

  if (balance < totalCost) {
    throw new Error(`Insufficient balance. Need ${ethers.formatEther(totalCost)} SEI (including gas), ` + `but have ${ethers.formatEther(balance)} SEI`);
  }

  try {
    console.log('Adding deposit to proposal...');
    console.log(`Proposal ID: ${proposalID.toString()}`);
    console.log(`Deposit amount: ${ethers.formatEther(depositAmount)} SEI`);

    const tx = await governance.deposit(proposalID, {
      value: depositAmount,
      gasLimit: 200000
    });

    console.log('Transaction submitted:', tx.hash);
    const receipt = await tx.wait();

    console.log('✅ Deposit added successfully!');
    console.log(`Proposal ID: ${proposalID.toString()}`);
    console.log(`Amount deposited: ${ethers.formatEther(depositAmount)} SEI`);
    console.log(`Transaction hash: ${receipt.hash}`);
    console.log(`View proposal: https://sei.explorers.guru/proposal/${proposalID.toString()}`);
  } catch (error: any) {
    console.error('Failed to add deposit:', error);

    if (error.message.includes('proposal does not exist')) {
      throw new Error('Proposal does not exist');
    } else if (error.message.includes('deposit period ended')) {
      throw new Error('Deposit period has ended for this proposal');
    } else {
      throw error;
    }
  }
}

// Usage example
const proposalID = 1n;
const additionalDeposit = ethers.parseUnits('1000', 18); // 1,000 SEI
await addDepositToProposal(proposalID, additionalDeposit);
```

## Complete Integration Example

Create a comprehensive governance interaction script:

```javascript title="governance-mainnet-demo.js" theme={"dark"}
const { ethers } = require('ethers');
const { GOVERNANCE_PRECOMPILE_ABI, GOVERNANCE_PRECOMPILE_ADDRESS } = require('@sei-js/precompiles');
require('dotenv').config();

// Validation functions
function isValidVoteOption(option) {
  return option >= 1 && option <= 4;
}

function validateWeightedOptions(options) {
  const totalWeight = options.reduce((sum, opt) => sum + parseFloat(opt.weight), 0);
  const isValidTotal = Math.abs(totalWeight - 1.0) < 0.000001;
  const allOptionsValid = options.every((opt) => isValidVoteOption(opt.option));
  return isValidTotal && allOptionsValid;
}

function validateProposalJSON(proposalJSON) {
  try {
    const proposal = JSON.parse(proposalJSON);
    return proposal.title && proposal.description && typeof proposal.title === 'string' && typeof proposal.description === 'string' && proposal.title.length > 0 && proposal.description.length > 0;
  } catch {
    return false;
  }
}

function validateDepositAmount(depositAmount, isExpedited = false) {
  const MINIMUM_DEPOSIT = ethers.parseUnits('3500', 18); // 3,500 SEI
  const EXPEDITED_DEPOSIT = ethers.parseUnits('7000', 18); // 7,000 SEI
  const required = isExpedited ? EXPEDITED_DEPOSIT : MINIMUM_DEPOSIT;
  return depositAmount >= required;
}

async function main() {
  try {
    // Connect to Sei Mainnet
    console.log('🌐 Connecting to Sei Mainnet...');
    const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');

    // Use your private key from environment variable
    const privateKey = process.env.PRIVATE_KEY;
    if (!privateKey) {
      throw new Error('Please set PRIVATE_KEY in .env file');
    }

    const wallet = new ethers.Wallet(privateKey, provider);
    const userAddress = wallet.address;

    console.log(`👤 Wallet address: ${userAddress}`);

    // Check balance
    const balance = await provider.getBalance(userAddress);
    const balanceEther = ethers.formatEther(balance);
    console.log(`💰 Wallet balance: ${balanceEther} SEI\n`);

    // Verify sufficient balance for mainnet governance
    const minimumRequired = ethers.parseUnits('3600', 18); // 3,600 SEI (3,500 + buffer)
    if (balance < minimumRequired) {
      console.log('❌ Insufficient balance for mainnet governance participation');
      console.log(`   Required: At least 3,600 SEI (3,500 for proposal + 100 buffer)`);
      console.log(`   Current: ${balanceEther} SEI`);
      console.log('   Please acquire more SEI tokens from exchanges or DEXs');
      return;
    }

    // Initialize governance precompile contract
    const governance = new ethers.Contract(GOVERNANCE_PRECOMPILE_ADDRESS, GOVERNANCE_PRECOMPILE_ABI, wallet);

    console.log('🏛️  === Sei Mainnet Governance Demo ===\n');

    // 1. Submit a governance proposal
    console.log('1️⃣  Submitting a governance proposal...');

    const proposal = {
      title: 'Demo: EVM Governance Integration Test',
      description: `This is a demonstration proposal submitted through the governance precompile to showcase seamless EVM-Cosmos governance integration.

## Purpose
This proposal demonstrates:
- EVM smart contract governance participation
- Cross-environment compatibility
- Native governance functionality through precompiles

## Technical Details
- Submitted via governance precompile at ${GOVERNANCE_PRECOMPILE_ADDRESS}
- Using ethers.js for transaction management
- Mainnet deployment with real SEI deposits

## Voting Recommendation
This is a test proposal. Vote according to your preference to test the system.`,
      type: 'Text',
      is_expedited: false
    };

    const proposalJSON = JSON.stringify(proposal);

    // Validate proposal
    if (!validateProposalJSON(proposalJSON)) {
      throw new Error('Invalid proposal JSON structure');
    }

    // Use mainnet-appropriate deposit
    const depositAmount = ethers.parseUnits('3500', 18); // Exactly minimum required

    if (!validateDepositAmount(depositAmount)) {
      throw new Error('Deposit amount insufficient for mainnet');
    }

    try {
      console.log(`   📋 Title: ${proposal.title}`);
      console.log(`   💵 Deposit: ${ethers.formatEther(depositAmount)} SEI`);
      console.log('   🚀 Submitting transaction...');

      const submitTx = await governance.submitProposal(proposalJSON, {
        value: depositAmount,
        gasLimit: 500000,
        gasPrice: ethers.parseUnits('100', 'gwei') // Set appropriate gas price
      });

      console.log(`   📝 Transaction hash: ${submitTx.hash}`);
      console.log('   ⏳ Waiting for confirmation...');

      const submitReceipt = await submitTx.wait();

      // Extract proposal ID safely
      let proposalID = null;
      for (const log of submitReceipt.logs) {
        try {
          const parsed = governance.interface.parseLog(log);
          if (parsed && parsed.name === 'ProposalSubmitted') {
            proposalID = parsed.args.proposalID;
            break;
          }
        } catch {
          continue;
        }
      }

      if (!proposalID) {
        console.log('   ⚠️  Could not extract proposal ID. Check transaction manually.');
        console.log(`   🔗 Transaction: https://seiscan.io/tx/${submitReceipt.hash}`);
        return;
      }

      console.log(`   ✅ Proposal submitted successfully!`);
      console.log(`   🆔 Proposal ID: ${proposalID.toString()}`);
      console.log(`   🔗 View proposal: https://sei.explorers.guru/proposal/${proposalID.toString()}`);

      // 2. Demonstrate voting
      console.log(`\n2️⃣  Voting on proposal ${proposalID.toString()}...`);

      const voteOption = 1; // Yes
      const voteNames = { 1: 'Yes', 2: 'Abstain', 3: 'No', 4: 'NoWithVeto' };

      console.log(`   🗳️  Vote option: ${voteNames[voteOption]}`);
      console.log('   🚀 Submitting vote...');

      const voteTx = await governance.vote(proposalID, voteOption, {
        gasLimit: 200000,
        gasPrice: ethers.parseUnits('100', 'gwei')
      });

      console.log(`   📝 Transaction hash: ${voteTx.hash}`);
      await voteTx.wait();

      console.log('   ✅ Vote cast successfully!');
      console.log(`   🔗 Transaction: https://seiscan.io/tx/${voteTx.hash}`);

      // 3. Demonstrate weighted voting
      console.log(`\n3️⃣  Casting weighted vote on proposal ${proposalID.toString()}...`);

      const weightedOptions = [
        { option: 1, weight: '0.7' }, // 70% Yes
        { option: 2, weight: '0.2' }, // 20% Abstain
        { option: 3, weight: '0.1' } // 10% No
        // CRITICAL: Total = 0.7 + 0.2 + 0.1 = 1.0 ✅
      ];

      if (!validateWeightedOptions(weightedOptions)) {
        throw new Error('CRITICAL: Invalid weighted options - transaction would fail');
      }

      console.log('   📊 Vote distribution:');
      weightedOptions.forEach(({ option, weight }) => {
        const percent = (parseFloat(weight) * 100).toFixed(1);
        console.log(`      ${percent}% ${voteNames[option]}`);
      });

      console.log('   🚀 Submitting weighted vote...');

      const weightedTx = await governance.voteWeighted(proposalID, weightedOptions, {
        gasLimit: 300000,
        gasPrice: ethers.parseUnits('100', 'gwei')
      });

      console.log(`   📝 Transaction hash: ${weightedTx.hash}`);
      await weightedTx.wait();

      console.log('   ✅ Weighted vote cast successfully!');
      console.log(`   🔗 Transaction: https://seiscan.io/tx/${weightedTx.hash}`);

      // 4. Add additional deposit
      console.log(`\n4️⃣  Adding deposit to proposal ${proposalID.toString()}...`);

      const additionalDeposit = ethers.parseUnits('500', 18); // 500 SEI

      console.log(`   💵 Additional deposit: ${ethers.formatEther(additionalDeposit)} SEI`);
      console.log('   🚀 Submitting deposit...');

      const depositTx = await governance.deposit(proposalID, {
        value: additionalDeposit,
        gasLimit: 200000,
        gasPrice: ethers.parseUnits('100', 'gwei')
      });

      console.log(`   📝 Transaction hash: ${depositTx.hash}`);
      await depositTx.wait();

      console.log('   ✅ Additional deposit added successfully!');
      console.log(`   🔗 Transaction: https://seiscan.io/tx/${depositTx.hash}`);

      // Summary
      console.log('\n🎉 === Governance Demo Completed Successfully! ===');
      console.log(`📊 Proposal ID: ${proposalID.toString()}`);
      console.log(`💰 Total deposited: ${ethers.formatEther(depositAmount + additionalDeposit)} SEI`);
      console.log('🔗 View all governance proposals: https://sei.explorers.guru/proposals');
    } catch (error) {
      if (error.message.includes('insufficient funds')) {
        console.log('\n❌ Insufficient funds for governance participation');
        console.log('   Ensure you have enough SEI for deposits and gas fees');
      } else if (error.message.includes('already voted')) {
        console.log('\n⚠️  You have already voted on this proposal');
      } else {
        throw error;
      }
    }
  } catch (error) {
    console.error('\n❌ Error:', error.message);
    console.log('\n🔧 Troubleshooting tips:');
    console.log('1. Ensure PRIVATE_KEY is set in .env file');
    console.log('2. Verify sufficient SEI balance (minimum 3,600 SEI)');
    console.log('3. Check network connectivity to Sei mainnet');
    console.log('4. Confirm wallet has staked SEI for voting power');
    process.exit(1);
  }
}

// Run the demo
main().catch(console.error);
```

### Running the Example

1. **Create a new directory and initialize npm:**

```bash theme={"dark"}
mkdir sei-governance-mainnet
cd sei-governance-mainnet
npm init -y
```

2. **Install dependencies:**

```bash theme={"dark"}
npm install ethers @sei-js/precompiles@^2.1.2 dotenv
```

3. **Create a `.env` file:**

```bash theme={"dark"}
PRIVATE_KEY=your_private_key_here
```

4. **Create the demo file:**
   Copy the complete integration example above into `governance-mainnet-demo.js`

5. **Ensure you have sufficient SEI:**

   * Minimum 3,500 SEI for proposal deposit
   * Additional SEI for gas and optional additional deposits
   * Staked SEI for voting power

6. **Run the script:**

```bash theme={"dark"}
node governance-mainnet-demo.js
```

### Expected Output

```
🌐 Connecting to Sei Mainnet...
👤 Wallet address: 0x742d35Cc6634C0532925a3b844Bc6789e065f3B
💰 Wallet balance: 5000.5 SEI

🏛️  === Sei Mainnet Governance Demo ===

1️⃣  Submitting a governance proposal...
   📋 Title: Demo: EVM Governance Integration Test
   💵 Deposit: 3500.0 SEI
   🚀 Submitting transaction...
   📝 Transaction hash: 0x123...abc
   ⏳ Waiting for confirmation...
   ✅ Proposal submitted successfully!
   🆔 Proposal ID: 42
   🔗 View proposal: https://sei.explorers.guru/proposal/42

2️⃣  Voting on proposal 42...
   🗳️  Vote option: Yes
   🚀 Submitting vote...
   📝 Transaction hash: 0x456...def
   ✅ Vote cast successfully!
   🔗 Transaction: https://seiscan.io/tx/0x456...def

3️⃣  Casting weighted vote on proposal 42...
   📊 Vote distribution:
      70.0% Yes
      20.0% Abstain
      10.0% No
   🚀 Submitting weighted vote...
   📝 Transaction hash: 0x789...ghi
   ✅ Weighted vote cast successfully!
   🔗 Transaction: https://seiscan.io/tx/0x789...ghi

4️⃣  Adding deposit to proposal 42...
   💵 Additional deposit: 500.0 SEI
   🚀 Submitting deposit...
   📝 Transaction hash: 0xabc...123
   ✅ Additional deposit added successfully!
   🔗 Transaction: https://seiscan.io/tx/0xabc...123

🎉 === Governance Demo Completed Successfully! ===
📊 Proposal ID: 42
💰 Total deposited: 4000.0 SEI
🔗 View all governance proposals: https://sei.explorers.guru/proposals
```

## Troubleshooting

### Common Issues and Solutions

#### Insufficient Deposit

```typescript theme={"dark"}
// Check minimum deposit requirement based on proposal type
const MINIMUM_DEPOSIT = ethers.parseUnits('3500', 18); // 3,500 SEI minimum
const EXPEDITED_DEPOSIT = ethers.parseUnits('7000', 18); // 7,000 SEI for expedited

function checkDepositRequirement(depositAmount: bigint, isExpedited: boolean = false): void {
  const requiredAmount = isExpedited ? EXPEDITED_DEPOSIT : MINIMUM_DEPOSIT;
  const networkName = 'mainnet';

  if (depositAmount < requiredAmount) {
    const required = ethers.formatEther(requiredAmount);
    const provided = ethers.formatEther(depositAmount);
    throw new Error(`Deposit too low for ${networkName}${isExpedited ? ' (expedited)' : ''}. Required: ${required} SEI, Provided: ${provided} SEI`);
  }
}
```

#### No Voting Power

```typescript theme={"dark"}
// Check if user has staked SEI for voting power
async function checkVotingEligibility(userAddress: string): Promise<void> {
  console.log('Checking voting eligibility...');

  // Note: You would typically integrate with staking queries here
  // This is a placeholder for the actual implementation

  console.log('⚠️  Reminder: You must have staked SEI to participate in governance voting');
  console.log('   Liquid SEI does not provide voting power');
  console.log('   Delegate your SEI to validators to gain voting power');
  console.log('   Visit: https://dashboard.sei.io/stake to stake your tokens');
}
```

#### Invalid Vote Option

```typescript theme={"dark"}
// Validate vote option with descriptive error
function validateVoteOptionWithDescription(option: number): void {
  const voteOptions = {
    1: 'Yes - Vote in favor of the proposal',
    2: 'Abstain - Neutral vote that counts toward quorum',
    3: 'No - Vote against the proposal',
    4: 'NoWithVeto - Strong opposition that can burn deposits'
  };

  if (!(option in voteOptions)) {
    const validOptions = Object.entries(voteOptions)
      .map(([key, value]) => `${key}: ${value}`)
      .join('\n');

    throw new Error(`Invalid vote option: ${option}\n\nValid options:\n${validOptions}`);
  }
}
```

#### Weighted Vote Validation

```typescript theme={"dark"}
// Comprehensive weighted vote validation with helpful errors
function validateWeightedVoteComprehensive(options: Array<{ option: number; weight: string }>): void {
  if (options.length === 0) {
    throw new Error('At least one vote option is required');
  }

  if (options.length > 4) {
    throw new Error('Cannot have more than 4 vote options');
  }

  let totalWeight = 0;
  const seenOptions = new Set<number>();
  const voteOptionNames = { 1: 'Yes', 2: 'Abstain', 3: 'No', 4: 'NoWithVeto' };

  for (let i = 0; i < options.length; i++) {
    const { option, weight } = options[i];

    // Validate option
    if (option < 1 || option > 4 || !Number.isInteger(option)) {
      throw new Error(
        `Invalid vote option at index ${i}: ${option}. Must be integer 1-4\n` +
          `Valid options: ${Object.entries(voteOptionNames)
            .map(([k, v]) => `${k}=${v}`)
            .join(', ')}`
      );
    }

    // Check for duplicate options
    if (seenOptions.has(option)) {
      throw new Error(`Duplicate vote option: ${option} (${voteOptionNames[option as keyof typeof voteOptionNames]})\n` + `Each vote option can only be used once`);
    }
    seenOptions.add(option);

    // Validate weight
    const weightNum = parseFloat(weight);
    if (isNaN(weightNum)) {
      throw new Error(`Invalid weight at index ${i}: "${weight}" is not a valid number`);
    }

    if (weightNum <= 0) {
      throw new Error(`Invalid weight at index ${i}: ${weight}. Weight must be greater than 0`);
    }

    if (weightNum > 1) {
      throw new Error(`Invalid weight at index ${i}: ${weight}. Weight cannot exceed 1.0`);
    }

    totalWeight += weightNum;
  }

  // Check total weight - CRITICAL for transaction success
  if (Math.abs(totalWeight - 1.0) > 0.000001) {
    const weightSummary = options.map(({ option, weight }) => `${voteOptionNames[option as keyof typeof voteOptionNames]}: ${weight}`).join(', ');

    throw new Error(`CRITICAL: Total weight must equal exactly 1.0, got ${totalWeight.toFixed(6)}\n` + `Current weights: ${weightSummary}\n` + `Sum: ${totalWeight.toFixed(6)}\n` + `Transaction will fail if weights don't sum to 1.0`);
  }
}
```

### Error Code Reference

| Error                       | Cause                                      | Solution                                                    |
| --------------------------- | ------------------------------------------ | ----------------------------------------------------------- |
| `proposal does not exist`   | Invalid proposal ID or proposal expired    | Verify proposal ID and ensure voting period is still active |
| `inactive proposal`         | Voting or deposit period has ended         | Check proposal status and timeline                          |
| `insufficient deposit`      | Deposit below 3,500 SEI                    | Increase deposit to the minimum required amount             |
| `invalid vote option`       | Vote option not 1-4                        | Use a valid option (1-Yes, 2-Abstain, 3-No, 4-NoWithVeto)   |
| `already voted`             | Address has already voted on this proposal | Each address can vote only once per proposal                |
| `weights must sum to 1`     | Weighted votes don’t sum to 1.0            | **CRITICAL —** adjust weights so they total exactly 1.0     |
| `insufficient voting power` | No staked SEI                              | Delegate SEI to validators to gain voting power             |
| `deposit period ended`      | Deposits no longer accepted                | Deposit period closes 2 days after submission               |

<Info>
  **Need Help?** If you encounter issues:

  * **Discord:** [Sei Community Discord](https://discord.gg/sei)
  * **GitHub:** [Sei Protocol Repository](https://github.com/sei-protocol/sei-chain)
  * **Explorer:** [View Proposals on Sei Explorer](https://sei.explorers.guru/proposals)
</Info>

---

URL: https://docs.sei.io/evm/precompiles/json

# JSON Precompile Usage

> Learn how to interact with Sei's JSON precompile through ethers.js, enabling efficient parsing, manipulation, and querying of JSON data within EVM smart contracts to overcome Solidity's native limitations for handling complex data structures.

**Address:** `0x0000000000000000000000000000000000001003`

The Sei JSON precompile allows EVM applications to efficiently parse and query JSON data directly within smart contracts. This enables complex data handling capabilities that are not natively available in Solidity, making it easier to work with structured data from external sources or APIs.

<Info>**What is a precompile?** A precompile is a special smart contract deployed at a fixed address by the Sei protocol itself, that exposes custom native chain logic to EVM-based applications. It acts like a regular contract from the EVM's perspective, but executes privileged, low-level logic efficiently.</Info>

## How Does the JSON Precompile Work?

The JSON precompile at address `0x0000000000000000000000000000000000001003` exposes functions like `extractAsBytes()`, `extractAsBytesList()`, and `extractAsUint256()`.

* **Direct Integration:** EVM contracts and dApps can parse JSON data like any other smart contract method.
* **Native Execution:** JSON parsing is executed at the native level for maximum efficiency.
* **Seamless Bridge:** No need for complex workarounds or external libraries for JSON handling.

## Use Cases

* **Oracle Integration:** Parse complex oracle responses containing multiple data points.
* **DeFi Applications:** Process structured price feeds and market data.
* **Gaming:** Handle complex game state and player data stored in JSON format.
* **Cross-Chain Communication:** Parse messages and data from other chains.
* **NFT Metadata:** Extract and manipulate NFT metadata stored in JSON format.

## Functions

The JSON precompile exposes the following functions:

### Query Functions

```solidity theme={"dark"}
/// Extracts data as bytes from the input using the specified key.
/// @param input The input data.
/// @param key The key to extract.
/// @return The extracted data as bytes.
function extractAsBytes(
    bytes memory input,
    string memory key
) external view returns (bytes memory response);

/// Extracts data as a list of bytes from the input using the specified key.
/// @param input The input data.
/// @param key The key to extract.
/// @return The extracted data as bytes collection.
function extractAsBytesList(
    bytes memory input,
    string memory key
) external view returns (bytes[] memory response);

/// Extracts data as a uint256 from the input using the specified key.
/// @param input The input data.
/// @param key The key to extract.
/// @return The extracted uint256.
function extractAsUint256(
    bytes memory input,
    string memory key
) external view returns (uint256 response);
```

## Using the Precompile

### Setup

#### Prerequisites

Before getting started, ensure you have:

* **Node.js** (v18 or higher)
* **npm** or **yarn** package manager
* **MetaMask** or compatible EVM wallet configured for Sei Mainnet
* **SEI tokens** for gas

#### Install Dependencies

Install the required packages for interacting with Sei precompiles:

```bash theme={"dark"}
# Install ethers.js for smart contract interactions
npm install ethers

# Install Sei EVM bindings for precompile addresses and ABIs
npm install @sei-js/precompiles@^2.1.2

# Install dotenv for managing private keys (recommended for security)
npm install dotenv
```

#### Import Precompile Components

```typescript theme={"dark"}
// Import JSON precompile address and ABI
// View the entire ABI here: https://github.com/sei-protocol/sei-chain/tree/main/precompiles/json
import { JSON_PRECOMPILE_ABI, JSON_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';
import { ethers } from 'ethers';
```

<Info>**Precompile Address:** The JSON precompile is deployed at `0x0000000000000000000000000000000000001003`</Info>

### Contract Initialization

Set up your provider, signer, and contract instance:

```typescript theme={"dark"}
// Using MetaMask as the signer and provider (browser environment)
const provider = new ethers.BrowserProvider(window.ethereum);
await provider.send('eth_requestAccounts', []);
const signer = await provider.getSigner();

// Or for Node.js environment
const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

// Create a contract instance for the JSON precompile
const jsonPrecompile = new ethers.Contract(JSON_PRECOMPILE_ADDRESS, JSON_PRECOMPILE_ABI, signer);
```

## Data Type Handling

The JSON precompile has specific limitations for different data types:

### Supported Data Types

| Function           | Supports                  | Limitations                                |
| ------------------ | ------------------------- | ------------------------------------------ |
| extractAsBytes     | Strings, Objects, Arrays  | Returns raw bytes - needs conversion       |
| extractAsUint256   | Integers only             | No decimals, booleans, or negative numbers |
| extractAsBytesList | Arrays of strings/objects | Each element returned as bytes             |

### Data Type Conversion Strategies

```typescript theme={"dark"}
// For decimal numbers - store as integers with known precision
const priceData = { price: 250 }; // Represents 2.50 with 2 decimal places
const price = await jsonPrecompile.extractAsUint256(inputData, 'price');
const actualPrice = parseFloat(price.toString()) / 100; // Convert back to 2.50

// For boolean values - use 0/1 integers
const statusData = { isActive: 1 }; // 1 = true, 0 = false
const isActiveInt = await jsonPrecompile.extractAsUint256(inputData, 'isActive');
const isActive = isActiveInt === 1n;

// For complex objects - extract as bytes and parse
const userData = { user: { name: 'Alice', balance: 1000 } };
const userBytes = await jsonPrecompile.extractAsBytes(inputData, 'user');
const userString = ethers.toUtf8String(userBytes);
const userObject = JSON.parse(userString);
```

## Error Handling Utilities

Create comprehensive error handling for all extraction functions:

```typescript theme={"dark"}
// Safe extraction for bytes data
async function safeExtractBytes(jsonPrecompile: ethers.Contract, data: any, key: string, defaultValue: string = ''): Promise<string> {
  try {
    const inputData = ethers.toUtf8Bytes(JSON.stringify(data));
    const result = await jsonPrecompile.extractAsBytes(inputData, key);
    return ethers.toUtf8String(result);
  } catch (error: any) {
    console.log(`Key "${key}" not found or invalid, using default value`);
    return defaultValue;
  }
}

// Safe extraction for uint256 data
async function safeExtractUint256(jsonPrecompile: ethers.Contract, data: any, key: string, defaultValue: bigint = 0n): Promise<bigint> {
  try {
    const inputData = ethers.toUtf8Bytes(JSON.stringify(data));
    const result = await jsonPrecompile.extractAsUint256(inputData, key);
    return result;
  } catch (error: any) {
    console.log(`Key "${key}" not found or not a valid integer, using default value`);
    return defaultValue;
  }
}

// Safe extraction for array data
async function safeExtractBytesList(jsonPrecompile: ethers.Contract, data: any, key: string, defaultValue: string[] = []): Promise<string[]> {
  try {
    const inputData = ethers.toUtf8Bytes(JSON.stringify(data));
    const result = await jsonPrecompile.extractAsBytesList(inputData, key);
    return result.map((bytes: any) => ethers.toUtf8String(bytes));
  } catch (error: any) {
    console.log(`Key "${key}" not found or not a valid array, using default value`);
    return defaultValue;
  }
}
```

## Step-by-Step Guide: Using the JSON Precompile

### Extract String Data

```typescript theme={"dark"}
// JSON data with string values
const data = { name: 'Sei Token', symbol: 'SEI' };
const inputData = ethers.toUtf8Bytes(JSON.stringify(data));

// Extract string using safe method
const name = await safeExtractBytes(jsonPrecompile, data, 'name');
console.log('Name:', name); // Output: "Sei Token"

// Or direct extraction with error handling
try {
  const symbolBytes = await jsonPrecompile.extractAsBytes(inputData, 'symbol');
  const symbol = ethers.toUtf8String(symbolBytes);
  console.log('Symbol:', symbol); // Output: "SEI"
} catch (error) {
  console.error('Failed to extract symbol:', error.message);
}
```

### Extract Numeric Data

```typescript theme={"dark"}
// JSON data with numbers (integers only)
const data = { price: 42, volume: 1000000 };
const inputData = ethers.toUtf8Bytes(JSON.stringify(data));

// Extract integer using safe method
const price = await safeExtractUint256(jsonPrecompile, data, 'price');
console.log('Price:', price.toString()); // Output: "42"

// Handle decimal numbers by using integer representation
const decimalData = { rate: 275 }; // Represents 2.75 with 2 decimal places
const rate = await safeExtractUint256(jsonPrecompile, decimalData, 'rate');
const actualRate = Number(rate) / 100; // Convert to 2.75
console.log('Rate:', actualRate);
```

### Extract Array Data

```typescript theme={"dark"}
// JSON data with array
const data = { tokens: ['SEI', 'USDC', 'USDT'] };
const inputData = ethers.toUtf8Bytes(JSON.stringify(data));

// Extract array using safe method
const tokens = await safeExtractBytesList(jsonPrecompile, data, 'tokens');
console.log('Tokens:', tokens); // Output: ["SEI", "USDC", "USDT"]

// Handle mixed arrays by extracting as bytes and parsing
const mixedData = { values: [42, 'test', 100] };
const valuesBytes = await jsonPrecompile.extractAsBytes(ethers.toUtf8Bytes(JSON.stringify(mixedData)), 'values');
const valuesString = ethers.toUtf8String(valuesBytes);
const valuesArray = JSON.parse(valuesString);
console.log('Mixed values:', valuesArray); // Output: [42, "test", 100]
```

### Extract Nested Data

<Warning>**Important:** The JSON precompile does not support dot notation for nested objects. Instead, extract the parent object and parse it manually.</Warning>

```typescript theme={"dark"}
// For nested data, extract the parent object first
const data = {
  user: {
    wallet: {
      balance: 1000,
      currency: 'SEI'
    }
  }
};

// Method 1: Extract parent object and parse manually (recommended)
const userBytes = await jsonPrecompile.extractAsBytes(ethers.toUtf8Bytes(JSON.stringify(data)), 'user');
const userData = JSON.parse(ethers.toUtf8String(userBytes));
const balance = userData.wallet.balance;
const currency = userData.wallet.currency;

console.log('Balance:', balance); // Output: 1000
console.log('Currency:', currency); // Output: "SEI"

// Method 2: Extract deeper nested object
const walletBytes = await jsonPrecompile.extractAsBytes(
  ethers.toUtf8Bytes(JSON.stringify(data)),
  'wallet' // Direct key, not dot notation
);
const walletData = JSON.parse(ethers.toUtf8String(walletBytes));
console.log('Wallet data:', walletData); // Output: { balance: 1000, currency: "SEI" }
```

## Complete Integration Example

Create a comprehensive JSON parsing application for mainnet:

```javascript title="json-precompile-mainnet.js" theme={"dark"}
// json-precompile-mainnet.js
const { ethers } = require('ethers');
const { JSON_PRECOMPILE_ABI, JSON_PRECOMPILE_ADDRESS } = require('@sei-js/precompiles');
require('dotenv').config();

// Safe extraction utilities
async function safeExtractBytes(jsonPrecompile, data, key, defaultValue = '') {
  try {
    const inputData = ethers.toUtf8Bytes(JSON.stringify(data));
    const result = await jsonPrecompile.extractAsBytes(inputData, key);
    return ethers.toUtf8String(result);
  } catch (error) {
    console.log(`   ⚠️  Key "${key}" not found, using default: "${defaultValue}"`);
    return defaultValue;
  }
}

async function safeExtractUint256(jsonPrecompile, data, key, defaultValue = 0n) {
  try {
    const inputData = ethers.toUtf8Bytes(JSON.stringify(data));
    const result = await jsonPrecompile.extractAsUint256(inputData, key);
    return result;
  } catch (error) {
    console.log(`   ⚠️  Key "${key}" not found or invalid integer, using default: ${defaultValue}`);
    return defaultValue;
  }
}

async function safeExtractBytesList(jsonPrecompile, data, key, defaultValue = []) {
  try {
    const inputData = ethers.toUtf8Bytes(JSON.stringify(data));
    const result = await jsonPrecompile.extractAsBytesList(inputData, key);
    return result.map((bytes) => ethers.toUtf8String(bytes));
  } catch (error) {
    console.log(`   ⚠️  Key "${key}" not found or invalid array, using default: [${defaultValue.join(', ')}]`);
    return defaultValue;
  }
}

async function main() {
  try {
    // Connect to Sei Mainnet
    console.log('🌐 Connecting to Sei Mainnet...');
    const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');

    // Use private key from environment variables (secure approach)
    const privateKey = process.env.PRIVATE_KEY;
    if (!privateKey) {
      throw new Error('Please set PRIVATE_KEY in .env file');
    }

    const wallet = new ethers.Wallet(privateKey, provider);
    console.log(`👤 Wallet address: ${wallet.address}`);

    // Check balance
    const balance = await provider.getBalance(wallet.address);
    const balanceEther = ethers.formatEther(balance);
    console.log(`💰 Wallet balance: ${balanceEther} SEI\n`);

    // Initialize JSON precompile contract
    const jsonPrecompile = new ethers.Contract(JSON_PRECOMPILE_ADDRESS, JSON_PRECOMPILE_ABI, wallet);

    console.log('📄 === Sei Mainnet JSON Precompile Demo ===\n');

    // Complex sample data - simulating a real-world oracle response
    const oracleData = {
      market: {
        prices: {
          SEI: 275, // 2.75 USD (stored as integer with 2 decimal places)
          BTC: 5000000, // 50,000.00 USD
          ETH: 300000 // 3,000.00 USD
        },
        volume: {
          daily: 1500000000, // $15M daily volume
          weekly: 8500000000 // $85M weekly volume
        }
      },
      metadata: {
        timestamp: '2024-12-27T12:00:00Z',
        source: 'MainnetPriceOracle',
        version: '2.1.0',
        isLive: 1 // 1 = true, 0 = false
      },
      assets: ['SEI', 'BTC', 'ETH', 'USDC'],
      validators: {
        active: 125,
        total: 200
      }
    };

    console.log('📋 Input JSON Data:');
    console.log(JSON.stringify(oracleData, null, 2));
    console.log();

    // 1. Extract string data with error handling
    console.log('1️⃣  Extracting String Data...');

    // Extract metadata object first, then parse individual fields
    const metadataBytes = await jsonPrecompile.extractAsBytes(ethers.toUtf8Bytes(JSON.stringify(oracleData)), 'metadata');
    const metadata = JSON.parse(ethers.toUtf8String(metadataBytes));

    console.log(`   📊 Source: ${metadata.source}`);
    console.log(`   🔢 Version: ${metadata.version}`);
    console.log(`   ⏰ Timestamp: ${metadata.timestamp}`);
    console.log(`   🟢 Is Live: ${metadata.isLive === 1 ? 'Yes' : 'No'}`);

    // Test missing key
    const missingKey = await safeExtractBytes(jsonPrecompile, oracleData, 'nonexistent', 'N/A');
    console.log(`   ❓ Missing Key: ${missingKey}`);

    // 2. Extract numeric data with proper object parsing
    console.log('\n2️⃣  Extracting Numeric Data...');

    // Extract market object first
    const marketBytes = await jsonPrecompile.extractAsBytes(ethers.toUtf8Bytes(JSON.stringify(oracleData)), 'market');
    const market = JSON.parse(ethers.toUtf8String(marketBytes));

    // Extract validators object
    const validatorsBytes = await jsonPrecompile.extractAsBytes(ethers.toUtf8Bytes(JSON.stringify(oracleData)), 'validators');
    const validators = JSON.parse(ethers.toUtf8String(validatorsBytes));

    // Convert integers back to decimals
    const seiPrice = market.prices.SEI / 100; // 2 decimal places
    const btcPrice = market.prices.BTC / 100; // 2 decimal places
    const isLive = metadata.isLive === 1; // Convert to boolean

    console.log(`   💰 SEI Price: ${seiPrice} (raw: ${market.prices.SEI})`);
    console.log(`   ₿ BTC Price: ${btcPrice.toLocaleString()} (raw: ${market.prices.BTC})`);
    console.log(`   💹 Daily Volume: ${market.volume.daily.toLocaleString()}`);
    console.log(`   ✅ Active Validators: ${validators.active}`);
    console.log(`   🔴 Is Live: ${isLive} (raw: ${metadata.isLive})`);

    // 3. Extract array data
    console.log('\n3️⃣  Extracting Array Data...');
    const assets = await safeExtractBytesList(jsonPrecompile, oracleData, 'assets');
    const invalidArray = await safeExtractBytesList(jsonPrecompile, oracleData, 'invalid.array', ['DEFAULT']);

    console.log(`   🪙 Assets: [${assets.join(', ')}]`);
    console.log(`   ❌ Invalid Array: [${invalidArray.join(', ')}]`);

    // 4. Extract complex nested objects
    console.log('\n4️⃣  Extracting Complex Nested Data...');
    console.log('   📈 Market Data:');
    console.log(`      Prices: SEI=${market.prices.SEI / 100}, BTC=${market.prices.BTC / 100}, ETH=${market.prices.ETH / 100}`);
    console.log(`      Volume: Daily=${market.volume.daily.toLocaleString()}, Weekly=${market.volume.weekly.toLocaleString()}`);
    console.log(`   👥 Validator Data:`);
    console.log(`      Active: ${validators.active}, Total: ${validators.total}`);

    // 5. Gas optimization demonstration
    console.log('\n5️⃣  Gas Usage Analysis...');
    const gasEstimates = {
      small: 50000, // Simple key extraction
      medium: 80000, // Nested object extraction
      large: 120000 // Complex array/object processing
    };

    console.log('   ⛽ Recommended Gas Limits:');
    console.log(`      Simple extraction: ${gasEstimates.small.toLocaleString()} gas`);
    console.log(`      Nested extraction: ${gasEstimates.medium.toLocaleString()} gas`);
    console.log(`      Complex processing: ${gasEstimates.large.toLocaleString()} gas`);

    // 6. Performance test with corrected key extraction
    console.log('\n6️⃣  Performance & Error Testing...');
    const testCases = [
      { key: 'metadata', expected: 'object', description: 'metadata object' },
      { key: 'market', expected: 'object', description: 'market data' },
      { key: 'assets', expected: 'array', description: 'assets array' },
      { key: 'nonexistent', expected: 'error', description: 'missing key' }
    ];

    for (const testCase of testCases) {
      try {
        const start = Date.now();
        const result = await safeExtractBytes(jsonPrecompile, oracleData, testCase.key);
        const duration = Date.now() - start;
        const preview = result.length > 50 ? result.substring(0, 47) + '...' : result;
        console.log(`   ✅ ${testCase.description}: "${preview}" (${duration}ms)`);
      } catch (error) {
        console.log(`   ❌ ${testCase.description}: ${error.message}`);
      }
    }

    console.log('\n🎉 === JSON Precompile Demo Completed Successfully! ===');
  } catch (error) {
    console.error('\n❌ Error:', error.message);
    console.log('\n🔧 Troubleshooting tips:');
    console.log('1. Ensure PRIVATE_KEY is set in .env file');
    console.log('2. Verify sufficient SEI balance for gas fees');
    console.log('3. Check network connectivity to Sei mainnet');
    console.log('4. Validate JSON structure before processing');
    process.exit(1);
  }
}

// Run the demo
main().catch(console.error);
```

### Running the Mainnet Example

1. **Create a new directory and initialize npm:**

```bash theme={"dark"}
mkdir sei-json-mainnet
cd sei-json-mainnet
npm init -y
```

2. **Install dependencies:**

```bash theme={"dark"}
npm install ethers @sei-js/precompiles@^2.1.2 dotenv
```

3. **Create a `.env` file:**

```bash theme={"dark"}
PRIVATE_KEY=your_private_key_here
```

<Warning>**Security Note:** Never commit private keys to version control! The `.env` file should be added to your `.gitignore`.</Warning>

4. **Create the demo file:**
   Copy the complete integration example above into `json-precompile-mainnet.js`

5. **Ensure you have SEI tokens:**

   * SEI for gas (small amounts needed for view functions)

6. **Run the script:**

```bash theme={"dark"}
node json-precompile-mainnet.js
```

### Expected Output

```
🌐 Connecting to Sei Mainnet...
👤 Wallet address: 0x742d35Cc6634C0532925a3b844Bc6789e065f3B
💰 Wallet balance: 15.5 SEI

📄 === Sei Mainnet JSON Precompile Demo ===

📋 Input JSON Data:
{
  "market": {
    "prices": {
      "SEI": 275,
      "BTC": 5000000,
      "ETH": 300000
    },
    "volume": {
      "daily": 1500000000,
      "weekly": 8500000000
    }
  },
  "metadata": {
    "timestamp": "2024-12-27T12:00:00Z",
    "source": "MainnetPriceOracle",
    "version": "2.1.0",
    "isLive": 1
  },
  "assets": ["SEI", "BTC", "ETH", "USDC"],
  "validators": {
    "active": 125,
    "total": 200
  }
}

1️⃣  Extracting String Data...
   📊 Source: MainnetPriceOracle
   🔢 Version: 2.1.0
   ⏰ Timestamp: 2024-12-27T12:00:00Z
   🟢 Is Live: Yes
   ⚠️  Key "nonexistent" not found, using default: "N/A"
   ❓ Missing Key: N/A

2️⃣  Extracting Numeric Data...
   💰 SEI Price: $2.75 (raw: 275)
   ₿ BTC Price: $50,000 (raw: 5000000)
   💹 Daily Volume: $1,500,000,000
   ✅ Active Validators: 125
   🔴 Is Live: true (raw: 1)

3️⃣  Extracting Array Data...
   🪙 Assets: [SEI, BTC, ETH, USDC]
   ⚠️  Key "invalid.array" not found or invalid array, using default: [DEFAULT]
   ❌ Invalid Array: [DEFAULT]

4️⃣  Extracting Complex Nested Data...
   📈 Market Data:
      Prices: SEI=$2.75, BTC=$50000, ETH=$3000
      Volume: Daily=$1,500,000,000, Weekly=$8,500,000,000

5️⃣  Gas Usage Analysis...
   ⛽ Recommended Gas Limits:
      Simple extraction: 50,000 gas
      Nested extraction: 80,000 gas
      Complex processing: 120,000 gas

6️⃣  Performance & Error Testing...
   ✅ metadata object: "{"timestamp":"2024-12-27T12:00:00Z","source":"..." (15ms)
   ✅ market data: "{"prices":{"SEI":275,"BTC":5000000,"ETH":30000..." (12ms)
   ✅ assets array: "["SEI","BTC","ETH","USDC"]" (18ms)
   ⚠️  Key "nonexistent" not found, using default: ""
   ✅ missing key: "" (8ms)

🎉 === JSON Precompile Demo Completed Successfully! ===
```

## Advanced Usage Examples

### Oracle Price Feed Integration

```typescript theme={"dark"}
// Advanced oracle integration with comprehensive error handling
class SeiPriceOracle {
  private jsonPrecompile: ethers.Contract;

  constructor(jsonPrecompile: ethers.Contract) {
    this.jsonPrecompile = jsonPrecompile;
  }

  async parsePriceFeed(oracleResponse: any): Promise<{
    prices: Map<string, number>;
    timestamp: string;
    isValid: boolean;
  }> {
    try {
      // The precompile does not support dot notation for nested keys.
      // Extract the parent "metadata" object as bytes, then parse it manually.
      const metadataJson = await safeExtractBytes(this.jsonPrecompile, oracleResponse, 'metadata', '{}');
      const metadata = JSON.parse(metadataJson);
      const timestamp = metadata.timestamp ?? '';
      const isValid = metadata.isLive === 1;

      // Extract the parent "market" object the same way, then read its prices.
      const marketJson = await safeExtractBytes(this.jsonPrecompile, oracleResponse, 'market', '{}');
      const market = JSON.parse(marketJson);
      const rawPrices = market.prices ?? {};

      const prices = new Map<string, number>();
      const assets = await safeExtractBytesList(this.jsonPrecompile, oracleResponse, 'assets');

      for (const asset of assets) {
        // Convert from integer with 6 decimal places
        prices.set(asset, Number(rawPrices[asset] ?? 0) / 1000000);
      }

      return { prices, timestamp, isValid };
    } catch (error) {
      console.error('Failed to parse oracle response:', error);
      return {
        prices: new Map(),
        timestamp: '',
        isValid: false
      };
    }
  }
}
```

## Troubleshooting

### Common Issues and Solutions

#### Key Not Found

```typescript theme={"dark"}
// Comprehensive error handling for missing keys
async function handleMissingKeys(jsonPrecompile: ethers.Contract, data: any) {
  const keys = ['required.key', 'optional.key', 'deeply.nested.key'];

  for (const key of keys) {
    try {
      const result = await jsonPrecompile.extractAsBytes(ethers.toUtf8Bytes(JSON.stringify(data)), key);
      console.log(`✅ ${key}: ${ethers.toUtf8String(result)}`);
    } catch (error: any) {
      if (error.message.includes('key not found')) {
        console.log(`⚠️  Key "${key}" not found in JSON structure`);
      } else {
        console.log(`❌ Error extracting "${key}": ${error.message}`);
      }
    }
  }
}
```

### Error Code Reference

| Error                 | Cause                                    | Solution                                         |
| --------------------- | ---------------------------------------- | ------------------------------------------------ |
| `key not found`       | Specified key doesn't exist in JSON      | Verify key path and JSON structure               |
| `invalid JSON format` | Malformed JSON input                     | Use `JSON.stringify()` to ensure valid format    |
| `execution reverted`  | Gas limit too low                        | Increase gas limit based on data complexity      |
| `invalid integer`     | Non-numeric value for `extractAsUint256` | Ensure the value is a valid integer              |
| `out of gas`          | Insufficient gas for large JSON          | Use `calculateGasLimit()` for dynamic estimation |

## Key Considerations and Tricks

<Info>
  * **Integers Only:** `extractAsUint256` only handles integers - no decimals, booleans, or negative numbers
  * **Decimal Handling:** Store decimal numbers as integers with known precision (e.g., 275 for 2.75 with 2 decimal places)
  * **Boolean Values:** Use 0/1 integers to represent false/true
  * **Key Paths:** Extract parent objects first, then parse manually - dot notation may not be supported
  * **Arrays:** Must use `extractAsBytesList()` for array data
  * **Gas Costs:** Large JSON objects require higher gas limits
  * **Encoding:** Always use UTF-8 encoding with `ethers.toUtf8Bytes()`
  * **Error Handling:** Always implement fallback values for production applications
</Info>

<Info>**Need Help?** If you encounter issues not covered here, check the [Sei Discord](https://discord.gg/sei) or [GitHub repository](https://github.com/sei-protocol/sei-chain) for community support.</Info>

---

URL: https://docs.sei.io/evm/precompiles/oracle

# Oracle Precompile Usage

> Learn how to interact with Sei's Oracle precompile through ethers.js, enabling real-time access to exchange rates, TWAPs, and other economic data directly in your EVM smart contracts for DeFi applications.

**Address:** `0x0000000000000000000000000000000000001008`

<Danger>**Deprecation Notice:** The native Sei Oracle is deprecated and will be shut off soon. We strongly recommend migrating to one of the third-party oracle providers, such as [Chainlink](/evm/oracles/chainlink), [Pyth](/evm/oracles/pyth-network), [Redstone](/evm/oracles/redstone), or [API3](/evm/oracles/api3).</Danger>

---

URL: https://docs.sei.io/evm/precompiles/staking

# Staking Precompile

> Learn how to interact with Sei's Staking precompile through ethers.js, enabling delegation, undelegation, redelegation, and validator management directly in your EVM smart contracts for DeFi and staking applications.

<Info>Watch the video walkthrough for this topic in the [Video Tutorials](/evm/videos) section.</Info>

**Address:** `0x0000000000000000000000000000000000001005`

The Sei staking precompile allows EVM applications to interact directly with Sei's native staking module through standard smart contract calls. This enables delegation, undelegation, redelegation, validator management, and staking queries directly from your dApps without needing separate Cosmos SDK integration.

<Info> **What is a precompile?** A precompile is a special smart contract deployed at a fixed address by the Sei protocol itself, that exposes custom native chain logic to EVM-based applications. It acts like a regular contract from the EVM's perspective, but executes privileged, low-level logic efficiently. </Info>

## How Does the Staking Precompile Work?

The staking precompile at address `0x0000000000000000000000000000000000001005` exposes a comprehensive set of staking functions including `delegate()`, `undelegate()`, `redelegate()`, `createValidator()`, `editValidator()`, and various query functions like `validators()`, `delegatorDelegations()`, `pool()`, and `params()`.

* **Direct Integration:** EVM contracts and dApps can call staking functions like any other smart contract method.
* **Native Execution:** Operations are executed at the Cosmos SDK level for maximum efficiency and security.
* **Seamless Bridge:** No need for separate wallet integrations or complex cross-chain interactions.
* **Event Emission:** All staking operations emit events (`Delegate`, `Undelegate`, `Redelegate`, `ValidatorCreated`, `ValidatorEdited`) for easy tracking and indexing.

## Use Cases

* **DeFi Integration:** Build liquid staking protocols and yield farming strategies.
* **Delegation Services:** Create user-friendly interfaces for staking operations.
* **Portfolio Management:** Automate staking strategies and delegation rebalancing.
* **Validator Management:** Create and manage validators programmatically.

## What You'll Learn in This Guide

By the end of this guide, you'll be able to:

* **Integrate Staking Operations** - Call delegation, undelegation, and redelegation functions directly from your EVM contracts and dApps
* **Handle Decimal Precision** - Master the critical precision patterns for different operations to avoid common formatting errors
* **Create and Manage Validators** - Create new validators and edit their parameters programmatically
* **Query Staking State** - Use the comprehensive query functions to fetch validators, delegations, unbonding info, pool statistics, and staking parameters
* **Listen for Staking Events** - Track staking operations using emitted events for indexing and notifications
* **Build Portfolio Tools** - Implement automated rebalancing and delegation tracking for staking management applications
* **Navigate Staking Risks** - Understand unbonding periods, slashing mechanics, and validator selection for safe staking operations

## Events

The staking precompile emits the following events:

```solidity theme={"dark"}
/**
 * @notice Emitted when tokens are delegated to a validator
 * @param delegator The address of the delegator
 * @param validator The validator address
 * @param amount The amount delegated in base units
 */
event Delegate(address indexed delegator, string validator, uint256 amount);

/**
 * @notice Emitted when tokens are redelegated from one validator to another
 * @param delegator The address of the delegator
 * @param srcValidator The source validator address
 * @param dstValidator The destination validator address
 * @param amount The amount redelegated in base units
 */
event Redelegate(
    address indexed delegator,
    string srcValidator,
    string dstValidator,
    uint256 amount
);

/**
 * @notice Emitted when tokens are undelegated from a validator
 * @param delegator The address of the delegator
 * @param validator The validator address
 * @param amount The amount undelegated in base units
 */
event Undelegate(
    address indexed delegator,
    string validator,
    uint256 amount
);

/**
 * @notice Emitted when a new validator is created
 * @param creator The address of the validator creator
 * @param validatorAddress The validator address
 * @param moniker The validator moniker
 */
event ValidatorCreated(
    address indexed creator,
    string validatorAddress,
    string moniker
);

/**
 * @notice Emitted when a validator is edited
 * @param editor The address of the validator editor
 * @param validatorAddress The validator address
 * @param moniker The new validator moniker
 */
event ValidatorEdited(
    address indexed editor,
    string validatorAddress,
    string moniker
);
```

### Listening for Events

You can listen for these events in your dApp to track staking operations:

```typescript theme={"dark"}
// Listen for delegation events
staking.on('Delegate', (delegator, validator, amount) => {
  console.log(`${delegator} delegated ${amount} to ${validator}`);
});

// Listen for redelegation events
staking.on('Redelegate', (delegator, srcValidator, dstValidator, amount) => {
  console.log(`${delegator} redelegated ${amount} from ${srcValidator} to ${dstValidator}`);
});

// Listen for undelegation events
staking.on('Undelegate', (delegator, validator, amount) => {
  console.log(`${delegator} undelegated ${amount} from ${validator}`);
});

// Listen for validator creation events
staking.on('ValidatorCreated', (creator, validatorAddress, moniker) => {
  console.log(`New validator ${moniker} created at ${validatorAddress} by ${creator}`);
});

// Listen for validator edit events
staking.on('ValidatorEdited', (editor, validatorAddress, moniker) => {
  console.log(`Validator ${validatorAddress} edited by ${editor}, new moniker: ${moniker}`);
});
```

## Functions

The staking precompile exposes the following functions:

### Transaction Functions

```solidity theme={"dark"}
/// Delegates Sei to the specified validator.
/// @dev This function truncates msg.value to 6 decimal places for interaction with the staking module
/// @param valAddress The Sei address of the validator.
/// @return Whether the delegation was successful.
function delegate(
    string memory valAddress
) payable external returns (bool success);

/// Redelegates Sei from one validator to another.
/// @dev The amount should be in 6 decimal precision, not 18. 1 SEI = 1_000_000 uSEI
/// @param srcAddress The Sei address of the validator to move delegations from.
/// @param dstAddress The Sei address of the validator to move delegations to.
/// @param amount The amount of Sei to move from srcAddress to dstAddress.
/// @return Whether the redelegation was successful.
function redelegate(
    string memory srcAddress,
    string memory dstAddress,
    uint256 amount
) external returns (bool success);

/// Undelegates Sei from the specified validator.
/// @dev The amount should be in 6 decimal precision, not 18. 1 SEI = 1_000_000 uSEI
/// @param valAddress The Sei address of the validator to undelegate from.
/// @param amount The amount of Sei to undelegate.
/// @return Whether the undelegation was successful.
function undelegate(
    string memory valAddress,
    uint256 amount
) external returns (bool success);

/// Create a new validator. Delegation amount must be provided as value in wei.
/// @param pubKeyHex Ed25519 public key in hex format (64 characters)
/// @param moniker Validator display name
/// @param commissionRate Initial commission rate (e.g. "0.05" for 5%)
/// @param commissionMaxRate Maximum commission rate (e.g. "0.20" for 20%)
/// @param commissionMaxChangeRate Maximum commission change rate per day (e.g. "0.01" for 1%)
/// @param minSelfDelegation Minimum self-delegation amount in base units
/// @return success True if validator creation was successful
function createValidator(
    string memory pubKeyHex,
    string memory moniker,
    string memory commissionRate,
    string memory commissionMaxRate,
    string memory commissionMaxChangeRate,
    uint256 minSelfDelegation
) external payable returns (bool success);

/// Edit an existing validator's parameters
/// @param moniker New validator display name
/// @param commissionRate New commission rate (e.g. "0.10" for 10%)
///                      Pass empty string "" to not change commission rate
///                      Note: Commission can only be changed once per 24 hours
/// @param minSelfDelegation New minimum self-delegation amount
///                         Pass 0 to not change minimum self-delegation
///                         Note: Can only increase, cannot decrease below current value
/// @return success True if validator edit was successful
function editValidator(
    string memory moniker,
    string memory commissionRate,
    uint256 minSelfDelegation
) external returns (bool success);
```

### Query Functions

```solidity theme={"dark"}
struct Delegation {
    Balance balance;
    DelegationDetails delegation;
}

struct Balance {
    uint256 amount;  // Staked balance in usei (6 decimals)
    string denom;    // Token denomination (e.g., "usei")
}

struct DelegationDetails {
    string delegator_address;
    uint256 shares;    // Delegation shares (18 decimal precision)
    uint256 decimals;  // Precision for shares field (always 18)
    string validator_address;
}

struct Validator {
    string operatorAddress;      // Validator's operator address (seivaloper...)
    string consensusPubkey;      // Consensus public key
    bool jailed;                 // Whether the validator is jailed
    int32 status;                // Bonding status (1=Unbonded, 2=Unbonding, 3=Bonded)
    string tokens;               // Total tokens delegated
    string delegatorShares;      // Total delegator shares
    string description;          // Validator description/metadata
    int64 unbondingHeight;       // Height at which unbonding started
    int64 unbondingTime;         // Time at which unbonding completes
    string commissionRate;       // Current commission rate
    string commissionMaxRate;    // Maximum commission rate
    string commissionMaxChangeRate; // Maximum daily commission change rate
    int64 commissionUpdateTime;  // Last commission update timestamp
    string minSelfDelegation;    // Minimum self-delegation requirement
}

struct ValidatorsResponse {
    Validator[] validators;      // Array of validators
    bytes nextKey;               // Pagination key for next page
}

struct DelegationsResponse {
    Delegation[] delegations;    // Array of delegations
    bytes nextKey;               // Pagination key for next page
}

struct UnbondingDelegationEntry {
    int64 creationHeight;        // Height when unbonding was initiated
    int64 completionTime;        // Timestamp when unbonding completes
    string initialBalance;       // Initial unbonding balance
    string balance;              // Current unbonding balance
}

struct UnbondingDelegation {
    string delegatorAddress;     // Delegator's address
    string validatorAddress;     // Validator's address
    UnbondingDelegationEntry[] entries; // Unbonding entries
}

struct UnbondingDelegationsResponse {
    UnbondingDelegation[] unbondingDelegations; // Array of unbonding delegations
    bytes nextKey;               // Pagination key for next page
}

struct RedelegationEntry {
    int64 creationHeight;        // Height when redelegation was initiated
    int64 completionTime;        // Timestamp when redelegation completes
    string initialBalance;       // Initial redelegation balance
    string sharesDst;            // Shares at destination validator
}

struct Redelegation {
    string delegatorAddress;     // Delegator's address
    string validatorSrcAddress;  // Source validator address
    string validatorDstAddress;  // Destination validator address
    RedelegationEntry[] entries; // Redelegation entries
}

struct RedelegationsResponse {
    Redelegation[] redelegations; // Array of redelegations
    bytes nextKey;               // Pagination key for next page
}

struct HistoricalInfo {
    int64 height;                // Block height
    Validator[] validators;      // Validators at that height
}

struct Pool {
    string notBondedTokens;      // Total tokens not bonded
    string bondedTokens;         // Total tokens bonded
}

struct Params {
    uint64 unbondingTime;        // Unbonding duration in seconds
    uint32 maxValidators;        // Maximum number of validators
    uint32 maxEntries;           // Max unbonding/redelegation entries
    uint32 historicalEntries;    // Number of historical entries to keep
    string bondDenom;            // Bond token denomination
    string minCommissionRate;    // Minimum commission rate
    string maxVotingPowerRatio;  // Maximum voting power ratio
    string maxVotingPowerEnforcementThreshold; // Enforcement threshold
}

/// Queries delegation for a given delegator and validator address.
/// @param delegator The address of the delegator.
/// @param valAddress The Sei address of the validator.
/// @return The delegation information.
/// @dev balance.amount is in usei (6 decimals). To calculate SEI: amount / 1e6
/// @dev shares uses 18 decimal precision. To calculate actual shares: shares / 1e18
function delegation(
    address delegator,
    string memory valAddress
) external view returns (Delegation delegation);

/// Get list of validators with optional status filter
/// @param status Filter by validator status ("BOND_STATUS_BONDED", "BOND_STATUS_UNBONDING", "BOND_STATUS_UNBONDED", or "" for all)
/// @param nextKey Pagination key (use empty bytes for first page)
/// @return response List of validators with pagination info
function validators(
    string memory status,
    bytes memory nextKey
) external view returns (ValidatorsResponse memory response);

/// Get validator information for a given validator address
/// @param validatorAddress The validator address
/// @return validator Validator details
function validator(
    string memory validatorAddress
) external view returns (Validator memory validator);

/// Get delegations for a specific validator
/// @param validatorAddress The validator address
/// @param nextKey Pagination key
/// @return response Delegations response with pagination
function validatorDelegations(
    string memory validatorAddress,
    bytes memory nextKey
) external view returns (DelegationsResponse memory response);

/// Get unbonding delegations for a specific validator
/// @param validatorAddress The validator address
/// @param nextKey Pagination key
/// @return response Unbonding delegations response with pagination
function validatorUnbondingDelegations(
    string memory validatorAddress,
    bytes memory nextKey
) external view returns (UnbondingDelegationsResponse memory response);

/// Get unbonding delegation information for a delegator and validator pair
/// @param delegator The delegator's address
/// @param validatorAddress The validator address
/// @return unbondingDelegation Unbonding delegation details
function unbondingDelegation(
    address delegator,
    string memory validatorAddress
) external view returns (UnbondingDelegation memory unbondingDelegation);

/// Get all delegations for a delegator
/// @param delegator The delegator's address
/// @param nextKey Pagination key
/// @return response Delegations response with pagination
function delegatorDelegations(
    address delegator,
    bytes memory nextKey
) external view returns (DelegationsResponse memory response);

/// Get validator information for a delegator and validator pair
/// @param delegator The delegator's address
/// @param validatorAddress The validator address
/// @return validator Validator details
function delegatorValidator(
    address delegator,
    string memory validatorAddress
) external view returns (Validator memory validator);

/// Get all unbonding delegations for a delegator
/// @param delegator The delegator's address
/// @param nextKey Pagination key
/// @return response Unbonding delegations response with pagination
function delegatorUnbondingDelegations(
    address delegator,
    bytes memory nextKey
) external view returns (UnbondingDelegationsResponse memory response);

/// Get redelegations with optional filters
/// @param delegator The delegator's address (empty string for all)
/// @param srcValidator The source validator address (empty string for all)
/// @param dstValidator The destination validator address (empty string for all)
/// @param nextKey Pagination key
/// @return response Redelegations response with pagination
function redelegations(
    string memory delegator,
    string memory srcValidator,
    string memory dstValidator,
    bytes memory nextKey
) external view returns (RedelegationsResponse memory response);

/// Get all validators that a delegator has delegated to
/// @param delegator The delegator's address
/// @param nextKey Pagination key
/// @return response Validators response with pagination
function delegatorValidators(
    address delegator,
    bytes memory nextKey
) external view returns (ValidatorsResponse memory response);

/// Get historical info for a given height
/// @param height The block height
/// @return historicalInfo Historical validator set info
function historicalInfo(
    int64 height
) external view returns (HistoricalInfo memory historicalInfo);

/// Get staking pool information (bonded and unbonded token totals)
/// @return pool Pool details
function pool() external view returns (Pool memory pool);

/// Get staking module parameters
/// @return params Staking parameters
function params() external view returns (Params memory params);
```

<Warning>
  **Important Precision Note for `delegation()` Response:**

  The response contains two different precision scales:

  * `balance.amount`: **6 decimals** (usei) - the actual staked token amount
  * `delegation.shares`: **18 decimals** - the validator pool share amount
  * `delegation.decimals`: Always returns **18** (refers to shares precision, NOT balance)

  To convert to SEI for display:

  * Balance: `balance.amount / 1e6`
  * Shares: `delegation.shares / 1e18`
</Warning>

## Using the Precompile

### Setup

#### Prerequisites

Before getting started, ensure you have:

* **Node.js** (v18 or higher)
* **npm** or **yarn** package manager
* **EVM-compatible wallet**
* **SEI tokens** for gas and staking operations

#### Install Dependencies

Install the required packages for interacting with Sei precompiles:

```bash theme={"dark"}
# Install ethers.js for smart contract interactions
npm install ethers

# Install Sei EVM bindings for precompile addresses and ABIs
npm install @sei-js/precompiles@2.1.2
```

#### Import Precompile Components

```typescript theme={"dark"}
// Import Staking precompile address and ABI
// View the entire ABI here: https://github.com/sei-protocol/sei-chain/tree/main/precompiles/staking
import { STAKING_PRECOMPILE_ABI, STAKING_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';
import { ethers } from 'ethers';
```

<Info> **Precompile Address:** The staking precompile is deployed at `0x0000000000000000000000000000000000001005` </Info>

### Contract Initialization

Set up your provider, signer, and contract instance:

```typescript theme={"dark"}
// Using EVM-compatible wallet as the signer and provider
const provider = new ethers.BrowserProvider(window.ethereum);
await provider.send('eth_requestAccounts', []);
const signer = await provider.getSigner();

// Create a contract instance for the staking precompile
const staking = new ethers.Contract(STAKING_PRECOMPILE_ADDRESS, STAKING_PRECOMPILE_ABI, signer);
```

## Critical: Understanding Decimal Precision

One of the most important concepts to understand when working with the Sei staking precompile:

### Mixed Decimal Precision System

The staking precompile operates with **different decimal precision for different operations** due to bridging EVM and Cosmos standards:

| Function              | Input/Output           | Decimal Precision            | Example                                                |
| --------------------- | ---------------------- | ---------------------------- | ------------------------------------------------------ |
| **delegate()**        | msg.value (input)      | 18 decimals (wei)            | `ethers.parseUnits('1', 18)`                           |
| **undelegate()**      | amount (input)         | 6 decimals (uSEI)            | `1000000` (represents 1 SEI)                           |
| **redelegate()**      | amount (input)         | 6 decimals (uSEI)            | `500000` (represents 0.5 SEI)                          |
| **createValidator()** | msg.value (input)      | 18 decimals (wei)            | `ethers.parseUnits('1000', 18)`                        |
| **delegation()**      | return values (output) | Mixed (balance 6, shares 18) | `balance.amount=1000000`, `shares=1000000000000000000` |

<Warning>
  **Granularity for delegate():**

  `msg.value` is truncated to 6 decimals (uSEI). Always send amounts that are a multiple of `1e12` wei (last 12 digits zero) to avoid unintended truncation.

  * OK: `1_000_000_000_000` wei (`0.000001000000` SEI)
  * NOT OK: `1_000_000_000_001` wei (`0.000001000000000001` SEI)
  * NOT OK: `1_000_000_330_000` wei (`0.000001000000330000` SEI)

  Examples:

  * Delegate 10 SEI → `10000000000000000000` wei (18 decimals)
  * Undelegate 10 SEI → `10000000` uSEI (6 decimals)
</Warning>

### How This Works in Practice

**delegate() Function (Uses 18 decimals):**

* `delegate()` - accepts `msg.value` in wei (18 decimals)

**undelegate() and redelegate() Functions (Use 6 decimals):**

* `undelegate()` - expects amount parameter in 6 decimals (uSEI)
* `redelegate()` - expects amount parameter in 6 decimals (uSEI)

**Reading/Query Operations (Return 6 decimals):**

* `delegation()` - returns `balance.amount` in 6-decimal `uSEI` and `delegation.shares` in 18-decimal precision
* Rewards are handled by the **Distribution precompile**: `rewards()` query returns 18-decimal `DecCoins`, while withdrawn amounts (events) are 6-decimal `uSEI`

### Why This Mixed System Exists

1. **delegate() EVM Compatibility:** Uses standard 18-decimal wei format for EVM `msg.value` consistency
2. **Other Operations Cosmos Integration:** `undelegate()` and `redelegate()` use 6-decimal uSEI precision to match native Cosmos operations
3. **Staking Query Consistency:** Staking precompile query balances use 6-decimal `uSEI` (while `shares` is 18-decimal) for consistent reading

### Best Practice: Different Conversion for Different Functions

When working with user inputs, use the appropriate conversion for each function:

```typescript theme={"dark"}
// Best practice for handling user input amounts
function prepareAmountForDelegate(seiAmount: number): bigint {
  // For delegate() - convert to 18 decimals (wei)
  const fixedAmount = seiAmount.toFixed(6);
  return ethers.parseUnits(fixedAmount, 18);
}

function prepareAmountForUndelegateRedelegate(seiAmount: number): bigint {
  // For undelegate() and redelegate() - convert to 6 decimals (uSEI)
  return ethers.parseUnits(seiAmount.toFixed(6), 6);
}

// Usage examples
const userInputAmount = 1.23456789; // User enters this

// For delegate()
const delegateAmount = prepareAmountForDelegate(userInputAmount); // 18 decimals

// For undelegate() and redelegate()
const undelegateAmount = prepareAmountForUndelegateRedelegate(userInputAmount); // 6 decimals
```

### Normalization Guidelines (Clients and Indexers)

* **Normalize to a single unit** for analytics and reconciliation:
  * Display: convert to `SEI` (`wei / 1e18`, `uSEI / 1e6`)
  * Storage/aggregation: prefer `uSEI` (6 decimals)
* **Reconciling delegate vs. undelegate/redelegate/rewards:** convert delegate `msg.value` from wei to uSEI using integer division by `1e12` (floor), which matches the precompile’s internal truncation.
* **Enforce granularity at source:** construct `msg.value` as a multiple of `1e12` wei by formatting user input to 6 decimals prior to `parseUnits`.

```typescript theme={"dark"}
// Convert delegate msg.value (wei) to uSEI (6 decimals) for reconciliation
function weiToUseiForDelegate(valueWei: bigint): bigint {
  return valueWei / 1_000_000_000_000n; // floor to 6-decimal granularity
}

// Convert uSEI to SEI for display
function useiToSeiString(amountUsei: bigint): string {
  return ethers.formatUnits(amountUsei, 6);
}

// Ensure msg.value is a multiple of 1e12 wei (last 12 digits zero)
function normalizeWeiForDelegate(valueWei: bigint): bigint {
  return (valueWei / 1_000_000_000_000n) * 1_000_000_000_000n;
}
```

## Decimal Conversion Helpers

Use these helper functions to avoid precision errors:

```typescript theme={"dark"}
// Helper functions for amount conversion
class SeiAmountConverter {
  // Convert SEI to wei (18 decimals) - ONLY for delegate()
  static seiToWei(seiAmount: number): bigint {
    return ethers.parseUnits(seiAmount.toFixed(6), 18);
  }

  // Convert SEI to uSEI (6 decimals) - for undelegate() and redelegate()
  static seiToUsei(seiAmount: number): bigint {
    return ethers.parseUnits(seiAmount.toFixed(6), 6);
  }

  // Convert reading results (6 decimals) to SEI
  static useiToSei(useiAmount: number | bigint): number {
    return Number(useiAmount) / 1000000;
  }

  // Convert wei to SEI (18 decimals) - for delegate operations
  static weiToSei(weiAmount: bigint): number {
    return Number(ethers.formatEther(weiAmount));
  }
}

// Usage examples - Use correct decimals for each function
const delegateAmount = SeiAmountConverter.seiToWei(1); // For delegate() - 18 decimals
const undelegateAmount = SeiAmountConverter.seiToUsei(0.5); // For undelegate() - 6 decimals
const redelegateAmount = SeiAmountConverter.seiToUsei(2); // For redelegate() - 6 decimals
```

## Step-by-Step Guide: Using the Staking Precompile

### Delegate Tokens

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Sei validator address you want to delegate to (seivaloper... format)
    const validatorAddress = 'seivaloper1xyz...';

    const amount = 1; // Amount in SEI to delegate

    const amountTrimmed = amount.toFixed(6); // Ensure 6 decimal precision for msg.value

    // Delegate 1 SEI - Uses 18 decimals for msg.value
    const amountToDelegate = ethers.parseUnits(amountTrimmed, 18);

    const tx = await staking.delegate(validatorAddress, { value: amountToDelegate });

    const receipt = await tx.wait();
    console.log('Delegation completed:', receipt);
    ```
  </Tab>

  <Tab title="Solidity">
    ```typescript theme={"dark"}
    function delegateToValidator(string memory validatorAddress) external payable {
            require(msg.value > 0, "Amount must be greater than 0");
            
            bool success = ISTAKING(0x0000000000000000000000000000000000001005).delegate{value: msg.value}(validatorAddress);
            require(success, "Delegation failed");
            
            emit Delegated(msg.sender, validatorAddress, msg.value);
        }
    ```
  </Tab>
</Tabs>

### Undelegate Tokens

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Undelegate 1 SEI from a validator - Uses 6 decimals for amount parameter
    const validatorAddress = 'seivaloper1xyz...';

    const amount = 1; // Amount in SEI to undelegate
    const amountTrimmed = amount.toFixed(6); // Ensure 6 decimal precision
    const amountToUndelegate = ethers.parseUnits(amountTrimmed, 6); // 1 SEI in 6 decimals

    const tx = await staking.undelegate(validatorAddress, amountToUndelegate);
    const receipt = await tx.wait();

    console.log('Undelegation started:', receipt);
    ```
  </Tab>

  <Tab title="Solidity">
    ```typescript theme={"dark"}
    function undelegateFromValidator(
            string memory validatorAddress, 
            uint256 amount
        ) external {
            require(amount > 0, "Amount must be greater than 0");
            
            bool success = ISTAKING(0x0000000000000000000000000000000000001005).undelegate(validatorAddress, amount);
            require(success, "Undelegation failed");
            
            emit Undelegated(msg.sender, validatorAddress, amount);
        }
        
    ```
  </Tab>
</Tabs>

<Warning> **IMPORTANT:** Undelegated tokens are subject to a **21-day unbonding period** during which they cannot be transferred and do not earn rewards. </Warning>

### Redelegate Tokens

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Redelegate 0.5 SEI from one validator to another - Uses 6 decimals for amount parameter
    const srcValidator = 'seivaloper1abc...';
    const dstValidator = 'seivaloper1xyz...';

    const amount = 0.5; // Amount in SEI to redelegate
    const amountTrimmed = amount.toFixed(6); // Ensure 6 decimal precision
    const amountToRedelegate = ethers.parseUnits(amountTrimmed, 6); // 0.5 SEI in 6 decimals

    const tx = await staking.redelegate(srcValidator, dstValidator, amountToRedelegate);
    const receipt = await tx.wait();

    console.log('Redelegation completed:', receipt);
    ```
  </Tab>

  <Tab title="Solidity">
    ```typescript theme={"dark"}
    function redelegateBetweenValidators(
            string memory fromValidator,
            string memory toValidator,
            uint256 amount
        ) external {
            require(amount > 0, "Amount must be greater than 0");
            
            bool success = ISTAKING(0x0000000000000000000000000000000000001005).redelegate(fromValidator, toValidator, amount);
            require(success, "Redelegation failed");
            
            emit Redelegated(msg.sender, fromValidator, toValidator, amount);
        }
    ```
  </Tab>
</Tabs>

<Warning>
  **Redelegation restrictions:**

  * Maximum 7 redelegations per validator pair per 21-day period

  * After redelegating from Validator A to Validator B, you cannot redelegate from Validator B to another validator for 21 days

  * Each redelegation has its own 21-day cooldown period
</Warning>

### Query a Delegation

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Get your EVM address as the delegator
    const delegator = await signer.getAddress();

    try {
      const delegationInfo = await staking.delegation(delegator, validatorAddress);

      console.log('Delegation details:', {
        amount: delegationInfo.balance.amount.toString(),
        denom: delegationInfo.balance.denom,
        shares: delegationInfo.delegation.shares.toString(),
        decimals: delegationInfo.delegation.decimals.toString(),
        delegator_address: delegationInfo.delegation.delegator_address,
        validator_address: delegationInfo.delegation.validator_address
      });

      // Convert delegation amount from uSEI to SEI for readable display
      const delegationAmountSei = ethers.formatUnits(delegationInfo.balance.amount, 6);
      console.log('Delegation amount (SEI):', delegationAmountSei);
    } catch (error) {
      if (error.message.includes('delegation not found') || error.message.includes('no delegation')) {
        console.log('No delegation found for this validator');
      } else {
        console.error('Error querying delegation:', error);
      }
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```typescript theme={"dark"}
    function getDelegationInfo(
            address delegator,
            string memory validatorAddress
        ) external view returns (IStakingPrecompile.Delegation memory) {
            return ISTAKING(0x0000000000000000000000000000000000001005).delegation(delegator, validatorAddress);
        }
    ```
  </Tab>
</Tabs>

### Create a Validator

<Warning> Creating a validator requires significant SEI for self-delegation and proper validator infrastructure setup. Only proceed if you understand the responsibilities of running a validator node. </Warning>

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Ed25519 public key in hex format (64 characters)
    // This comes from your validator node's priv_validator_key.json
    const pubKeyHex = 'your_ed25519_public_key_hex_64_chars';
    const moniker = 'MyValidator';

    // Commission rates as decimal strings
    const commissionRate = '0.05'; // 5% commission
    const commissionMaxRate = '0.20'; // Maximum 20% commission
    const commissionMaxChangeRate = '0.01'; // Can change by 1% per day max

    // Minimum self-delegation in base units (uSEI)
    const minSelfDelegation = BigInt(1000000); // 1 SEI minimum

    // Initial self-delegation amount in wei (18 decimals)
    const selfDelegationAmount = ethers.parseUnits('1000', 18); // 1000 SEI

    const tx = await staking.createValidator(pubKeyHex, moniker, commissionRate, commissionMaxRate, commissionMaxChangeRate, minSelfDelegation, { value: selfDelegationAmount });

    const receipt = await tx.wait();
    console.log('Validator created:', receipt);
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    function createNewValidator(
        string memory pubKeyHex,
        string memory moniker,
        string memory commissionRate,
        string memory commissionMaxRate,
        string memory commissionMaxChangeRate,
        uint256 minSelfDelegation
    ) external payable {
        require(msg.value > 0, "Self-delegation required");

        bool success = STAKING.createValidator{value: msg.value}(
            pubKeyHex,
            moniker,
            commissionRate,
            commissionMaxRate,
            commissionMaxChangeRate,
            minSelfDelegation
        );
        require(success, "Validator creation failed");
    }
    ```
  </Tab>
</Tabs>

### Edit a Validator

```typescript theme={"dark"}
// Update validator parameters
const newMoniker = 'MyUpdatedValidator';
const newCommissionRate = '0.08'; // 8% commission (or "" to keep current)
const newMinSelfDelegation = BigInt(2000000); // 2 SEI (or 0 to keep current)

const tx = await staking.editValidator(newMoniker, newCommissionRate, newMinSelfDelegation);

const receipt = await tx.wait();
console.log('Validator updated:', receipt);
```

<Info>**Edit Validator Constraints:** - Commission can only be changed once every 24 hours - `minSelfDelegation` can only be increased, never decreased - Pass empty string `""` for `commissionRate` to keep current rate - Pass `0` for `minSelfDelegation` to keep current value</Info>

### Query Validators

```typescript theme={"dark"}
// Get all bonded validators
const bondedValidators = await staking.validators('BOND_STATUS_BONDED', '0x');
console.log('Bonded validators:', bondedValidators.validators);

// Get all validators (no filter)
const allValidators = await staking.validators('', '0x');
console.log('Total validators:', allValidators.validators.length);

// Pagination - get next page if available
if (allValidators.nextKey.length > 0) {
  const nextPage = await staking.validators('', allValidators.nextKey);
  console.log('Next page validators:', nextPage.validators);
}
```

### Query a Specific Validator

```typescript theme={"dark"}
const validatorAddress = 'seivaloper1xyz...';
const validatorInfo = await staking.validator(validatorAddress);

console.log('Validator details:', {
  moniker: validatorInfo.description,
  tokens: validatorInfo.tokens,
  commission: validatorInfo.commissionRate,
  jailed: validatorInfo.jailed,
  status: validatorInfo.status // 1=Unbonded, 2=Unbonding, 3=Bonded
});
```

### Query All Delegations for an Address

```typescript theme={"dark"}
const delegator = await signer.getAddress();

// Get all delegations for the connected wallet
const myDelegations = await staking.delegatorDelegations(delegator, '0x');

console.log('My delegations:');
for (const del of myDelegations.delegations) {
  const amountSei = ethers.formatUnits(del.balance.amount, 6);
  console.log(`  ${del.delegation.validator_address}: ${amountSei} SEI`);
}
```

### Query Unbonding Delegations

```typescript theme={"dark"}
const delegator = await signer.getAddress();

// Get all unbonding delegations
const unbonding = await staking.delegatorUnbondingDelegations(delegator, '0x');

console.log('Unbonding delegations:');
for (const ud of unbonding.unbondingDelegations) {
  console.log(`Validator: ${ud.validatorAddress}`);
  for (const entry of ud.entries) {
    const completionDate = new Date(Number(entry.completionTime) * 1000);
    console.log(`  Amount: ${entry.balance}, Completes: ${completionDate.toISOString()}`);
  }
}

// Query specific unbonding delegation
const validatorAddress = 'seivaloper1xyz...';
const specificUnbonding = await staking.unbondingDelegation(delegator, validatorAddress);
```

### Query Redelegations

```typescript theme={"dark"}
// Get all redelegations for a specific delegator
const delegatorAddress = await signer.getAddress();
const delegatorBech32 = 'sei1...'; // Convert EVM address to Bech32 format

const redelegations = await staking.redelegations(
  delegatorBech32, // delegator filter (empty string for all)
  '', // source validator filter (empty string for all)
  '', // destination validator filter (empty string for all)
  '0x' // pagination key
);

console.log('Active redelegations:');
for (const redel of redelegations.redelegations) {
  console.log(`From ${redel.validatorSrcAddress} to ${redel.validatorDstAddress}`);
  for (const entry of redel.entries) {
    const completionDate = new Date(Number(entry.completionTime) * 1000);
    console.log(`  Amount: ${entry.initialBalance}, Completes: ${completionDate.toISOString()}`);
  }
}
```

### Query Staking Pool and Parameters

```typescript theme={"dark"}
// Get staking pool totals
const pool = await staking.pool();
console.log('Staking Pool:', {
  bondedTokens: pool.bondedTokens,
  notBondedTokens: pool.notBondedTokens
});

// Get staking parameters
const params = await staking.params();
console.log('Staking Parameters:', {
  unbondingTime: `${Number(params.unbondingTime) / 86400} days`,
  maxValidators: params.maxValidators,
  bondDenom: params.bondDenom,
  minCommissionRate: params.minCommissionRate
});
```

### Query Historical Validator Info

```typescript theme={"dark"}
// Get validator set at a specific block height
const blockHeight = 1000000n;
const historicalInfo = await staking.historicalInfo(blockHeight);

console.log(`Validators at block ${blockHeight}:`);
for (const val of historicalInfo.validators) {
  console.log(`  ${val.operatorAddress}: ${val.tokens} tokens`);
}
```

## Advanced Usage Examples

### Portfolio Rebalancing

```typescript theme={"dark"}
async function rebalanceStaking(
  fromValidator: string,
  toValidator: string,
  amount: number // Amount in SEI
) {
  try {
    // Convert to 6 decimal precision for redelegate (uses 6 decimals)
    const amountIn6Decimals = ethers.parseUnits(amount.toFixed(6), 6);

    const tx = await staking.redelegate(fromValidator, toValidator, amountIn6Decimals);

    const receipt = await tx.wait();
    console.log('Rebalancing completed:', receipt);

    return receipt;
  } catch (error) {
    console.error('Rebalancing failed:', error);
    throw error;
  }
}
```

### Complete Integration Example

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    async function stakingExample() {
      // Setup
      const provider = new ethers.BrowserProvider(window.ethereum);
      await provider.send('eth_requestAccounts', []);
      const signer = await provider.getSigner();
      const staking = new ethers.Contract(STAKING_PRECOMPILE_ADDRESS, STAKING_PRECOMPILE_ABI, signer);

      const delegator = await signer.getAddress();
      const validatorAddress = 'seivaloper1xyz...';

      try {
        // 1. Check current delegation (with error handling)
        console.log('=== Checking Current Delegation ===');
        try {
          const currentDelegation = await staking.delegation(delegator, validatorAddress);
          const currentAmountSei = ethers.formatUnits(currentDelegation.balance.amount, 6);
          console.log('Current delegation amount (SEI):', currentAmountSei);
        } catch (error) {
          if (error.message.includes('delegation not found') || error.message.includes('no delegation')) {
            console.log('No existing delegation found for this validator');
          } else {
            throw error; // Re-throw if it's a different error
          }
        }

        // 2. Delegate additional tokens (uses 18 decimals)
        console.log('=== Delegating Tokens ===');
        const amount = 1;
        const amountTrimmed = amount.toFixed(6); // Ensure 6 decimal precision
        const amountToDelegate = ethers.parseUnits(amountTrimmed, 18);
        const delegateTx = await staking.delegate(validatorAddress, {
          value: amountToDelegate,
          gasLimit: 300000
        });
        await delegateTx.wait();
        console.log('Delegation successful:', delegateTx.hash);

        // 3. Check updated delegation
        const updatedDelegation = await staking.delegation(delegator, validatorAddress);
        const updatedAmountSei = ethers.formatUnits(updatedDelegation.balance.amount, 6);
        console.log('Updated delegation amount (SEI):', updatedAmountSei);

        // 4. Undelegate partial amount (uses 6 decimals)
        console.log('=== Undelegating Tokens ===');
        const undelegateAmount = ethers.parseUnits('0.5', 6); // 0.5 SEI in 6 decimals
        const undelegateTx = await staking.undelegate(validatorAddress, undelegateAmount);
        await undelegateTx.wait();
        console.log('Undelegation successful:', undelegateTx.hash);
      } catch (error) {
        console.error('Operation failed:', error);
      }
    }
    ```
  </Tab>

  <Tab title="Solidity">
    **Contract Example**

    ```solidity theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;

    interface IStakingPrecompile {
        // Events
        event Delegate(address indexed delegator, string validator, uint256 amount);
        event Redelegate(address indexed delegator, string srcValidator, string dstValidator, uint256 amount);
        event Undelegate(address indexed delegator, string validator, uint256 amount);
        event ValidatorCreated(address indexed creator, string validatorAddress, string moniker);
        event ValidatorEdited(address indexed editor, string validatorAddress, string moniker);

        // Structs
        struct Delegation {
            Balance balance;
            DelegationDetails delegation;
        }

        struct Balance {
            uint256 amount;
            string denom;
        }

        struct DelegationDetails {
            string delegator_address;
            uint256 shares;
            uint256 decimals;
            string validator_address;
        }

        struct Validator {
            string operatorAddress;
            string consensusPubkey;
            bool jailed;
            int32 status;
            string tokens;
            string delegatorShares;
            string description;
            int64 unbondingHeight;
            int64 unbondingTime;
            string commissionRate;
            string commissionMaxRate;
            string commissionMaxChangeRate;
            int64 commissionUpdateTime;
            string minSelfDelegation;
        }

        struct ValidatorsResponse {
            Validator[] validators;
            bytes nextKey;
        }

        struct Pool {
            string notBondedTokens;
            string bondedTokens;
        }

        struct Params {
            uint64 unbondingTime;
            uint32 maxValidators;
            uint32 maxEntries;
            uint32 historicalEntries;
            string bondDenom;
            string minCommissionRate;
            string maxVotingPowerRatio;
            string maxVotingPowerEnforcementThreshold;
        }

        // Transaction functions
        function delegate(string memory valAddress) payable external returns (bool success);

        function undelegate(
            string memory valAddress,
            uint256 amount
        ) external returns (bool success);

        function redelegate(
            string memory srcAddress,
            string memory dstAddress,
            uint256 amount
        ) external returns (bool success);

        function createValidator(
            string memory pubKeyHex,
            string memory moniker,
            string memory commissionRate,
            string memory commissionMaxRate,
            string memory commissionMaxChangeRate,
            uint256 minSelfDelegation
        ) external payable returns (bool success);

        function editValidator(
            string memory moniker,
            string memory commissionRate,
            uint256 minSelfDelegation
        ) external returns (bool success);

        // Query functions
        function delegation(
            address delegator,
            string memory valAddress
        ) external view returns (Delegation memory);

        function validators(
            string memory status,
            bytes memory nextKey
        ) external view returns (ValidatorsResponse memory);

        function validator(
            string memory validatorAddress
        ) external view returns (Validator memory);

        function pool() external view returns (Pool memory);

        function params() external view returns (Params memory);
    }

    contract StakingManager {
        IStakingPrecompile constant STAKING = IStakingPrecompile(0x0000000000000000000000000000000000001005);

        event Delegated(address indexed user, string validator, uint256 amount);
        event Undelegated(address indexed user, string validator, uint256 amount);
        event Redelegated(address indexed user, string fromValidator, string toValidator, uint256 amount);

        // Delegate user's SEI to a validator
        function delegateToValidator(string memory validatorAddress) external payable {
            require(msg.value > 0, "Amount must be greater than 0");

            bool success = STAKING.delegate{value: msg.value}(validatorAddress);
            require(success, "Delegation failed");

            emit Delegated(msg.sender, validatorAddress, msg.value);
        }

        // Undelegate SEI from a validator (amount in 6 decimal precision - uSEI)
        function undelegateFromValidator(
            string memory validatorAddress,
            uint256 amount
        ) external {
            require(amount > 0, "Amount must be greater than 0");

            bool success = STAKING.undelegate(validatorAddress, amount);
            require(success, "Undelegation failed");

            emit Undelegated(msg.sender, validatorAddress, amount);
        }

        // Redelegate SEI between validators (amount in 6 decimal precision - uSEI)
        function redelegateBetweenValidators(
            string memory fromValidator,
            string memory toValidator,
            uint256 amount
        ) external {
            require(amount > 0, "Amount must be greater than 0");

            bool success = STAKING.redelegate(fromValidator, toValidator, amount);
            require(success, "Redelegation failed");

            emit Redelegated(msg.sender, fromValidator, toValidator, amount);
        }

        // Get delegation info for a user and validator
        function getDelegationInfo(
            address delegator,
            string memory validatorAddress
        ) external view returns (IStakingPrecompile.Delegation memory) {
            return STAKING.delegation(delegator, validatorAddress);
        }

        // Helper function to convert SEI to uSEI (6 decimals)
        function seiToUsei(uint256 seiAmount) public pure returns (uint256) {
            return seiAmount * 1e6;
        }

        // Helper function to convert uSEI to SEI
        function useiToSei(uint256 useiAmount) public pure returns (uint256) {
            return useiAmount / 1e6;
        }
    }
    ```

    <Info> **Note:** This is a simplified example for demonstration purposes. The above example works such that when someone delegates through the above contract, the delegation will be recorded under the above contract address and not the user. So maintain correct mapping in the contract for tracking user delegations </Info>

    **Client Integration Example**

    ```javascript theme={"dark"}
    import { network } from 'hardhat';

    // Hardhat 3 exposes ethers through a network connection rather than a global import
    const { ethers } = await network.create();

    async function main() {
      const [deployer] = await ethers.getSigners();
      console.log('Deploying contracts with the account:', deployer.address);

      const balance = await deployer.provider.getBalance(deployer.address);
      console.log('Account balance:', ethers.formatEther(balance));

      const StakingManager = await ethers.getContractFactory('StakingManager');
      console.log('Deploying StakingManager...');
      const stakingManager = await StakingManager.deploy();

      await stakingManager.waitForDeployment();
      console.log('StakingManager deployed to:', await stakingManager.getAddress());

      const validatorAddress = 'seival......123';

      const amount = 1;
      const trimmedAmount = amount.toFixed(6);
      const formattedAmount = ethers.parseEther(trimmedAmount.toString());

      const delegate = await stakingManager.delegateToValidator(validatorAddress, { value: formattedAmount });

      await delegate.wait();
      console.log('Delegation transaction hash:', delegate.hash);

      // Use deployer address for querying delegation
      const queryDelegation = await stakingManager.getDelegationInfo(deployer.address, validatorAddress);
      console.log('Delegation Info:', queryDelegation);

      const undelegateAmount = ethers.parseUnits(trimmedAmount.toString(), 6);
      const undelegate = await stakingManager.undelegateFromValidator(validatorAddress, undelegateAmount);

      await undelegate.wait();
      console.log('Undelegation transaction hash:', undelegate.hash);

      const redelegate = await stakingManager.redelegateBetweenValidators(
        validatorAddress,
        'seival.....123', // Replace with the new validator address
        undelegateAmount
      );

      await redelegate.wait();
      console.log('Redelegation transaction hash:', redelegate.hash);
    }

    main().catch((error) => {
      console.error(error);
      process.exitCode = 1;
    });
    ```
  </Tab>
</Tabs>

## Security Considerations & Risks

### Unbonding Period

* **21-day lock:** Undelegated tokens cannot be transferred or earn rewards for 21 days
* **No exceptions:** This cannot be canceled once initiated
* **Planning:** Consider this when managing liquidity needs

### Validator Selection Criteria

* **Commission Rate:** Lower commission means more rewards for you (typically 1-10%)
* **Uptime:** Check for validators with high uptime (99%+)

### Redelegation Complexity

* **7-transaction limit:** You can only redelegate from the same validator to the same destination validator 7 times in 21 days
* **Serial blocking:** After redelegating A→B, you cannot redelegate B→C for 21 days
* **Each redelegation starts its own 21-day timer**

## Troubleshooting

### Common Issues and Solutions

#### Gas-Related Issues

```typescript theme={"dark"}
// Set appropriate gas limits for different operations
const delegateTx = await staking.delegate(validatorAddress, {
  value: amount,
  gasLimit: 300000
});
```

### Error Code Reference

| Error                            | Cause                          | Solution                                 |
| -------------------------------- | ------------------------------ | ---------------------------------------- |
| `insufficient funds`             | Not enough SEI for operation   | Check balance and reduce amount          |
| `validator does not exist`       | Invalid validator address      | Verify validator address format          |
| `invalid delegation amount`      | Amount formatting issue        | Use correct decimal precision            |
| `commission rate too high`       | Commission above max rate      | Lower commission rate                    |
| `commission change too frequent` | Changing commission within 24h | Wait 24 hours between changes            |
| `self delegation too low`        | Below minimum self-delegation  | Increase self-delegation amount          |
| `too many redelegations`         | Exceeded 7 redelegation limit  | Wait for earliest redelegation to expire |

## FAQ: Precision and Normalization

* **What are the base units and precision standards defined for SEI across operations?**
  * `delegate()`: accepts `msg.value` in wei (18 decimals), but is internally truncated to 6-decimal `uSEI`. Effective granularity is 1 uSEI = `1e12` wei.
  * `undelegate()` / `redelegate()`: amounts use 6-decimal `uSEI`.
  * Staking queries: balances are 6-decimal `uSEI` (and shares are 18-decimal). Distribution `rewards()` query returns 18-decimal `DecCoins`, but withdrawn amounts are 6-decimal `uSEI`.
* **Should applications normalize between 18 and 6 decimals?**
  * Yes. For reconciliation, convert delegate `wei` to `uSEI` via integer division by `1e12` (floor). For display, convert to SEI (`wei → /1e18`, `uSEI → /1e6`).
* **Is this behavior consistent and intentional?**
  * Yes. This is intentional and not planned to change. Delegation uses EVM-native `msg.value` (18 decimals), while staking operations are executed in the Cosmos staking module, which uses 6-decimal `uSEI`.
* **Why multiple decimal precisions on one chain?**
  * To bridge EVM conventions (18-decimal `msg.value`) with the Cosmos staking module’s native 6-decimal accounting while keeping queries and non-`delegate()` writes consistent at 6 decimals.

## Important Notes

<Info> Remember the key rule: delegate() uses 18 decimals, undelegate()/redelegate() use 6 decimals, delegation() returns 6 decimals! </Info>

### Decimal Precision

* **delegate()** uses 18 decimals (wei) for msg.value
* **undelegate() and redelegate()** use 6 decimals (uSEI) for amount parameters
* **Query results** return amounts in 6 decimal precision
* **Best practice:** Use appropriate conversion functions for each operation
* **Rewards/claims (Distribution precompile):** `rewards()` query returns 18-decimal `DecCoins`; withdrawn amounts (events) are 6-decimal `uSEI`
* **Granularity:** `delegate()` `msg.value` must be a multiple of `1e12` wei (last 12 digits zero) because the precompile truncates to 6 decimals internally

### Validator Addresses

* Use valid Sei validator addresses with `seivaloper1...` prefix
* These are Cosmos-format addresses, not EVM addresses

### Staking Risks

* **Unbonding:** 21-day waiting period for undelegated tokens
* **Redelegation limits:** Complex rules around frequency and serial operations

### Commission and Rewards

* Validators keep a commission percentage
* Rewards are distributed proportionally to delegation amounts
* Choose validators wisely based on commission, uptime, and governance participation

---

URL: https://docs.sei.io/evm/precompiles/p256-precompile

# P256 Precompile

> Use the P256 precompile to verify secp256r1/P-256 signatures directly from EVM smart contracts, enabling efficient passkey-based authentication and signature verification.

**Address**: `0x0000000000000000000000000000000000001011`

This is the implementation of [RIP-7212](https://github.com/ethereum/RIPs/blob/master/RIPS/rip-7212.md), which provides a precompiled contract for verifying signatures in the `secp256r1` or `P-256` elliptic curve.

## Overview

The P256 precompile enables efficient signature verification for the `secp256r1` curve, which is widely used in modern security systems including:

* Apple's Secure Enclave
* WebAuthn/FIDO2
* Android Keychain
* Various hardware security modules (HSMs)
* PassKeys

This precompile implementation is significantly more gas efficient (up to 60x) compared to Solidity-based implementations.

## Interface

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

address constant P256VERIFY_PRECOMPILE_ADDRESS = 0x0000000000000000000000000000000000001011;

IP256VERIFY constant P256VERIFY_CONTRACT = IP256VERIFY(P256VERIFY_PRECOMPILE_ADDRESS);

interface IP256VERIFY {
    function verify(
        bytes memory signature
    ) external view returns (bytes memory response);
}
```

## Implementation Library

Here's a complete implementation of the P256 library that provides a convenient wrapper around the precompile:

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "./ECDSA.sol";
import "./P256Verify.sol";

/// @title P256
/// @author klkvr <https://github.com/klkvr>
/// @author jxom <https://github.com/jxom>
/// @notice Wrapper function to abstract low level details of call to the P256
///         signature verification precompile as defined in EIP-7212, see
///         <https://eips.ethereum.org/EIPS/eip-7212>.
library P256 {
    /// @notice P256VERIFY operation
    /// @param digest 32 bytes of the signed data hash
    /// @param signature Signature of the signer
    /// @param publicKey Public key of the signer
    /// @return success Represents if the operation was successful
    function verify(bytes32 digest, ECDSA.Signature memory signature, ECDSA.PublicKey memory publicKey)
        internal
        view
        returns (bool)
    {
        bytes memory input = abi.encode(digest, signature.r, signature.s, publicKey.x, publicKey.y);
        // On invalid signatures the precompile returns no data, which would
        // make a high-level interface call revert when decoding the `bytes`
        // return value. Use a low-level staticcall and treat empty return
        // data as "invalid signature" instead.
        (bool success, bytes memory output) = P256VERIFY_PRECOMPILE_ADDRESS.staticcall(
            abi.encodeWithSelector(IP256VERIFY.verify.selector, input)
        );

        return success && output.length > 0;
    }
}
```

## Basic Usage

### Using the P256 Library

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "./P256.sol";
import "./ECDSA.sol";

contract P256Example {
    using P256 for bytes32;

    function verifySignature(
        bytes32 messageHash,
        ECDSA.Signature memory signature,
        ECDSA.PublicKey memory publicKey
    ) public view returns (bool) {
        return P256.verify(messageHash, signature, publicKey);
    }
}
```

### Direct Precompile Usage

For more control, you can call the precompile directly:

```solidity theme={"dark"}
pragma solidity ^0.8.0;

interface IP256Verify {
    function verify(bytes calldata input) external view returns (bytes memory response);
}

contract P256Verifier {
    IP256Verify constant P256_PRECOMPILE = IP256Verify(0x0000000000000000000000000000000000001011);

    function verifySignature(
        bytes32 messageHash,
        bytes32 r,
        bytes32 s,
        bytes32 publicKeyX,
        bytes32 publicKeyY
    ) external view returns (bool) {
        bytes memory input = abi.encodePacked(
            messageHash,
            r,
            s,
            publicKeyX,
            publicKeyY
        );

        // Success returns a non-empty (ABI-encoded 32-byte) value; invalid
        // signatures return no data, which would revert a high-level call.
        (bool ok, bytes memory output) = address(P256_PRECOMPILE).staticcall(
            abi.encodeWithSelector(IP256Verify.verify.selector, input)
        );
        return ok && output.length > 0;
    }
}
```

## Signature Format

The signature verification requires the following components:

* `digest`: 32 bytes of the signed data hash
* `signature`: Contains the r and s components of the signature
* `publicKey`: Contains the x and y coordinates of the public key

The precompile expects these components to be encoded in a specific format:

* First 32 bytes: message hash
* Next 32 bytes: `r` component of the signature
* Next 32 bytes: `s` component of the signature
* Next 32 bytes: `x` coordinate of the public key
* Next 32 bytes: `y` coordinate of the public key

Total length: 160 bytes

## Gas Costs

The precompile is highly gas efficient compared to Solidity implementations. The exact gas cost per byte of verified data is set to `GasCostPerByte = 300`, which gives us:

* **Total Cost**: 300 × 160 = **48,000 gas** per verification
* **Efficiency**: Up to 60x more efficient than pure Solidity implementations

## Real-World Use Cases

### WebAuthn/PassKeys Authentication

```solidity theme={"dark"}
pragma solidity ^0.8.0;

contract WebAuthnAuth {
    IP256Verify constant P256_PRECOMPILE = IP256Verify(0x0000000000000000000000000000000000001011);

    struct PublicKey {
        bytes32 x;
        bytes32 y;
    }

    mapping(address => PublicKey) public userKeys;

    function registerPasskey(
        bytes32 keyX,
        bytes32 keyY
    ) external {
        userKeys[msg.sender] = PublicKey(keyX, keyY);
    }

    function authenticateWithPasskey(
        bytes32 challengeHash,
        bytes32 r,
        bytes32 s
    ) external view returns (bool) {
        PublicKey memory userKey = userKeys[msg.sender];
        require(userKey.x != 0 && userKey.y != 0, "No passkey registered");

        bytes memory input = abi.encodePacked(
            challengeHash,
            r,
            s,
            userKey.x,
            userKey.y
        );

        (bool ok, bytes memory output) = address(P256_PRECOMPILE).staticcall(
            abi.encodeWithSelector(IP256Verify.verify.selector, input)
        );
        return ok && output.length > 0;
    }
}
```

### Apple Secure Enclave Integration

```solidity theme={"dark"}
contract SecureEnclaveAuth {
    IP256Verify constant P256_PRECOMPILE = IP256Verify(0x0000000000000000000000000000000000001011);

    event SecureOperation(address indexed user, bytes32 indexed operationHash);

    function executeSecureOperation(
        bytes32 operationHash,
        bytes32 r,
        bytes32 s,
        bytes32 enclaveKeyX,
        bytes32 enclaveKeyY
    ) external {
        require(
            verifyEnclaveSignature(operationHash, r, s, enclaveKeyX, enclaveKeyY),
            "Invalid Secure Enclave signature"
        );

        emit SecureOperation(msg.sender, operationHash);
    }

    function verifyEnclaveSignature(
        bytes32 hash,
        bytes32 r,
        bytes32 s,
        bytes32 x,
        bytes32 y
    ) internal view returns (bool) {
        bytes memory input = abi.encodePacked(hash, r, s, x, y);
        (bool ok, bytes memory output) = address(P256_PRECOMPILE).staticcall(
            abi.encodeWithSelector(IP256Verify.verify.selector, input)
        );
        return ok && output.length > 0;
    }
}
```

### Multi-Signature with Hardware Keys

```solidity theme={"dark"}
contract HardwareMultiSig {
    IP256Verify constant P256_PRECOMPILE = IP256Verify(0x0000000000000000000000000000000000001011);

    struct Signature {
        bytes32 r;
        bytes32 s;
    }

    struct PublicKey {
        bytes32 x;
        bytes32 y;
    }

    function verifyMultipleHardwareKeys(
        bytes32 messageHash,
        Signature[] calldata signatures,
        PublicKey[] calldata publicKeys,
        uint256 threshold
    ) external view returns (bool) {
        require(signatures.length == publicKeys.length, "Mismatched arrays");
        require(threshold <= signatures.length, "Invalid threshold");

        uint256 validSignatures = 0;

        for (uint i = 0; i < signatures.length; i++) {
            bytes memory input = abi.encodePacked(
                messageHash,
                signatures[i].r,
                signatures[i].s,
                publicKeys[i].x,
                publicKeys[i].y
            );

            (bool ok, bytes memory output) = address(P256_PRECOMPILE).staticcall(
                abi.encodeWithSelector(IP256Verify.verify.selector, input)
            );
            if (ok && output.length > 0) {
                validSignatures++;
            }
        }

        return validSignatures >= threshold;
    }
}
```

## Security Considerations

<Warning>**Important**: Always validate public keys and signature components before verification to prevent invalid curve point attacks.</Warning>

### Public Key Validation

```solidity theme={"dark"}
function isValidPublicKey(bytes32 x, bytes32 y) internal pure returns (bool) {
    // Ensure point is not at infinity
    if (x == 0 && y == 0) return false;

    // Additional validation should be performed for production use
    // The precompile will reject invalid curve points
    return true;
}
```

### Signature Malleability

P256 signatures can be malleable. If your application requires unique signatures, implement additional checks:

```solidity theme={"dark"}
function isLowS(bytes32 s) internal pure returns (bool) {
    // Check if s is in the lower half of the curve order (n / 2, where n is
    // the P-256 group order). This prevents signature malleability.
    return uint256(s) <= 0x7FFFFFFF800000007FFFFFFFFFFFFFFFDE737D56D38BCF4279DCE5617E3192A8;
}
```

## JavaScript Integration

### Preparing Input Data

```javascript theme={"dark"}
// Example: Preparing P256 verification input (ethers v6)
function prepareP256Input(messageHash, signature, publicKey) {
  // Ensure all components are 32 bytes
  const hash = ethers.zeroPadValue(messageHash, 32);
  const r = ethers.zeroPadValue(signature.r, 32);
  const s = ethers.zeroPadValue(signature.s, 32);
  const x = ethers.zeroPadValue(publicKey.x, 32);
  const y = ethers.zeroPadValue(publicKey.y, 32);

  // Concatenate all components
  return ethers.concat([hash, r, s, x, y]);
}

// Usage with ethers.js
const P256_VERIFY_ADDRESS = '0x0000000000000000000000000000000000001011';
const P256_VERIFY_ABI = ['function verify(bytes input) view returns (bytes response)'];

async function verifyP256Signature(provider, messageHash, signature, publicKey) {
  const precompile = new ethers.Contract(P256_VERIFY_ADDRESS, P256_VERIFY_ABI, provider);
  const input = prepareP256Input(messageHash, signature, publicKey);
  try {
    const result = await precompile.verify(input);
    // Success returns 32 bytes ending in 0x01
    return result === '0x0000000000000000000000000000000000000000000000000000000000000001';
  } catch (err) {
    // Invalid signatures return no data, which ethers cannot decode as `bytes`
    // (BAD_DATA) — treat that as a failed verification.
    return false;
  }
}
```

## Error Handling

The P256 precompile returns no data on failure. Because `verify` is declared as returning `bytes`, a high-level Solidity interface call reverts when it tries to decode that empty return data — always use a low-level `staticcall` (as in the examples above) so invalid signatures resolve to `false` instead of reverting. Common failure cases include:

1. **Invalid Input Length**: Input must be exactly 160 bytes
2. **Invalid Public Key**: Point not on the P256 curve
3. **Invalid Signature**: r or s values out of valid range
4. **Verification Failure**: Signature doesn't match message and public key

```solidity theme={"dark"}
function safeVerifyP256(
    bytes32 messageHash,
    bytes32 r,
    bytes32 s,
    bytes32 publicKeyX,
    bytes32 publicKeyY
) internal view returns (bool success, string memory error) {
    // Validate inputs
    if (!isValidPublicKey(publicKeyX, publicKeyY)) {
        return (false, "Invalid public key");
    }

    if (r == 0 || s == 0) {
        return (false, "Invalid signature components");
    }

    // Prepare input and verify
    bytes memory input = abi.encodePacked(
        messageHash, r, s, publicKeyX, publicKeyY
    );

    (bool ok, bytes memory output) = address(P256_PRECOMPILE).staticcall(
        abi.encodeWithSelector(IP256Verify.verify.selector, input)
    );
    bool verified = ok && output.length > 0;
    return (verified, verified ? "" : "Verification failed");
}
```

## Testing

### Unit Tests

```solidity theme={"dark"}
contract P256Test {
    IP256Verify constant P256_PRECOMPILE = IP256Verify(0x0000000000000000000000000000000000001011);

    function testValidSignature() public {
        // Test with known valid P256 signature
        bytes32 messageHash = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef;
        // Use actual test vectors for production tests
        bytes32 r = 0x...; // Valid r component
        bytes32 s = 0x...; // Valid s component
        bytes32 x = 0x...; // Valid public key x
        bytes32 y = 0x...; // Valid public key y

        bytes memory input = abi.encodePacked(messageHash, r, s, x, y);
        (bool ok, bytes memory output) = address(P256_PRECOMPILE).staticcall(
            abi.encodeWithSelector(IP256Verify.verify.selector, input)
        );

        assert(ok && output.length > 0);
    }
}
```

## Performance Considerations

* **Gas Efficiency**: 48,000 gas per verification vs 2M+ gas for Solidity implementations
* **Batch Operations**: Consider batching multiple verifications in a single transaction
* **Caching**: Cache public keys on-chain to reduce calldata for repeated verifications
* **Hardware Integration**: Particularly efficient for applications using hardware-backed keys

<Info>For more information about the P256 precompile implementation, visit the [Sei Chain repository](https://github.com/sei-protocol/sei-chain/tree/main/precompiles/p256).</Info>

---

URL: https://docs.sei.io/evm/precompiles/cosmwasm-precompiles/example-usage

# Example Usage

> Learn how to interact with Sei precompiles using ethers.js to query and execute CosmWasm contracts from the EVM.

<Info>
  Per [Proposal 115](https://www.mintscan.io/sei/proposals/115), no new CosmWasm contracts can be deployed on Sei. The examples below apply to **pre-existing CosmWasm contracts** only — `instantiate()` will revert. Separately, [Proposal 116](https://www.mintscan.io/sei/proposals/116) disables inbound IBC transfers as part of the [SIP-03](/learn/sip-03-migration) migration.
</Info>

The Sei precompiles can be used like any standard smart contract on the EVM. For
example, using [ethers.js](https://docs.ethers.org/v6/), you can query and
execute actions on an existing CosmWasm contract as follows:

## Setup

To install `ethers`, run the following command in your project directory
terminal:

```bash theme={"dark"}
npm install ethers
npm install @sei-js/evm
```

Next, you'll need to use one of the precompiles in `EVM Precompiles` section. In
this example, we're going to be using the [wasmd precompile](/evm/precompiles/cosmwasm-precompiles/cosmwasm):

```typescript theme={"dark"}
// Import Wasm precompile address and ABI
// View the entire ABI here: https://github.com/sei-protocol/sei-chain/tree/evm/precompiles/wasmd
import { WASM_PRECOMPILE_ABI, WASM_PRECOMPILE_ADDRESS } from '@sei-js/evm';
```

## Using the contract

Next, we'll set up a provider and contract to interact with the blockchain:

```typescript theme={"dark"}
import { ethers, toUtf8Bytes, toUtf8String } from 'ethers';

// Using MetaMask as the signer and provider
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();

// Create a contract with the signer
const contract = new ethers.Contract(WASM_PRECOMPILE_ADDRESS, WASM_PRECOMPILE_ABI, signer);
```

#### Querying & Executing a CosmWasm Contract

Once you have the contract, you can query and execute messages to any CosmWasm
smart contract. In the below example we assume there is a counter contract with a `get_count` function

```typescript theme={"dark"}
// Replace with your contract
const COUNTER_CONTRACT_ADDRESS = 'sei1eyf...xff';

// Query to get the count on the counter contract (replace with function from your ABI)
const queryMsg = { get_count: {} };
const queryResponse = await contract.query(COUNTER_CONTRACT_ADDRESS, toUtf8Bytes(JSON.stringify(queryMsg)));
console.log(toUtf8String(queryResponse));

// Execute message to increment the count on the contract. (Replace with any function from your ABI)
// No funds are attached since the increment method does not require sei. (Your ABI may require funds)
const executeMsg = { increment: {} };
const executeResponse = await contract.execute(
  COUNTER_CONTRACT_ADDRESS,
  toUtf8Bytes(JSON.stringify(executeMsg)),
  toUtf8Bytes(JSON.stringify([])) // Used for sending funds if needed
);

// Wait for the transaction to be confirmed
await executeResponse.wait();
console.log(executeResponse);
```

### Executing a payable function

In this example, we execute the 'donate' method on our contract. This is similar
to the `increment` method, but also receives funds from the user and stores it
in the contract.

```typescript theme={"dark"}
// Execute a message to donate to the contract.
const executeMsg = { donate: {} };

// Funds are attached via overrides. This example is specific to ethers.js
const overrides = {
  value: ethers.parseEther('3.2') // Sending 3.2 sei
};
const executeResponse = await contract.execute(
  COUNTER_CONTRACT_ADDRESS,
  toUtf8Bytes(JSON.stringify(executeMsg)),
  toUtf8Bytes(JSON.stringify([{ denom: 'uusdc', amount: '100' }])), // Also send 100 uusdc
  overrides
);

await executeResponse.wait();
const receipt = await provider.getTransactionReceipt(executeResponse.hash);
```

For payable contracts, Sei amounts have to be sent directly to the contract
while other denoms should use the `coins` field.

---

URL: https://docs.sei.io/evm/precompiles/cosmwasm-precompiles/addr

# Address Precompile

> Learn how to interact with Sei's Addr precompile through ethers.js and Solidity, enabling address association and cross-chain address mapping directly in your EVM smart contracts for seamless user experiences.

**Address:** `0x0000000000000000000000000000000000001004`

The Sei Address precompile allows EVM applications to interact directly with Sei's address association system through standard smart contract calls. This enables querying and creating mappings between EVM addresses and their corresponding Cosmos addresses, enabling seamless cross-chain address management without needing separate Cosmos SDK integration.

<Info> **What is a precompile?** A precompile is a special smart contract deployed at a fixed address by the Sei protocol itself, that exposes custom native chain logic to EVM-based applications. It acts like a regular contract from the EVM's perspective, but executes privileged, low-level logic efficiently. </Info>

## How Does the Address Precompile Work?

The Address precompile at address `0x0000000000000000000000000000000000001004` exposes functions like `associate()`, `associatePubKey()`, `getSeiAddr()`, and `getEvmAddr()`.

* **Direct Integration:** EVM contracts and dApps can call address association functions like any other smart contract method.
* **Native Execution:** Operations are executed at the Cosmos SDK level for maximum efficiency and security.
* **Seamless Bridge:** No need for separate wallet integrations or complex cross-chain interactions.

## Use Cases

* **Cross-Chain Identity:** Link EVM and Cosmos addresses for unified user experiences across both execution environments.
* **Address Resolution:** Build applications that can seamlessly work with both EVM and Cosmos address formats.
* **Wallet Integration:** Enable users to associate their addresses once and use both EVM and native Sei functionality.
* **DeFi Applications:** Create protocols that can interact with users regardless of their preferred address format.

## What You'll Learn in This Guide

By the end of this guide, you'll be able to:

* **Integrate Address Operations** - Call association and lookup functions directly from your EVM contracts and dApps
* **Handle Signature Verification** - Master the signature format requirements for secure address association
* **Manage Address Mappings** - Query and validate address relationships between EVM and Cosmos formats
* **Build Cross-Chain Tools** - Implement unified address management for applications spanning both execution environments
* **Navigate Association Requirements** - Understand when and how address association occurs automatically vs. manually

## Functions

The Address precompile exposes the following functions:

### Transaction Functions

```solidity theme={"dark"}
/// Associates an account given it's signature of any custom message.
/// @param v The v component of the signature.
/// @param r The r component of the signature.
/// @param s The s component of the signature.
/// @param customMessage A custom message that was signed by the address to be associated.
/// @return seiAddr The associated Sei address.
/// @return evmAddr The associated EVM address.
function associate(
    string memory v,
    string memory r,
    string memory s,
    string memory customMessage
) external returns (string memory seiAddr, address evmAddr);

/// Associates an account given it's compressed pubkey in hex format (excluding the '0x')
/// @param pubKeyHex The Hex-encoded compressed pubkey of the account to be associated, excluding the '0x'
/// @return seiAddr The associated Sei address.
/// @return evmAddr The associated EVM address.
function associatePubKey(
    string memory pubKeyHex
) external returns (string memory seiAddr, address evmAddr);
```

### Query Functions

```solidity theme={"dark"}
/// Queries the corresponding Sei Address for some EVM address.
/// @param addr The EVM Address for which we want the corresponding Sei address.
/// @return response The corresponding Sei address.
function getSeiAddr(
    address addr
) external view returns (string memory response);

/// Queries the corresponding EVM Address for some Sei address.
/// @param addr The Sei Address for which we want the corresponding EVM address.
/// @return response The corresponding EVM address.
function getEvmAddr(
    string memory addr
) external view returns (address response);
```

## Using the Precompile

### Setup

#### Prerequisites

Before getting started, ensure you have:

* **Node.js** (v18 or higher)
* **npm** or **yarn** package manager
* **EVM-compatible wallet**
* **SEI tokens** for gas
* **Hardhat** development environment set up

#### Install Dependencies

Install the required packages for interacting with Sei precompiles:

```bash theme={"dark"}
# Initiate a Hardhat 3 project (choose "Hardhat 3" and the Mocha + Ethers.js TypeScript setup)
npx hardhat --init

# Install ethers.js for smart contract interactions
npm install ethers

# Install Sei EVM bindings for precompile addresses and ABIs
npm install @sei-js/precompiles@2.1.2
```

#### Setup Hardhat Environment

Create a `hardhat.config.ts` file with the following content:

```typescript theme={"dark"}
import { defineConfig, configVariable } from 'hardhat/config';
import hardhatToolboxMochaEthers from '@nomicfoundation/hardhat-toolbox-mocha-ethers';

export default defineConfig({
  solidity: '0.8.28',
  networks: {
    sei: {
      type: 'http',
      chainId: 1329,
      url: 'https://evm-rpc.sei-apis.com',
      accounts: [configVariable('PRIVATE_KEY')]
    }
  },
  plugins: [hardhatToolboxMochaEthers]
});
```

Store your private key in Hardhat's encrypted keystore (no plaintext `.env` file needed):

```bash theme={"dark"}
npx hardhat keystore set PRIVATE_KEY
```

#### Import Precompile Components

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Import Address precompile address and ABI
    // View the entire ABI here: https://github.com/sei-protocol/sei-chain/tree/main/precompiles/addr
    import { ADDRESS_PRECOMPILE_ABI, ADDRESS_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';
    import { ethers } from 'ethers';
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;

    interface IAddrPrecompile {
    function associate(
    string memory v,
    string memory r,
    string memory s,
    string memory customMessage
    ) external returns (string memory seiAddr, address evmAddr);

    function associatePubKey(
    string memory pubKeyHex
    ) external returns (string memory seiAddr, address evmAddr);

    function getSeiAddr(address addr) external view returns (string memory response);

    function getEvmAddr(string memory addr) external view returns (address response);

    }

    ```
  </Tab>
</Tabs>

<Info> **Precompile Address:** The address precompile is deployed at `0x0000000000000000000000000000000000001004` </Info>

### Contract Initialization

<Tabs>
  <Tab title="JavaScript">
    Set up your provider, signer, and contract instance:

    ```typescript theme={"dark"}
    // Using EVM-compatible wallet as the signer and provider
    const provider = new ethers.BrowserProvider(window.ethereum);
    await provider.send('eth_requestAccounts', []);
    const signer = await provider.getSigner();

    // Create a contract instance for the addr precompile
    const addr = new ethers.Contract(ADDRESS_PRECOMPILE_ADDRESS, ADDRESS_PRECOMPILE_ABI, signer);
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    // Initialize the contract instance in your Solidity code
    contract CrossChainAddressManager {
      IAddrPrecompile constant ADDR = IAddrPrecompile(0x0000000000000000000000000000000000001004);
    }
    ```
  </Tab>
</Tabs>

#### When Does Association Happen?

Address association between EVM and Cosmos addresses occurs automatically in most cases:

| Method                 | Trigger                     | Requirements                 |
| ---------------------- | --------------------------- | ---------------------------- |
| **Automatic**          | First transaction broadcast | Wallet signs any transaction |
| **Manual (Signature)** | associate() function        | Custom message signature     |
| **Manual (PubKey)**    | associatePubKey() function  | Compressed public key        |

### How Association Works

**Automatic Association:**

* Occurs when a wallet first signs and broadcasts any transaction on Sei
* No additional steps required for most users
* Association is permanent once created

**Manual Association:**

* Use `associate()` for signature-based association
* Use `associatePubKey()` for public key-based association
* Useful for advanced applications or when automatic association hasn't occurred

### Address Format Requirements

**EVM Addresses:**

* Standard Ethereum format: `0x1234...` (20 bytes, 40 hex characters)
* Case-insensitive but typically lowercase

**Sei Addresses:**

* Cosmos format with `sei1...` prefix for regular addresses
* Validator addresses use `seivaloper1...` prefix
* Bech32 encoding format

## Step-by-Step Guide: Using the Address Precompile

### Associate Address with Signature

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Associate addresses using a custom message signature
    const message = `Associate my addresses - ${Date.now()}`;

    try {
      // Get signature from user's wallet
      const signature = await signer.signMessage(message);
      const sig = ethers.Signature.from(signature);

      // Reconstruct the EIP-191 prefixed message that signMessage() actually signed:
      // "\x19Ethereum Signed Message:\n" + message length + message
      const customMessage = `\x19Ethereum Signed Message:\n${message.length}${message}`;

      // Convert signature components to strings
      const v = (sig.v - 27).toString();
      const r = sig.r;
      const s = sig.s;

      // Call associate function
      const tx = await addr.associate(v, r, s, customMessage);
      const receipt = await tx.wait();

      console.log('Association successful:', receipt);
    } catch (error) {
      console.error('Association failed:', error);
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract AddressManager {
        IAddrPrecompile constant ADDR = IAddrPrecompile(0x0000000000000000000000000000000000001004);

        event AddressAssociated(address indexed evmAddr, string seiAddr);

        function associateMyAddress(
            string memory v,
            string memory r,
            string memory s,
            string memory customMessage
        ) external {
            (string memory seiAddr, address evmAddr) = ADDR.associate(v, r, s, customMessage);

            // Verify the association is for the caller
            require(evmAddr == msg.sender, "Association mismatch");

            emit AddressAssociated(evmAddr, seiAddr);
        }
    }
    ```
  </Tab>
</Tabs>

### Associate Address with Public Key

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Associate addresses using a public key
    try {
      // Create or get a wallet's public key
      const wallet = ethers.Wallet.createRandom();
      const pubKeyWithout0x = wallet.signingKey.compressedPublicKey.slice(2);

      // Call associatePubKey function
      const tx = await addr.associatePubKey(pubKeyWithout0x);
      const receipt = await tx.wait();

      console.log('Public key association successful:', receipt);
    } catch (error) {
      console.error('Public key association failed:', error);
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract AddressManager {
        IAddrPrecompile constant ADDR = IAddrPrecompile(0x0000000000000000000000000000000000001004);

        event AddressAssociated(address indexed evmAddr, string seiAddr);

        function associateWithPubKey(string memory pubKeyHex) external {
            (string memory seiAddr, address evmAddr) = ADDR.associatePubKey(pubKeyHex);

            // Store or emit the association
            emit AddressAssociated(evmAddr, seiAddr);
        }
    }
    ```
  </Tab>
</Tabs>

### Query Sei Address from EVM Address

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Query the Sei address for a given EVM address
    const evmAddress = '0x1234567890123456789012345678901234567890';

    try {
      const seiAddress = await addr.getSeiAddr(evmAddress);
      console.log('Corresponding Sei address:', seiAddress);
    } catch (error) {
      if (error.message.includes('not found') || error.message.includes('no association')) {
        console.log('No association found for this EVM address');
      } else {
        console.error('Error querying Sei address:', error);
      }
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract AddressManager {
        IAddrPrecompile constant ADDR = IAddrPrecompile(0x0000000000000000000000000000000000001004);

        function getUserSeiAddress(address evmAddr) external view returns (string memory) {
            return ADDR.getSeiAddr(evmAddr);
        }

        // Safe version with error handling
        function tryGetUserSeiAddress(address evmAddr) external view returns (bool success, string memory seiAddr) {
            try ADDR.getSeiAddr(evmAddr) returns (string memory result) {
                return (true, result);
            } catch {
                return (false, "");
            }
        }
    }
    ```
  </Tab>
</Tabs>

### Query EVM Address from Sei Address

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Query the EVM address for a given Sei address
    const seiAddress = 'sei1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6s8dpw';

    try {
      const evmAddress = await addr.getEvmAddr(seiAddress);
      console.log('Corresponding EVM address:', evmAddress);
    } catch (error) {
      if (error.message.includes('not found') || error.message.includes('no association')) {
        console.log('No association found for this Sei address');
      } else {
        console.error('Error querying EVM address:', error);
      }
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract AddressManager {
        IAddrPrecompile constant ADDR = IAddrPrecompile(0x0000000000000000000000000000000000001004);

        function getEvmFromSei(string memory seiAddr) external view returns (address) {
            return ADDR.getEvmAddr(seiAddr);
        }

        // Safe version with error handling
        function tryGetEvmFromSei(string memory seiAddr) external view returns (bool success, address evmAddr) {
            try ADDR.getEvmAddr(seiAddr) returns (address result) {
                return (true, result);
            } catch {
                return (false, address(0));
            }
        }
    }
    ```
  </Tab>
</Tabs>

### Complete Integration Example

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    import { ADDRESS_PRECOMPILE_ABI, ADDRESS_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';
    import { ethers } from 'ethers';

    async function addrExample() {
      // Setup
      const provider = new ethers.BrowserProvider(window.ethereum);
      await provider.send('eth_requestAccounts', []);
      const signer = await provider.getSigner();
      const addr = new ethers.Contract(ADDRESS_PRECOMPILE_ADDRESS, ADDRESS_PRECOMPILE_ABI, signer);

      const evmAddress = await signer.getAddress();

      try {
        // 1. Check if current EVM address has an associated Sei address
        console.log('=== Checking Current Association ===');
        try {
          const associatedSei = await addr.getSeiAddr(evmAddress);
          console.log('EVM address:', evmAddress);
          console.log('Associated Sei address:', associatedSei);

          // Verify reverse lookup
          const reverseEvm = await addr.getEvmAddr(associatedSei);
          console.log('Reverse lookup EVM address:', reverseEvm);
        } catch (error) {
          if (error.message.includes('not found') || error.message.includes('no association')) {
            console.log('No association found. You may need to make a transaction first or associate manually.');

            // 2. Demonstrate manual association with public key
            console.log('=== Creating Manual Association ===');
            const wallet = ethers.Wallet.createRandom();
            const pubKeyWithout0x = wallet.signingKey.compressedPublicKey.slice(2);

            const associateTx = await addr.associatePubKey(pubKeyWithout0x);
            const receipt = await associateTx.wait();
            console.log('Manual association completed:', receipt.transactionHash);
          } else {
            throw error;
          }
        }

        // 3. Demonstrate address resolution for different formats
        console.log('=== Address Resolution Examples ===');

        // Test with known Sei address format
        const testSeiAddr = 'sei1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6s8dpw';
        try {
          const correspondingEvm = await addr.getEvmAddr(testSeiAddr);
          console.log('Test Sei address:', testSeiAddr);
          console.log('Corresponding EVM address:', correspondingEvm);
        } catch (error) {
          console.log('Test address not associated:', testSeiAddr);
        }
      } catch (error) {
        console.error('Operation failed:', error);
      }
    }
    ```
  </Tab>

  <Tab title="Solidity">
    **Contract Example**

    ```solidity theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;

    interface IAddrPrecompile {
        function associate(
            string memory v,
            string memory r,
            string memory s,
            string memory customMessage
        ) external returns (string memory seiAddr, address evmAddr);

        function associatePubKey(
            string memory pubKeyHex
        ) external returns (string memory seiAddr, address evmAddr);

        function getSeiAddr(address addr) external view returns (string memory response);

        function getEvmAddr(string memory addr) external view returns (address response);
    }

    contract CrossChainAddressManager {
        IAddrPrecompile constant ADDR = IAddrPrecompile(0x0000000000000000000000000000000000001004);

        struct UserProfile {
            address evmAddress;
            string seiAddress;
            bool isVerified;
        }

        mapping(address => UserProfile) public userProfiles;
        mapping(string => address) public seiToEvm;

        event UserRegistered(address indexed evmAddr, string seiAddr);
        event AddressAssociated(address indexed evmAddr, string seiAddr);

        /**
         * @dev Register user with automatic address association lookup
         */
        function registerUser() external {
            address userEvm = msg.sender;

            // Try to get associated Sei address
            try ADDR.getSeiAddr(userEvm) returns (string memory seiAddr) {
                // Association exists
                userProfiles[userEvm] = UserProfile({
                    evmAddress: userEvm,
                    seiAddress: seiAddr,
                    isVerified: true
                });

                seiToEvm[seiAddr] = userEvm;
                emit UserRegistered(userEvm, seiAddr);

            } catch {
                // No association found
                revert("Address not associated. Please associate your addresses first.");
            }
        }

        /**
         * @dev Batch query multiple EVM addresses
         */
        function batchGetSeiAddresses(
            address[] memory evmAddresses
        ) external view returns (string[] memory seiAddresses) {
            seiAddresses = new string[](evmAddresses.length);

            for (uint256 i = 0; i < evmAddresses.length; i++) {
                try ADDR.getSeiAddr(evmAddresses[i]) returns (string memory seiAddr) {
                    seiAddresses[i] = seiAddr;
                } catch {
                    seiAddresses[i] = ""; // Empty string if not associated
                }
            }
        }

        /**
         * @dev Check if an address pair is associated
         */
        function areAddressesAssociated(
            address evmAddr,
            string memory seiAddr
        ) external view returns (bool) {
            try ADDR.getSeiAddr(evmAddr) returns (string memory result) {
                return keccak256(bytes(result)) == keccak256(bytes(seiAddr));
            } catch {
                return false;
            }
        }
    }
    ```

    **Client Integration Example**

    Deploy the contract:

    ```javascript theme={"dark"}
    import { network } from 'hardhat';

    // Hardhat 3 exposes ethers through a network connection rather than a global import
    const { ethers } = await network.create();

    async function main() {
      // The signer comes from the network config (encrypted keystore)
      const [deployer] = await ethers.getSigners();
      console.log('Deploying contracts with the account:', deployer.address);

      const balance = await deployer.provider.getBalance(deployer.address);
      console.log('Account balance:', ethers.formatEther(balance));

      const AddressManager = await ethers.getContractFactory('CrossChainAddressManager');
      console.log('Deploying AddressManager...', AddressManager);
      const addressManager = await AddressManager.deploy({
        gasLimit: 5000000n // Set a reasonable gas limit
      });
      await addressManager.waitForDeployment();

      console.log('AddressManager deployed to:', await addressManager.getAddress());
    }

    main().catch((error) => {
      console.error(error);
      process.exitCode = 1;
    });
    ```

    Then run:

    ```bash theme={"dark"}
    npx hardhat run scripts/deploy.js --network sei
    ```

    ```javascript theme={"dark"}
    import { network } from 'hardhat';
    // Path is relative to this file in scripts/ — Hardhat writes artifacts to the project root
    import addressManagerAbi from '../artifacts/contracts/CrossChainAddressManager.sol/CrossChainAddressManager.json' with { type: 'json' };

    // Hardhat 3 exposes ethers through a network connection rather than a global import
    const { ethers } = await network.create();

    async function main() {
      // The signer comes from the network config (encrypted keystore)
      const [deployer] = await ethers.getSigners();
      console.log('Interacting with the account:', deployer.address);

      const balance = await deployer.provider.getBalance(deployer.address);
      console.log('Account balance:', ethers.formatEther(balance));

      const addressManagerAddress = '0xYourAddressManagerContractAddress'; // Replace with your deployed contract address
      const addressManager = new ethers.Contract(addressManagerAddress, addressManagerAbi.abi, deployer);
      console.log('AddressManager deployed to:', await addressManager.getAddress());

      // Register user (requires existing address association)
      try {
        const registerTx = await addressManager.registerUser();
        await registerTx.wait();
        console.log('User registered successfully');

        // Get user's profile
        const userProfile = await addressManager.userProfiles(deployer.address);
        console.log('User profile:', userProfile);
      } catch (error) {
        console.error('Registration failed:', error);
      }
    }

    main().catch((error) => {
      console.error(error);
      process.exitCode = 1;
    });
    ```

    Then run the interaction script:

    ```bash theme={"dark"}
    npx hardhat run scripts/interact.js --network sei
    ```
  </Tab>
</Tabs>

## Security Considerations & Risks

### Association Permanence

* **Permanent Mapping:** Once addresses are associated, the mapping cannot be changed or removed
* **Single Association:** Each address can only be associated with one counterpart
* **Verification:** Always verify associations before depending on them in critical operations

### Signature Security

* **Custom Messages:** Use unique, timestamped messages to prevent replay attacks
* **Message Format:** Follow exact Ethereum Signed Message format for compatibility

## Troubleshooting

### Common Issues and Solutions

#### Gas-Related Issues

```typescript theme={"dark"}
// Set appropriate gas limits for different operations
const associateTx = await addr.associate(v, r, s, customMessage, {
  gasLimit: 200000 // Association operations
});

const pubKeyTx = await addr.associatePubKey(pubKeyHex, {
  gasLimit: 150000 // Public key association
});
```

### Error Code Reference

| Error                    | Cause                           | Solution                                       |
| ------------------------ | ------------------------------- | ---------------------------------------------- |
| `invalid signature`      | Malformed v, r, s components    | Verify signature parsing and format            |
| `already associated`     | Address already has association | Check existing association instead             |
| `not found`              | No association exists           | Create association first                       |
| `invalid public key`     | Malformed public key format     | Use compressed format without 0x prefix        |
| `invalid address format` | Wrong address format            | Use proper EVM (0x...) or Sei (sei1...) format |

## Important Notes

<Info> Remember: Address associations are permanent and cannot be changed once created! </Info>

### Address Formats

* **EVM Addresses:** Use standard Ethereum format with `0x` prefix
* **Sei Addresses:** Use Cosmos format with `sei1` prefix for regular addresses
* **Case Sensitivity:** EVM addresses are case-insensitive, Sei addresses are case-sensitive

### Association Timing

* **Automatic:** Most users get associated automatically on their first transaction
* **Manual:** Use precompile functions for programmatic association or when automatic association hasn't occurred
* **Verification:** Always verify associations exist before depending on them

### Signature Requirements

* **Message Format:** Must include Ethereum Signed Message prefix for `associate()` function
* **Component Format:** v, r, s must be properly formatted hex strings
* **Replay Protection:** Use unique messages to prevent signature replay attacks

### Gas Considerations

* **Association operations:** \~200,000 gas limit recommended
* **Query operations:** Standard view function gas usage
* **Batch operations:** Scale gas limits based on array size

<Info>View the Address precompile source code and the contract ABI [here](https://github.com/sei-protocol/sei-chain/tree/main/precompiles/addr).</Info>

---

URL: https://docs.sei.io/evm/precompiles/cosmwasm-precompiles/bank

# Bank Precompile

> Learn how to interact with Sei's Bank precompile through ethers.js and Solidity, enabling native token transfers, balance queries, and token metadata management directly in your EVM smart contracts for seamless DeFi experiences.

**Address:** `0x0000000000000000000000000000000000001001`

The Sei bank precompile allows EVM applications to interact directly with Sei's native banking system through standard smart contract calls. This enables querying balances, transferring tokens, and accessing token metadata for both native SEI tokens and Cosmos SDK-based assets, providing seamless integration between EVM and Cosmos ecosystems.

<Info> **What is a precompile?** A precompile is a special smart contract deployed at a fixed address by the Sei protocol itself, that exposes custom native chain logic to EVM-based applications. It acts like a regular contract from the EVM's perspective, but executes privileged, low-level logic efficiently. </Info>

## How Does the Bank Precompile Work?

The bank precompile at address `0x0000000000000000000000000000000000001001` exposes functions like `send()`, `sendNative()`, `balance()`, `all_balances()`, and token metadata queries.

* **Direct Integration:** EVM contracts and dApps can call banking functions like any other smart contract method.
* **Native Execution:** Operations are executed at the Cosmos SDK level for maximum efficiency and security.
* **Cross-Chain Assets:** Manage both native SEI tokens and IBC assets seamlessly from EVM contracts.

**When to use `send` vs `sendNative`:** `send` moves an arbitrary `denom` (any IBC or factory token) between two EVM addresses (`0x...`) by reading the balance directly from the bank module — no `msg.value` is attached. It is gated to the registered ERC20 native pointer for that denom, so it is typically invoked from the auto-deployed pointer contract rather than from arbitrary user code. `sendNative` is for sending native SEI (the attached `msg.value`) from the EVM caller to a Cosmos bech32 (`sei1...`) destination, which is useful for crossing the EVM→Cosmos boundary when the recipient has no associated EVM address (for example, paying a Cosmos-only contract or account).

## Use Cases

* **DeFi Applications:** Build decentralized finance protocols that can handle native SEI and Cosmos assets.
* **Portfolio Management:** Build tools to track and manage multi-asset portfolios across Cosmos and EVM.
* **Token Information Services:** Query comprehensive token metadata for UI display and analytics.

## What You'll Learn in This Guide

By the end of this guide, you'll be able to:

* **Execute Token Transfers** - Send both native SEI and custom tokens between addresses
* **Query Account Balances** - Check single and multi-asset balances for any address
* **Access Token Metadata** - Retrieve names, symbols, decimals, and supply information

## Functions

The bank precompile exposes the following functions:

### Transaction Functions

```solidity theme={"dark"}
/// Sends non-native tokens from one address to another. Callable only by the
/// registered ERC20 native pointer contract for the given denom.
/// @param fromAddress The EVM address (0x...) to send funds from.
/// @param toAddress The EVM address (0x...) to send funds to.
/// @param denom The denomination of funds to send.
/// @param amount The amount of the above denom to send.
/// @return success Whether the send was successfully executed.
function send(
    address fromAddress,
    address toAddress,
    string memory denom,
    uint256 amount
) external returns (bool success);

/// Sends native SEI (the attached msg.value) from the EVM caller to a Cosmos
/// bech32 recipient. Requires a non-zero msg.value.
/// @param toNativeAddress The bech32 (sei1...) address of the recipient.
/// @return success Whether the tokens were successfully sent.
function sendNative(
    string memory toNativeAddress
) payable external returns (bool success);
```

### Query Functions

```solidity theme={"dark"}
/// Queries the balance of the given account for the specified denom.
/// @param acc The EVM address (0x...) of the account to query.
/// @param denom The denomination to query for.
/// @return amount The amount of denom held by acc.
function balance(
    address acc,
    string memory denom
) external view returns (uint256 amount);

/// Queries the balance of the given account for all balances.
/// @param acc The EVM address (0x...) of the account to query.
/// @return response Balances for all coins/denoms.
function all_balances(
    address acc
) external view returns (Coin[] memory response);

/// Queries the name of the specified denom.
/// @param denom The denomination to query about.
/// @return response The name of the specified denom.
function name(
    string memory denom
) external view returns (string memory response);

/// Queries the symbol of the specified denom.
/// @param denom The denomination to query about.
/// @return response The symbol of the specified denom.
function symbol(
    string memory denom
) external view returns (string memory response);

/// Queries the number of decimal places for the specified denom.
/// @param denom The denomination to query about.
/// @return response The number of decimals for the specified denom.
function decimals(
    string memory denom
) external view returns (uint8 response);

/// Queries the total supply of the specified denom.
/// @param denom The denomination to query about.
/// @return response The total supply of the specified denom.
function supply(
    string memory denom
) external view returns (uint256 response);
```

## Using the Precompile

### Setup

#### Prerequisites

Before getting started, ensure you have:

* **Node.js** (v18 or higher)
* **npm** or **yarn** package manager
* **EVM-compatible wallet**
* **SEI tokens** for gas and testing transfers
* **Hardhat** for development and testing

#### Install Dependencies

Install the required packages for interacting with Sei precompiles:

```bash theme={"dark"}
# Instantiate a new Hardhat 3 project (choose "Hardhat 3" and the Mocha + Ethers.js TypeScript setup)
npx hardhat --init

# Install ethers.js for smart contract interactions
npm install ethers

# Install Sei EVM bindings for precompile addresses and ABIs
npm install @sei-js/precompiles@2.1.2
```

#### Setup Hardhat Environment

Create a `hardhat.config.ts` file with the following content:

```typescript theme={"dark"}
import { defineConfig, configVariable } from 'hardhat/config';
import hardhatToolboxMochaEthers from '@nomicfoundation/hardhat-toolbox-mocha-ethers';

export default defineConfig({
  solidity: '0.8.28',
  networks: {
    sei: {
      type: 'http',
      chainId: 1329,
      url: 'https://evm-rpc.sei-apis.com',
      accounts: [configVariable('PRIVATE_KEY')]
    }
  },
  plugins: [hardhatToolboxMochaEthers]
});
```

Store your private key in Hardhat's encrypted keystore (no plaintext `.env` file needed):

```bash theme={"dark"}
npx hardhat keystore set PRIVATE_KEY
```

#### Import Precompile Components

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Import Bank precompile address and ABI
    // View the entire ABI here: https://github.com/sei-protocol/sei-chain/tree/main/precompiles/bank
    import { BANK_PRECOMPILE_ABI, BANK_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';
    import { ethers } from 'ethers';
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;

    struct Coin {
    uint256 amount;
    string denom;
    }

    interface IBankPrecompile {
    function send(
    address fromAddress,
    address toAddress,
    string memory denom,
    uint256 amount
    ) external returns (bool success);

        function sendNative(
            string memory toNativeAddress
        ) payable external returns (bool success);

        function balance(
            address acc,
            string memory denom
        ) external view returns (uint256 amount);

        function all_balances(
            address acc
        ) external view returns (Coin[] memory response);

        function name(
            string memory denom
        ) external view returns (string memory response);

        function symbol(
            string memory denom
        ) external view returns (string memory response);

        function decimals(
            string memory denom
        ) external view returns (uint8 response);

        function supply(
            string memory denom
        ) external view returns (uint256 response);

    }

    ```
  </Tab>
</Tabs>

<Info> **Precompile Address:** The bank precompile is deployed at `0x0000000000000000000000000000000000001001` </Info>

### Contract Initialization

<Tabs>
  <Tab title="JavaScript">
    Set up your provider, signer, and contract instance:

    ```typescript theme={"dark"}
    // Using EVM-compatible wallet as the signer and provider
    const provider = new ethers.BrowserProvider(window.ethereum);
    await provider.send('eth_requestAccounts', []);
    const signer = await provider.getSigner();

    // Create a contract instance for the bank precompile
    const bank = new ethers.Contract(BANK_PRECOMPILE_ADDRESS, BANK_PRECOMPILE_ABI, signer);
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    // Initialize the contract instance in your Solidity code
    contract TokenManager {
        IBankPrecompile constant BANK = IBankPrecompile(0x0000000000000000000000000000000000001001);
    }
    ```
  </Tab>
</Tabs>

### Native SEI vs Custom Tokens

**Native SEI Transfers:**

* Use `sendNative()` with payable value
* Denomination is always `usei` (micro-SEI)
* Parse to 18 digits when calling `sendNative()`

**Custom Token Transfers:**

* Use `send()` with specific denomination
* Requires prior token approval or ownership
* Support various decimal configurations

## Step-by-Step Guide: Using the Bank Precompile

### Send Native SEI Tokens

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Send native SEI tokens to another address
    const recipientAddress = 'sei1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6s8dpw';
    const amountInSei = '0.1'; // 0.1 SEI

    try {
      // msg.value is in wei (18 decimals), like any other EVM transaction
      const amountInWei = ethers.parseUnits(amountInSei, 18); // equivalent to ethers.parseEther(amountInSei)

      // Send native SEI
      const tx = await bank.sendNative(recipientAddress, {
        value: amountInWei,
        gasLimit: 300000n
      });

      const receipt = await tx.wait();
      console.log('Native SEI transfer successful:', receipt.hash);
      console.log(`Sent ${amountInSei} SEI to ${recipientAddress}`);
    } catch (error) {
      console.error('Native SEI transfer failed:', error);
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract PaymentProcessor {
        IBankPrecompile constant BANK = IBankPrecompile(0x0000000000000000000000000000000000001001);

        event PaymentSent(address indexed from, string to, uint256 amount);

        function sendSeiPayment(string memory recipient) external payable {
            require(msg.value > 0, "Payment amount must be greater than 0");

            bool success = BANK.sendNative{value: msg.value}(recipient);
            require(success, "Payment failed");

            emit PaymentSent(msg.sender, recipient, msg.value);
        }
    }
    ```
  </Tab>
</Tabs>

### Send Custom Tokens

<Tabs>
  <Tab title="JavaScript">
    <Warning>`send()` can only be called by the registered ERC20 native pointer contract for the given denom — calling it from a regular wallet will revert. The snippet below only illustrates the arguments a pointer contract passes. As a user, transfer native denoms through the denom's ERC20 pointer contract (`transfer()`), or use `sendNative()` for SEI.</Warning>

    ```typescript theme={"dark"}
    // Illustration: how a registered ERC20 pointer contract calls send()
    const fromAddress = '0x1234567890123456789012345678901234567890';
    const toAddress = '0x9876543210987654321098765432109876543210';
    const tokenDenom = 'usei';
    const amount = '1';

    // Amounts are in the denom's base units — check decimals() for each denom.
    // usei has 6 decimals (1 SEI = 1,000,000 usei)
    const tx = await bank.send(
      fromAddress,
      toAddress,
      tokenDenom,
      ethers.parseUnits(amount, 6),
      {
        gasLimit: 300000n
      }
    );

    const receipt = await tx.wait();
    console.log('Custom token transfer successful:', receipt.hash);
    console.log(`Sent ${amount} ${tokenDenom} from ${fromAddress} to ${toAddress}`);
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract TokenTransferManager {
        IBankPrecompile constant BANK = IBankPrecompile(0x0000000000000000000000000000000000001001);

        event TokenTransfer(
            address indexed from,
            address indexed to,
            string denom,
            uint256 amount
        );

        function transferTokens(
            address to,
            string memory denom,
            uint256 amount
        ) external {
            // Transfer tokens from sender to recipient
            bool success = BANK.send(msg.sender, to, denom, amount);
            require(success, "Token transfer failed");

            emit TokenTransfer(msg.sender, to, denom, amount);
        }

        function batchTransfer(
            address[] memory recipients,
            string memory denom,
            uint256[] memory amounts
        ) external {
            require(recipients.length == amounts.length, "Array length mismatch");

            for (uint256 i = 0; i < recipients.length; i++) {
                bool success = BANK.send(msg.sender, recipients[i], denom, amounts[i]);
                require(success, "Batch transfer failed");

                emit TokenTransfer(msg.sender, recipients[i], denom, amounts[i]);
            }
        }
    }
    ```
  </Tab>
</Tabs>

### Query Account Balance

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Query specific token balance
    const accountAddress = '0x1234567890123456789012345678901234567890';
    const tokenDenom = 'usei';

    try {
      const balance = await bank.balance(accountAddress, tokenDenom);

      // Convert usei to SEI for display
      if (tokenDenom === 'usei') {
        const seiBalance = ethers.formatUnits(balance, 6);
        console.log(`SEI Balance: ${seiBalance} SEI`);
      } else {
        console.log(`${tokenDenom} Balance: ${balance.toString()}`);
      }
    } catch (error) {
      console.error('Balance query failed:', error);
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract BalanceChecker {
        IBankPrecompile constant BANK = IBankPrecompile(0x0000000000000000000000000000000000001001);

        function getUserSeiBalance(address user) external view returns (uint256) {
            return BANK.balance(user, "usei");
        }

        function getUserTokenBalance(
            address user,
            string memory denom
        ) external view returns (uint256) {
            return BANK.balance(user, denom);
        }

        function hasMinimumBalance(
            address user,
            string memory denom,
            uint256 minAmount
        ) external view returns (bool) {
            uint256 balance = BANK.balance(user, denom);
            return balance >= minAmount;
        }
    }
    ```
  </Tab>
</Tabs>

### Query All Balances

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Query all token balances for an account
    const accountAddress = '0x1234567890123456789012345678901234567890';

    try {
      const allBalances = await bank.all_balances(accountAddress);

      console.log(`Account: ${accountAddress}`);
      console.log('All Balances:');

      allBalances.forEach((coin, index) => {
        if (coin.denom === 'usei') {
          const seiAmount = ethers.formatUnits(coin.amount, 6);
          console.log(`  ${index + 1}. ${seiAmount} SEI (${coin.denom})`);
        } else {
          console.log(`  ${index + 1}. ${coin.amount.toString()} ${coin.denom}`);
        }
      });
    } catch (error) {
      console.error('All balances query failed:', error);
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract PortfolioManager {
        IBankPrecompile constant BANK = IBankPrecompile(0x0000000000000000000000000000000000001001);

        struct Portfolio {
            address owner;
            Coin[] balances;
            uint256 totalValue; // In usei equivalent
        }

        function getPortfolio(address user) external view returns (Coin[] memory) {
            return BANK.all_balances(user);
        }

        function hasAnyBalance(address user) external view returns (bool) {
            Coin[] memory balances = BANK.all_balances(user);
            return balances.length > 0;
        }

        function countTokenTypes(address user) external view returns (uint256) {
            Coin[] memory balances = BANK.all_balances(user);
            return balances.length;
        }

        function findTokenBalance(
            address user,
            string memory targetDenom
        ) external view returns (uint256) {
            Coin[] memory balances = BANK.all_balances(user);

            for (uint256 i = 0; i < balances.length; i++) {
                if (keccak256(bytes(balances[i].denom)) == keccak256(bytes(targetDenom))) {
                    return balances[i].amount;
                }
            }

            return 0; // Token not found
        }
    }
    ```
  </Tab>
</Tabs>

### Query Token Metadata

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Query comprehensive token metadata
    const tokenDenom = 'usei';

    try {
      // Get all metadata in parallel
      const [name, symbol, decimals, totalSupply] = await Promise.all([bank.name(tokenDenom), bank.symbol(tokenDenom), bank.decimals(tokenDenom), bank.supply(tokenDenom)]);

      console.log('Token Metadata:');
      console.log(`  Denomination: ${tokenDenom}`);
      console.log(`  Name: ${name}`);
      console.log(`  Symbol: ${symbol}`);
      console.log(`  Decimals: ${decimals}`);
      console.log(`  Total Supply: ${ethers.formatUnits(totalSupply, decimals)}`);
    } catch (error) {
      console.error('Metadata query failed:', error);
    }

    // Function to get formatted token info
    async function getTokenInfo(denom) {
      try {
        const metadata = {
          denom: denom,
          name: await bank.name(denom),
          symbol: await bank.symbol(denom),
          decimals: await bank.decimals(denom),
          supply: await bank.supply(denom)
        };

        return {
          ...metadata,
          formattedSupply: ethers.formatUnits(metadata.supply, metadata.decimals)
        };
      } catch (error) {
        console.error(`Failed to get info for ${denom}:`, error);
        return null;
      }
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract TokenRegistry {
        IBankPrecompile constant BANK = IBankPrecompile(0x0000000000000000000000000000000000001001);

        struct TokenInfo {
            string denom;
            string name;
            string symbol;
            uint8 decimals;
            uint256 totalSupply;
            bool isValid;
        }

        mapping(string => TokenInfo) public tokenRegistry;

        function getTokenInfo(
            string memory denom
        ) external view returns (TokenInfo memory) {
            TokenInfo memory info;

            info.denom = denom;
            info.name = BANK.name(denom);
            info.symbol = BANK.symbol(denom);
            info.decimals = BANK.decimals(denom);
            info.totalSupply = BANK.supply(denom);
            info.isValid = true;

            return info;
        }
    }
    ```
  </Tab>
</Tabs>

### Complete Integration Example

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    import { BANK_PRECOMPILE_ABI, BANK_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';
    import { ethers } from 'ethers';

    class SeiTokenManager {
      private bank: ethers.Contract;
      private signer: ethers.Signer;

      constructor(signer: ethers.Signer) {
        this.signer = signer;
        this.bank = new ethers.Contract(BANK_PRECOMPILE_ADDRESS, BANK_PRECOMPILE_ABI, signer);
      }

      // Send native SEI tokens
      async sendSei(recipientAddress: string, amountInSei: string) {
        try {
          const amountInWei = ethers.parseUnits(amountInSei, 18);
          const tx = await this.bank.sendNative(recipientAddress, {
            value: amountInWei,
            gasLimit: 100000
          });

          const receipt = await tx.wait();
          return {
            success: true,
            transactionHash: receipt.hash,
            amount: amountInSei,
            recipient: recipientAddress
          };
        } catch (error) {
          return { success: false, error: error.message };
        }
      }

      // Get user's portfolio
      async getPortfolio(address: string) {
        try {
          const balances = await this.bank.all_balances(address);
          const portfolio = [];

          for (const coin of balances) {
            try {
              const metadata = await this.getTokenMetadata(coin.denom);
              portfolio.push({
                denom: coin.denom,
                amount: coin.amount.toString(),
                formattedAmount: ethers.formatUnits(coin.amount, metadata.decimals),
                ...metadata
              });
            } catch (metadataError) {
              // If metadata fails, still include the balance
              portfolio.push({
                denom: coin.denom,
                amount: coin.amount.toString(),
                formattedAmount: coin.amount.toString(),
                name: 'Unknown',
                symbol: 'Unknown',
                decimals: 0
              });
            }
          }

          return { success: true, portfolio };
        } catch (error) {
          return { success: false, error: error.message };
        }
      }

      // Get token metadata
      async getTokenMetadata(denom: string) {
        const [name, symbol, decimals, supply] = await Promise.all([this.bank.name(denom).catch(() => 'Unknown'), this.bank.symbol(denom).catch(() => 'Unknown'), this.bank.decimals(denom).catch(() => 0), this.bank.supply(denom).catch(() => 0n)]);

        return { name, symbol, decimals, supply: supply.toString() };
      }

      // Transfer custom tokens
      async transferToken(toAddress: string, denom: string, amount: string, decimals: number = 18) {
        try {
          const fromAddress = await this.signer.getAddress();
          const parsedAmount = ethers.parseUnits(amount, decimals);

          const tx = await this.bank.send(fromAddress, toAddress, denom, parsedAmount, {
            gasLimit: 150000
          });

          const receipt = await tx.wait();
          return {
            success: true,
            transactionHash: receipt.hash,
            from: fromAddress,
            to: toAddress,
            denom,
            amount
          };
        } catch (error) {
          return { success: false, error: error.message };
        }
      }

      // Batch operations
      async batchBalanceCheck(addresses: string[], denom: string) {
        try {
          const balances = await Promise.allSettled(addresses.map((addr) => this.bank.balance(addr, denom)));

          return balances.map((result, index) => ({
            address: addresses[index],
            balance: result.status === 'fulfilled' ? result.value.toString() : '0',
            success: result.status === 'fulfilled'
          }));
        } catch (error) {
          throw new Error(`Batch balance check failed: ${error.message}`);
        }
      }
    }

    // Usage example
    async function bankExample() {
      const provider = new ethers.BrowserProvider(window.ethereum);
      await provider.send('eth_requestAccounts', []);
      const signer = await provider.getSigner();
      const tokenManager = new SeiTokenManager(signer);

      console.log('=== Sei Token Manager Demo ===');

      // 1. Get current user's portfolio
      const userAddress = await signer.getAddress();
      const portfolio = await tokenManager.getPortfolio(userAddress);

      if (portfolio.success) {
        console.log('User Portfolio:');
        portfolio.portfolio.forEach((token, index) => {
          console.log(`  ${index + 1}. ${token.formattedAmount} ${token.symbol} (${token.name})`);
        });
      }

      // 2. Send native SEI
      const sendResult = await tokenManager.sendSei('sei1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6s8dpw', '0.01');

      if (sendResult.success) {
        console.log('SEI transfer successful:', sendResult.transactionHash);
      }

      // 3. Check balances for multiple addresses
      const addresses = ['0x1234567890123456789012345678901234567890', '0x9876543210987654321098765432109876543210'];

      const batchBalances = await tokenManager.batchBalanceCheck(addresses, 'usei');
      console.log('Batch balance results:', batchBalances);
    }
    ```
  </Tab>

  <Tab title="Solidity">
    **Complete Contract Example**

    ```solidity theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;

    interface IBankPrecompile {
        function send(address fromAddress, address toAddress, string memory denom, uint256 amount) external returns (bool success);
        function sendNative(string memory toNativeAddress) payable external returns (bool success);
        function balance(address acc, string memory denom) external view returns (uint256 amount);
        function all_balances(address acc) external view returns (Coin[] memory response);
        function name(string memory denom) external view returns (string memory response);
        function symbol(string memory denom) external view returns (string memory response);
        function decimals(string memory denom) external view returns (uint8 response);
        function supply(string memory denom) external view returns (uint256 response);
    }

    struct Coin {
        uint256 amount;
        string denom;
    }

    contract ComprehensiveTokenManager {
        IBankPrecompile constant BANK = IBankPrecompile(0x0000000000000000000000000000000000001001);

        // Events
        event PaymentProcessed(address indexed from, string to, uint256 amount, string denom);
        event TokenTransfer(address indexed from, address indexed to, string denom, uint256 amount);
        event BatchTransferCompleted(address indexed sender, uint256 totalRecipients);

        // State variables
        mapping(address => bool) public authorizedOperators;
        mapping(string => bool) public supportedTokens;
        address public owner;

        modifier onlyOwner() {
            require(msg.sender == owner, "Only owner can execute");
            _;
        }

        modifier onlyAuthorized() {
            require(authorizedOperators[msg.sender] || msg.sender == owner, "Not authorized");
            _;
        }

        constructor() {
            owner = msg.sender;
            authorizedOperators[msg.sender] = true;
            supportedTokens["usei"] = true;
        }

        // =============
        // Payment Functions
        // =============

        function processPayment(
            string memory recipient,
            uint256 amount
        ) external payable {
            require(msg.value >= amount, "Insufficient payment");

            bool success = BANK.sendNative{value: amount}(recipient);
            require(success, "Payment failed");

            // Refund excess
            if (msg.value > amount) {
                payable(msg.sender).transfer(msg.value - amount);
            }

            emit PaymentProcessed(msg.sender, recipient, amount, "usei");
        }

        function processTokenPayment(
            address recipient,
            string memory denom,
            uint256 amount
        ) external onlyAuthorized {
            require(supportedTokens[denom], "Token not supported");

            bool success = BANK.send(msg.sender, recipient, denom, amount);
            require(success, "Token payment failed");

            emit TokenTransfer(msg.sender, recipient, denom, amount);
        }

        // =============
        // Batch Operations
        // =============

        function batchSeiTransfer(
            string[] memory recipients,
            uint256[] memory amounts
        ) external payable {
            require(recipients.length == amounts.length, "Array length mismatch");
            require(recipients.length <= 50, "Too many recipients");

            uint256 totalAmount = 0;
            for (uint256 i = 0; i < amounts.length; i++) {
                totalAmount += amounts[i];
            }
            require(msg.value >= totalAmount, "Insufficient total payment");

            for (uint256 i = 0; i < recipients.length; i++) {
                bool success = BANK.sendNative{value: amounts[i]}(recipients[i]);
                require(success, "Batch transfer failed");

                emit PaymentProcessed(msg.sender, recipients[i], amounts[i], "usei");
            }

            // Refund excess
            if (msg.value > totalAmount) {
                payable(msg.sender).transfer(msg.value - totalAmount);
            }

            emit BatchTransferCompleted(msg.sender, recipients.length);
        }

        function batchTokenTransfer(
            address[] memory recipients,
            string memory denom,
            uint256[] memory amounts
        ) external onlyAuthorized {
            require(recipients.length == amounts.length, "Array length mismatch");
            require(recipients.length <= 20, "Too many recipients");
            require(supportedTokens[denom], "Token not supported");

            for (uint256 i = 0; i < recipients.length; i++) {
                bool success = BANK.send(msg.sender, recipients[i], denom, amounts[i]);
                require(success, "Batch token transfer failed");

                emit TokenTransfer(msg.sender, recipients[i], denom, amounts[i]);
            }

            emit BatchTransferCompleted(msg.sender, recipients.length);
        }

        // =============
        // Query Functions
        // =============

        function getUserPortfolio(address user) external view returns (Coin[] memory) {
            return BANK.all_balances(user);
        }

        function getUserBalance(address user, string memory denom) external view returns (uint256) {
            return BANK.balance(user, denom);
        }

        function getTokenInfo(string memory denom) external view returns (
            string memory name,
            string memory symbol,
            uint8 decimals,
            uint256 totalSupply
        ) {
            name = BANK.name(denom);
            symbol = BANK.symbol(denom);
            decimals = BANK.decimals(denom);
            totalSupply = BANK.supply(denom);
        }

        function checkSufficientBalance(
            address user,
            string memory denom,
            uint256 requiredAmount
        ) external view returns (bool) {
            uint256 balance = BANK.balance(user, denom);
            return balance >= requiredAmount;
        }

        function batchBalanceCheck(
            address[] memory users,
            string memory denom
        ) external view returns (uint256[] memory balances) {
            balances = new uint256[](users.length);
            for (uint256 i = 0; i < users.length; i++) {
                balances[i] = BANK.balance(users[i], denom);
            }
        }

        // =============
        // Admin Functions
        // =============

        function addSupportedToken(string memory denom) external onlyOwner {
            supportedTokens[denom] = true;
        }

        function removeSupportedToken(string memory denom) external onlyOwner {
            supportedTokens[denom] = false;
        }

        function addOperator(address operator) external onlyOwner {
            authorizedOperators[operator] = true;
        }

        function removeOperator(address operator) external onlyOwner {
            require(operator != owner, "Cannot remove owner");
            authorizedOperators[operator] = false;
        }

        // Emergency withdraw function
        function emergencyWithdraw() external onlyOwner {
            payable(owner).transfer(address(this).balance);
        }

        // =============
        // Utility Functions
        // =============

        function convertSeiToUsei(uint256 seiAmount) pure external returns (uint256) {
            return seiAmount * 1e6;
        }

        function convertUseiToSei(uint256 useiAmount) pure external returns (uint256) {
            return useiAmount / 1e6;
        }

        receive() external payable {}
    }
    ```

    Compile the contract:

    ```bash theme={"dark"}
    npx hardhat compile
    ```

    **Deployment Script**

    First, deploy the contract using Hardhat:

    ```javascript theme={"dark"}
    import { network } from 'hardhat';

    // Hardhat 3 exposes ethers through a network connection rather than a global import
    const { ethers } = await network.create();

    async function main() {
      // The signer comes from the network config (encrypted keystore)
      const [deployer] = await ethers.getSigners();
      console.log('Deploying contracts with the account:', deployer.address);

      const balance = await deployer.provider.getBalance(deployer.address);
      console.log('Account balance:', ethers.formatEther(balance));

      const ComprehensiveTokenManager = await ethers.getContractFactory('ComprehensiveTokenManager');
      console.log('Deploying ComprehensiveTokenManager...', ComprehensiveTokenManager);
      const comprehensiveTokenManager = await ComprehensiveTokenManager.deploy({
        gasLimit: 5000000n // Set a reasonable gas limit
      });
      await comprehensiveTokenManager.waitForDeployment();

      console.log('ComprehensiveTokenManager deployed to:', await comprehensiveTokenManager.getAddress());
    }

    main().catch((error) => {
      console.error(error);
      process.exitCode = 1;
    });
    ```

    To deploy, run:

    ```bash theme={"dark"}
    npx hardhat run scripts/deploy.js --network sei
    ```

    Next look through the integration example:

    ```javascript theme={"dark"}
    import { network } from 'hardhat';
    import TokenManager from './artifacts/contracts/ComprehensiveTokenManager.sol/ComprehensiveTokenManager.json' with { type: 'json' };

    // Hardhat 3 exposes ethers through a network connection rather than a global import
    const { ethers } = await network.create();

    async function main() {
      // The signer comes from the network config (encrypted keystore)
      const [deployer] = await ethers.getSigners();
      console.log('Interacting with the account:', deployer.address);

      const address = '0xYourDeployedContractAddress'; // Replace with your contract address
      const tokenManager = new ethers.Contract(address, TokenManager.abi, deployer);
      console.log('TokenManager deployed to:', address);

      // Add some supported tokens
      const tokens = ['usei', 'uatom', 'ubtc'];

      for (const token of tokens) {
        try {
          const tx = await tokenManager.addSupportedToken(token);
          await tx.wait();
          console.log('Added supported token:', token);
        } catch (error) {
          console.error('Failed to add token:', token, error.message);
        }
      }

      try {
        const allBalances = await tokenManager.getUserPortfolio(deployer.address);
        console.log('All balances:', allBalances);
      } catch (error) {
        console.error('Failed to get user portfolio:', error.message);
      }
    }

    main()
      .then(() => process.exit(0))
      .catch((error) => {
        console.error(error);
        process.exit(1);
      });
    ```

    Then run the integration example:

    ```bash theme={"dark"}
    npx hardhat run scripts/integrationExample.js --network sei
    ```
  </Tab>
</Tabs>

## Security Considerations & Risks

### Transaction Security

* **Amount Validation:** Always validate transfer amounts and ensure sufficient balances
* **Address Verification:** Verify recipient addresses are valid before sending tokens
* **Reentrancy Protection:** Be aware of potential reentrancy when combining with other contracts

### Permission Management

```solidity theme={"dark"}
// Example of secure permission patterns
modifier onlyTokenHolder(string memory denom, uint256 minAmount) {
    require(BANK.balance(msg.sender, denom) >= minAmount, "Insufficient token balance");
    _;
}

modifier validRecipient(address recipient) {
    require(recipient != address(0), "Invalid recipient");
    require(recipient != address(this), "Cannot send to contract");
    _;
}
```

## Troubleshooting

### Common Issues and Solutions

#### Transaction Failures

```typescript theme={"dark"}
// Handle common transfer errors
try {
  const tx = await bank.sendNative(recipient, { value: amount });
  await tx.wait();
} catch (error) {
  if (error.message.includes('insufficient funds')) {
    console.error('Insufficient balance for transfer');
  } else if (error.message.includes('invalid address')) {
    console.error('Invalid recipient address format');
  } else {
    console.error('Transfer failed:', error.message);
  }
}
```

#### Balance Query Issues

```typescript theme={"dark"}
// Safe balance checking with error handling
async function safeGetBalance(address: string, denom: string) {
  try {
    const balance = await bank.balance(address, denom);
    return { success: true, balance: balance.toString() };
  } catch (error) {
    if (error.message.includes('not found')) {
      return { success: true, balance: '0' }; // No balance = 0
    }
    return { success: false, error: error.message };
  }
}
```

### Error Code Reference

| Error                  | Cause                           | Solution                                       |
| ---------------------- | ------------------------------- | ---------------------------------------------- |
| `insufficient funds`   | Not enough balance for transfer | Check balance before transfer                  |
| `invalid address`      | Malformed address format        | Use proper EVM (0x...) or Sei (sei1...) format |
| `unknown denomination` | Token denom doesn't exist       | Verify token denomination format               |
| `amount overflow`      | Amount exceeds uint256 limits   | Use appropriate amount ranges                  |
| `metadata not found`   | Token metadata not available    | Handle missing metadata gracefully             |

## Important Notes

<Info>
  **Remember:** Always verify token denominations and handle errors gracefully in production applications!

  * **SEI Native:** While reading from chain it is formatted to 6 decimal places (1 SEI = 1,000,000 usei) and while writing to chain it is parsed to 18 decimal places.
  * **Custom Tokens:** Check decimals using `decimals()` function
  * **Display Formatting:** Always format amounts with proper decimal places for user display
</Info>

### Gas Optimization

* **Batch Operations:** Use batch functions for multiple operations to save gas
* **Query Efficiency:** Cache frequently accessed token metadata
* **Error Handling:** Implement proper error handling to avoid failed transaction costs

### Integration Best Practices

* **Balance Checks:** Always verify sufficient balance before transfers
* **Error Recovery:** Implement retry logic for failed transactions
* **User Experience:** Provide clear feedback on transaction status
* **Decimal Handling:** Use proper decimal formatting for different token types

<Info>View the Bank precompile source code and the contract ABI [here](https://github.com/sei-protocol/sei-chain/tree/main/precompiles/bank).</Info>

---

URL: https://docs.sei.io/evm/precompiles/cosmwasm-precompiles/cosmwasm

# CosmWasm Precompile

> Learn how to interact with Sei's CosmWasm precompile through ethers.js, enabling execution, batch operations, and querying of pre-existing CosmWasm contracts directly from your EVM smart contracts.

**Address:** `0x0000000000000000000000000000000000001002`

<Danger>
  **Deprecation Notice — Prop 115 & Prop 116**

  Per [governance Proposal 115](https://www.mintscan.io/sei/proposals/115), CosmWasm code uploads (`MsgStoreCode`) and contract instantiations (`MsgInstantiateContract`) are disabled chain-wide. The `instantiate()` function on this precompile **will revert** for all callers. Only `execute()`, `execute_batch()`, and `query()` against pre-existing CosmWasm contracts remain functional, and all CosmWasm functionality is deprecated in favor of EVM-only per [SIP-3](https://github.com/sei-protocol/sips/blob/main/sips/sip-3.md).

  In addition, [Proposal 116](https://www.mintscan.io/sei/proposals/116) disables inbound IBC transfers — IBC assets bridged from Cosmos chains can no longer arrive on Sei after this passes and is activated. See the [SIP-03 Migration Guide](/learn/sip-03-migration) for affected assets and migration routes.

  For new smart contract development, use the EVM directly. See [Deploy a Smart Contract](/evm/evm-general).
</Danger>

The Sei CosmWasm precompile allows EVM applications to interact directly with **pre-existing** CosmWasm contracts through standard smart contract calls. This enables execution, batch operations, and querying of CosmWasm contracts directly from your dApps without needing separate Cosmos SDK integration.

<Info> **What is a precompile?** A precompile is a special smart contract deployed at a fixed address by the Sei protocol itself, that exposes custom native chain logic to EVM-based applications. It acts like a regular contract from the EVM's perspective, but executes privileged, low-level logic efficiently. </Info>

## How Does the CosmWasm Precompile Work?

The CosmWasm precompile at address `0x0000000000000000000000000000000000001002` exposes functions like `execute()`, `execute_batch()`, and `query()`.

* **Direct Integration:** EVM contracts and dApps can call CosmWasm functions like any other smart contract method.
* **Native Execution:** Operations are executed at the Cosmos SDK level for maximum efficiency and security.
* **Seamless Bridge:** No need for separate wallet integrations or complex cross-chain interactions.

## What You'll Learn in This Guide

By the end of this guide, you'll be able to:

* **Execute Contract Functions** - Call CosmWasm contract methods and handle message formatting
* **Batch Operations** - Execute multiple contract calls efficiently in a single transaction
* **Query Contract State** - Read CosmWasm contract data without gas costs
* **Handle Cross-Runtime Data** - Master message encoding/decoding between EVM and CosmWasm formats

## Functions

The CosmWasm precompile exposes the following functions:

### Transaction Functions

<Warning>The `instantiate()` function has been disabled by [Prop 115](https://www.mintscan.io/sei/proposals/115) and will revert. It is omitted from this reference. The ABI in `@sei-js/precompiles` may still expose it for backwards compatibility, but calling it on-chain will fail.</Warning>

```solidity theme={"dark"}
/// Executes some message on a CosmWasm contract.
/// @param contractAddress The Sei address of the contract to execute.
/// @param msg The msg to send for execution. The format is specified by the contract code.
/// @param coins Any non-sei denominations that the contract requires for execution.
/// @return response The execution response from the CosmWasm contract.
function execute(
    string memory contractAddress,
    bytes memory msg,
    bytes memory coins
) payable external returns (bytes memory response);

struct ExecuteMsg {
    string contractAddress;
    bytes msg;
    bytes coins;
}

/// Executes collection of messages on CosmWasm contracts.
/// @param executeMsgs Array of execution messages to process.
/// @return responses The execution responses collection from the CosmWasm contracts.
function execute_batch(
    ExecuteMsg[] memory executeMsgs
) payable external returns (bytes[] memory responses);
```

### Query Functions

```solidity theme={"dark"}
/// Queries a CosmWasm contract.
/// @param contractAddress The Sei address of the contract to query.
/// @param req The query request object. The format is specified by the contract code.
/// @return response The response from the CosmWasm contract.
function query(
    string memory contractAddress,
    bytes memory req
) external view returns (bytes memory response);
```

## Using the Precompile

### Setup

#### Prerequisites

Before getting started, ensure you have:

* **Node.js** (v18 or higher)
* **npm** or **yarn** package manager
* **EVM-compatible wallet**
* **SEI tokens** for gas and contract operations

#### Install Dependencies

Install the required packages for interacting with Sei precompiles:

```bash theme={"dark"}
# Install ethers.js for smart contract interactions
npm install ethers

# Install Sei EVM bindings for precompile addresses and ABIs
npm install @sei-js/precompiles@2.1.2
```

#### Import Precompile Components

```typescript theme={"dark"}
// Import CosmWasm precompile address and ABI
// View the entire ABI here: https://github.com/sei-protocol/sei-chain/tree/main/precompiles/wasmd
import { WASM_PRECOMPILE_ABI, WASM_PRECOMPILE_ADDRESS } from '@sei-js/precompiles';
import { ethers } from 'ethers';
```

<Info> **Precompile Address:** The CosmWasm precompile is deployed at `0x0000000000000000000000000000000000001002` </Info>

### Contract Initialization

Set up your provider, signer, and contract instance:

```typescript theme={"dark"}
// Using EVM-compatible wallet as the signer and provider
const provider = new ethers.BrowserProvider(window.ethereum);
await provider.send('eth_requestAccounts', []);
const signer = await provider.getSigner();

// Create a contract instance for the CosmWasm precompile
const cosmwasm = new ethers.Contract(WASM_PRECOMPILE_ADDRESS, WASM_PRECOMPILE_ABI, signer);
```

## Critical: Understanding Message Formats

One of the most important concepts to understand when working with the Sei CosmWasm precompile:

### CosmWasm Message Structure

The CosmWasm precompile requires **JSON-encoded messages** that conform to each contract's specific schema:

| Function          | Input/Output          | Format Type | Example                                     |
| ----------------- | --------------------- | ----------- | ------------------------------------------- |
| `execute()`       | msg parameter (input) | JSON bytes  | `ethers.toUtf8Bytes(jsonString)`            |
| `query()`         | req parameter (input) | JSON bytes  | `ethers.toUtf8Bytes(jsonString)`            |
| **All functions** | response (output)     | JSON bytes  | `JSON.parse(ethers.toUtf8String(response))` |

### How Message Encoding Works

**All CosmWasm functions require JSON-encoded byte arrays:**

* `execute()` - accepts execution message as JSON bytes
* `query()` - accepts query message as JSON bytes

**Native Token Handling:**

* Use `msg.value` for SEI amounts
* Use `coins` parameter for other denominations (encoded as JSON bytes)

### Best Practice: Message Encoding Helpers

When working with CosmWasm messages, use proper JSON encoding:

```typescript theme={"dark"}
// Helper functions for message encoding
class CosmWasmMessageEncoder {
  // Encode execute message
  static encodeExecuteMsg(msg: object): Uint8Array {
    return ethers.toUtf8Bytes(JSON.stringify(msg));
  }

  // Encode query message
  static encodeQueryMsg(msg: object): Uint8Array {
    return ethers.toUtf8Bytes(JSON.stringify(msg));
  }

  // Encode coins for non-SEI denominations
  static encodeCoins(coins: Array<{ denom: string; amount: string }>): Uint8Array {
    if (coins.length === 0) return new Uint8Array();
    return ethers.toUtf8Bytes(JSON.stringify(coins));
  }

  // Decode response bytes to JSON
  static decodeResponse(responseBytes: Uint8Array): any {
    const jsonString = ethers.toUtf8String(responseBytes);
    return JSON.parse(jsonString);
  }
}

// Usage examples
const executeMsg = CosmWasmMessageEncoder.encodeExecuteMsg({
  transfer: {
    recipient: 'sei1...',
    amount: '1000000'
  }
});

const queryMsg = CosmWasmMessageEncoder.encodeQueryMsg({
  balance: { address: 'sei1...' }
});
```

## Message Format Helpers

Use these helper functions to handle CosmWasm message formatting:

```typescript theme={"dark"}
// Helper functions for CosmWasm message handling
class CosmWasmHelper {
  // Create execute message bytes
  static createExecuteMsg(msgObject: any): Uint8Array {
    return ethers.toUtf8Bytes(JSON.stringify(msgObject));
  }

  // Create query message bytes
  static createQueryMsg(msgObject: any): Uint8Array {
    return ethers.toUtf8Bytes(JSON.stringify(msgObject));
  }

  // Create coins array for non-SEI denominations
  static createCoins(coins: Array<{ denom: string; amount: string }>): Uint8Array {
    if (!coins || coins.length === 0) {
      return ethers.toUtf8Bytes('[]');
    }
    return ethers.toUtf8Bytes(JSON.stringify(coins));
  }

  // Parse response from CosmWasm contract
  static parseResponse(responseBytes: string | Uint8Array): any {
    try {
      const jsonString = typeof responseBytes === 'string' ? responseBytes : ethers.toUtf8String(responseBytes);
      return JSON.parse(jsonString);
    } catch (error) {
      console.error('Failed to parse CosmWasm response:', error);
      return null;
    }
  }
}

// Usage examples
const executeMsg = CosmWasmHelper.createExecuteMsg({
  mint: {
    recipient: 'sei1recipient...',
    amount: '1000000'
  }
});

const coins = CosmWasmHelper.createCoins([{ denom: 'uusdc', amount: '1000000' }]);
```

## Step-by-Step Guide: Using the CosmWasm Precompile

### Execute a CosmWasm Contract

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Execute a transfer on a CW20 token contract
    const contractAddress = 'sei1contract...'; // Your CosmWasm contract address

    // Create execute message for CW20 transfer
    const executeMsg = CosmWasmHelper.createExecuteMsg({
      transfer: {
        recipient: 'sei1recipient...',
        amount: '1000000' // 1 token with 6 decimals
      }
    });

    // No additional coins needed for this execution
    const coins = CosmWasmHelper.createCoins([]);

    const tx = await cosmwasm.execute(contractAddress, executeMsg, coins);

    const receipt = await tx.wait();
    console.log('Transfer executed:', receipt);

    // Parse the response if needed
    const response = CosmWasmHelper.parseResponse(receipt.logs[0].data);
    console.log('Execution response:', response);
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract CosmWasmExecutor {
        ICosmWasm constant COSMWASM = ICosmWasm(0x0000000000000000000000000000000000001002);

        event ContractExecuted(string contractAddress, bytes response);

        function executeContract(
            string memory contractAddress,
            bytes memory msg,
            bytes memory coins
        ) external payable {
            bytes memory response = COSMWASM.execute{value: msg.value}(
                contractAddress,
                msg,
                coins
            );

            emit ContractExecuted(contractAddress, response);
        }
    }
    ```
  </Tab>
</Tabs>

### Execute Batch Operations

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Execute multiple operations in a single transaction
    const contract1 = 'sei1contract1...';
    const contract2 = 'sei1contract2...';

    // Create multiple execute messages
    const executeMsg1 = CosmWasmHelper.createExecuteMsg({
      transfer: {
        recipient: 'sei1recipient1...',
        amount: '500000'
      }
    });

    const executeMsg2 = CosmWasmHelper.createExecuteMsg({
      mint: {
        recipient: 'sei1recipient2...',
        amount: '1000000'
      }
    });

    // Create batch execution array
    const executeMsgs = [
      {
        contractAddress: contract1,
        msg: executeMsg1,
        coins: CosmWasmHelper.createCoins([])
      },
      {
        contractAddress: contract2,
        msg: executeMsg2,
        coins: CosmWasmHelper.createCoins([])
      }
    ];

    const tx = await cosmwasm.execute_batch(executeMsgs);
    const receipt = await tx.wait();

    console.log('Batch execution completed:', receipt);
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract BatchExecutor {
        ICosmWasm constant COSMWASM = ICosmWasm(0x0000000000000000000000000000000000001002);

        function executeBatch(
            ICosmWasm.ExecuteMsg[] memory executeMsgs
        ) external payable {
            bytes[] memory responses = COSMWASM.execute_batch{value: msg.value}(executeMsgs);

            // Process responses as needed
            for (uint i = 0; i < responses.length; i++) {
                // Handle each response
                emit BatchResponseReceived(i, responses[i]);
            }
        }

        event BatchResponseReceived(uint index, bytes response);
    }
    ```
  </Tab>
</Tabs>

### Query a CosmWasm Contract

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    // Query balance of a CW20 token
    const contractAddress = 'sei1contract...';
    const userAddress = 'sei1user...';

    // Create query message
    const queryMsg = CosmWasmHelper.createQueryMsg({
      balance: { address: userAddress }
    });

    try {
      const responseBytes = await cosmwasm.query(contractAddress, queryMsg);
      const response = CosmWasmHelper.parseResponse(responseBytes);

      console.log('User balance:', response.balance);

      // Query token info
      const tokenInfoMsg = CosmWasmHelper.createQueryMsg({ token_info: {} });
      const tokenInfoBytes = await cosmwasm.query(contractAddress, tokenInfoMsg);
      const tokenInfo = CosmWasmHelper.parseResponse(tokenInfoBytes);

      console.log('Token info:', {
        name: tokenInfo.name,
        symbol: tokenInfo.symbol,
        decimals: tokenInfo.decimals,
        total_supply: tokenInfo.total_supply
      });
    } catch (error) {
      console.error('Query failed:', error);
    }
    ```
  </Tab>

  <Tab title="Solidity">
    ```solidity theme={"dark"}
    contract CosmWasmQuery {
        ICosmWasm constant COSMWASM = ICosmWasm(0x0000000000000000000000000000000000001002);

        function queryContract(
            string memory contractAddress,
            bytes memory queryMsg
        ) external view returns (bytes memory) {
            return COSMWASM.query(contractAddress, queryMsg);
        }

        // Helper to query and decode in one call (requires additional parsing logic)
        function queryBalance(
            string memory contractAddress,
            string memory userAddress
        ) external view returns (bytes memory) {
            // This would require JSON parsing in Solidity, which is complex
            // Better to handle parsing off-chain
            bytes memory queryMsg = abi.encode('{"balance":{"address":"', userAddress, '"}}');
            return COSMWASM.query(contractAddress, queryMsg);
        }
    }
    ```
  </Tab>
</Tabs>

<Warning> **Query Limitations:** CosmWasm queries are read-only operations and don't consume gas, but parsing JSON responses in Solidity is complex. Consider handling response parsing off-chain. </Warning>

## Advanced Usage Examples

### Cross-Runtime DeFi Integration

```typescript theme={"dark"}
async function crossRuntimeDeFiOperation(cosmwasmDexContract: string, evmTokenContract: string, amount: string) {
  try {
    // 1. Execute swap on CosmWasm DEX
    const swapMsg = CosmWasmHelper.createExecuteMsg({
      swap: {
        offer_asset: {
          info: { native_token: { denom: 'usei' } },
          amount: amount
        },
        belief_price: '1.0'
      }
    });

    const swapTx = await cosmwasm.execute(cosmwasmDexContract, swapMsg, CosmWasmHelper.createCoins([]), { value: ethers.parseEther(amount) });

    await swapTx.wait();
    console.log('CosmWasm swap completed');

    // 2. Query swap result
    const balanceMsg = CosmWasmHelper.createQueryMsg({
      balance: { address: await signer.getAddress() }
    });

    const balanceResponse = await cosmwasm.query(cosmwasmDexContract, balanceMsg);
    const balance = CosmWasmHelper.parseResponse(balanceResponse);

    console.log('New balance after swap:', balance);

    return balance;
  } catch (error) {
    console.error('Cross-runtime operation failed:', error);
    throw error;
  }
}
```

### Complete Integration Example

<Tabs>
  <Tab title="JavaScript">
    ```typescript theme={"dark"}
    async function cosmwasmExample() {
      // Setup
      const provider = new ethers.BrowserProvider(window.ethereum);
      await provider.send('eth_requestAccounts', []);
      const signer = await provider.getSigner();
      const cosmwasm = new ethers.Contract(WASM_PRECOMPILE_ADDRESS, WASM_PRECOMPILE_ABI, signer);

      const userAddress = await signer.getAddress();

      // Replace with the address of an existing CosmWasm contract you want to interact with.
      const contractAddress = 'sei1contract...';

      try {
        // 1. Execute mint operation against an existing contract
        console.log('=== Minting Tokens ===');
        const mintMsg = CosmWasmHelper.createExecuteMsg({
          mint: {
            recipient: 'sei1recipient...',
            amount: '1000000000' // 1000 tokens
          }
        });

        const mintTx = await cosmwasm.execute(contractAddress, mintMsg, CosmWasmHelper.createCoins([]));
        await mintTx.wait();
        console.log('Tokens minted successfully');

        // 2. Query token information
        console.log('=== Querying Token Info ===');
        const tokenInfoMsg = CosmWasmHelper.createQueryMsg({ token_info: {} });
        const tokenInfoBytes = await cosmwasm.query(contractAddress, tokenInfoMsg);
        const tokenInfo = CosmWasmHelper.parseResponse(tokenInfoBytes);

        console.log('Token Info:', {
          name: tokenInfo.name,
          symbol: tokenInfo.symbol,
          decimals: tokenInfo.decimals,
          total_supply: tokenInfo.total_supply
        });

        // 3. Query user balance
        const balanceMsg = CosmWasmHelper.createQueryMsg({
          balance: { address: 'sei1recipient...' }
        });
        const balanceBytes = await cosmwasm.query(contractAddress, balanceMsg);
        const balance = CosmWasmHelper.parseResponse(balanceBytes);

        console.log('User balance:', balance.balance);

        // 4. Execute batch transfer
        console.log('=== Batch Transfer ===');
        const batchMsgs = [
          {
            contractAddress: contractAddress,
            msg: CosmWasmHelper.createExecuteMsg({
              transfer: {
                recipient: 'sei1addr1...',
                amount: '100000000' // 100 tokens
              }
            }),
            coins: CosmWasmHelper.createCoins([])
          },
          {
            contractAddress: contractAddress,
            msg: CosmWasmHelper.createExecuteMsg({
              transfer: {
                recipient: 'sei1addr2...',
                amount: '200000000' // 200 tokens
              }
            }),
            coins: CosmWasmHelper.createCoins([])
          }
        ];

        const batchTx = await cosmwasm.execute_batch(batchMsgs);
        await batchTx.wait();
        console.log('Batch transfer completed');
      } catch (error) {
        console.error('CosmWasm operation failed:', error);
      }
    }
    ```
  </Tab>

  <Tab title="Solidity">
    **Contract Example**

    ```solidity theme={"dark"}
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;

    interface ICosmWasmPrecompile {
        struct ExecuteMsg {
            string contractAddress;
            bytes msg;
            bytes coins;
        }

        function execute(
            string memory contractAddress,
            bytes memory msg,
            bytes memory coins
        ) payable external returns (bytes memory response);

        function execute_batch(
            ExecuteMsg[] memory executeMsgs
        ) payable external returns (bytes[] memory responses);

        function query(
            string memory contractAddress,
            bytes memory req
        ) external view returns (bytes memory response);
    }

    contract CosmWasmBridge {
        ICosmWasmPrecompile constant COSMWASM = ICosmWasmPrecompile(0x0000000000000000000000000000000000001002);

        event ContractExecuted(string contractAddress, bytes response);
        event BatchExecuted(uint256 msgCount);
        event QueryExecuted(string contractAddress, bytes response);

        // Execute a message on a CosmWasm contract
        function executeContract(
            string memory contractAddress,
            bytes memory executeMsg,
            bytes memory coins
        ) external payable returns (bytes memory) {
            bytes memory response = COSMWASM.execute{value: msg.value}(
                contractAddress,
                executeMsg,
                coins
            );

            emit ContractExecuted(contractAddress, response);
            return response;
        }

        // Execute multiple messages in batch
        function executeBatch(
            ICosmWasmPrecompile.ExecuteMsg[] memory executeMsgs
        ) external payable returns (bytes[] memory) {
            bytes[] memory responses = COSMWASM.execute_batch{value: msg.value}(executeMsgs);

            emit BatchExecuted(executeMsgs.length);
            return responses;
        }

        // Query a CosmWasm contract
        function queryContract(
            string memory contractAddress,
            bytes memory queryMsg
        ) external view returns (bytes memory) {
            bytes memory response = COSMWASM.query(contractAddress, queryMsg);

            // Note: Cannot emit events in view functions
            return response;
        }

        // Helper function to create execute message struct
        function createExecuteMsg(
            string memory contractAddress,
            bytes memory msg,
            bytes memory coins
        ) public pure returns (ICosmWasmPrecompile.ExecuteMsg memory) {
            return ICosmWasmPrecompile.ExecuteMsg({
                contractAddress: contractAddress,
                msg: msg,
                coins: coins
            });
        }
    }
    ```

    <Info> **Note:** This contract acts as a bridge between EVM and existing CosmWasm contracts. Message encoding/decoding should be handled client-side for complex operations. </Info>

    **Client Integration Example**

    ```javascript theme={"dark"}
    import { network } from 'hardhat';

    // Hardhat 3 exposes ethers through a network connection rather than a global import
    const { ethers } = await network.create();

    async function main() {
      const [deployer] = await ethers.getSigners();
      console.log('Deploying contracts with the account:', deployer.address);

      const CosmWasmBridge = await ethers.getContractFactory('CosmWasmBridge');
      console.log('Deploying CosmWasmBridge...');
      const bridge = await CosmWasmBridge.deploy();

      await bridge.waitForDeployment();
      console.log('CosmWasmBridge deployed to:', await bridge.getAddress());

      // Address of an existing CosmWasm contract you want to interact with
      const contractAddress = 'sei1contract...';

      // Encode an execute message (e.g., a CW20 transfer)
      const executeMsg = ethers.toUtf8Bytes(
        JSON.stringify({
          transfer: {
            recipient: 'sei1recipient...',
            amount: '1000000'
          }
        })
      );

      const coins = ethers.toUtf8Bytes('[]');

      const tx = await bridge.executeContract(contractAddress, executeMsg, coins);
      const receipt = await tx.wait();

      console.log('Execute transaction hash:', tx.hash);

      const event = receipt.logs.find((log) => log.topics[0] === ethers.id('ContractExecuted(string,bytes)'));

      if (event) {
        console.log('CosmWasm execute call confirmed');
      }
    }

    main().catch((error) => {
      console.error(error);
      process.exitCode = 1;
    });
    ```
  </Tab>
</Tabs>

## Troubleshooting

### Common Issues and Solutions

#### Message Encoding Issues

```typescript theme={"dark"}
// Ensure proper JSON encoding for messages
const msg = {
  transfer: {
    recipient: 'sei1...',
    amount: '1000000' // Use strings for large numbers
  }
};

// Correct encoding
const encodedMsg = ethers.toUtf8Bytes(JSON.stringify(msg));

// Incorrect - will cause parsing errors
const incorrectMsg = ethers.toUtf8Bytes('invalid json');
```

### Error Code Reference

| Error                  | Cause                           | Solution                            |
| ---------------------- | ------------------------------- | ----------------------------------- |
| `invalid json`         | Malformed JSON message          | Validate JSON before encoding       |
| `contract not found`   | Invalid contract address        | Verify contract address format      |
| `insufficient funds`   | Not enough tokens for operation | Check balance and reduce amount     |
| `execution failed`     | Contract execution error        | Check contract state and parameters |
| `unauthorized`         | Insufficient permissions        | Check admin/owner permissions       |
| `query parsing failed` | Invalid query message format    | Match contract's query schema       |

## Important Notes

<Info> Remember the key rule: All CosmWasm messages must be properly JSON-encoded as bytes, and contract schemas vary by implementation! </Info>

### Message Format Requirements

* **JSON Encoding:** All messages must be valid JSON encoded as UTF-8 bytes, invalid JSON will cause transaction failures
* **Schema Compliance:** Messages must match the contract's expected format
* **Type Safety:** Use proper data types as expected by the contract

### Contract Address Format

* Use valid Sei contract addresses with `sei1...` prefix
* These are Cosmos-format addresses, not EVM addresses
* **Contract Existence:** Verify contracts exist before calling

### Cross-Runtime Considerations

* **State Isolation:** CosmWasm and EVM contracts have separate state
* **Gas Estimation:** CosmWasm operations may require different gas calculations
* **Error Handling:** Failed CosmWasm operations revert the entire EVM transaction
* **Native Token Handling:** Use `msg.value` for SEI, `coins` for other denominations
* **Batch Limitations:** Large batches may hit gas limits

### Best Practices

* Always validate JSON messages before sending
* Handle response parsing carefully, especially for complex data structures
* Use batch operations for multiple related calls to save gas
* Query contracts before executing to verify state when possible

<Info>View the CosmWasm precompile source code and the contract ABI [here](https://github.com/sei-protocol/sei-chain/tree/main/precompiles/wasmd).</Info>

---

URL: https://docs.sei.io/evm/sei-js

# @sei-js SDK

> A complete TypeScript SDK for building decentralized applications on Sei Network

@sei-js is the complete TypeScript SDK for building applications on Sei Network. Whether you're creating DeFi protocols, NFT marketplaces, or blockchain games, @sei-js provides everything you need to ship faster.

**Works with your favorite tools:** Sei is fully EVM-compatible, so you can use Viem, Ethers.js, Foundry, Hardhat, and all your existing Ethereum development tools without any changes. @sei-js extends these tools with Sei-specific features like precompiled contracts and optimized wallet connections.

<Info>@sei-js is open source. Contribute at [github.com/sei-protocol/sei-js](https://github.com/sei-protocol/sei-js).</Info>

## Why @sei-js?

* **Complete TypeScript support** — Full type safety for every function, contract interaction, and API response. Catch errors at compile time.
* **Production ready** — Battle-tested components used by major applications in the Sei ecosystem.
* **Optimized for Sei** — Take advantage of Sei's fast finality, low gas, and native features.

## Package Ecosystem

### [@sei-js/precompiles](/evm/precompiles)

Access Sei's precompiled contracts directly from your EVM applications. Interact with native blockchain functions for staking, governance, and more.

```bash theme={"dark"}
npm install @sei-js/precompiles
```

### [@sei-js/create-sei](/evm/sei-js/create-sei)

Bootstrap new Sei projects with pre-configured templates and tooling. Scaffold production-ready dApps in seconds.

```bash theme={"dark"}
npx @sei-js/create-sei app
```

### [@sei-js/sei-global-wallet](/evm/sei-global-wallet)

Connect to any Sei-compatible wallet using the EIP-6963 standard. Provides a cross-application embedded wallet experience with social login.

```bash theme={"dark"}
npm install @sei-js/sei-global-wallet
```

### [@sei-js/ledger](/evm/sei-js/ledger)

Secure transaction signing with Ledger hardware wallets. Provides TypeScript helper functions for address derivation and offline Amino signing via the SEI Ledger app.

```bash theme={"dark"}
npm install @sei-js/ledger
```

### [@sei-js/registry](/evm/sei-js/registry)

Chain constants, RPC endpoints, token metadata, gas parameters, and wallet info — a typed reference for Sei network configuration.

```bash theme={"dark"}
npm install @sei-js/registry
```

### [@sei-js/mcp-server](/ai/mcp-server)

Teach Claude, Cursor, Windsurf, or any LLM to interact with the Sei blockchain through the Model Context Protocol.

```bash theme={"dark"}
npx @sei-js/mcp-server
```

## Quick Start

Generate a new Sei application using the CLI tool:

```bash theme={"dark"}
npx @sei-js/create-sei app
cd app
npm install
npm run dev
```

This creates a production-ready project with TypeScript, wallet connections, and Sei network integration out of the box. See the [Scaffold Sei](/evm/sei-js/create-sei) page for details on available templates and options.

## Examples

End-to-end code examples using viem and ethers with Sei:

<CardGroup cols={2}>
  <Card title="viem Quickstart" icon="bolt" href="/evm/evm-parity/examples/viem-quickstart">
    Read chain data, send transactions, and interact with contracts in a Node.js script or backend.
  </Card>

  <Card title="ethers v6 Quickstart" icon="bolt" href="/evm/evm-parity/examples/ethers-quickstart">
    The same patterns using ethers v6, including browser provider and event listening.
  </Card>

  <Card title="Wagmi + React" icon="react" href="/evm/evm-parity/examples/wagmi-react">
    Connect wallets, read balances, and write contracts in a React app using Wagmi hooks.
  </Card>

  <Card title="ERC-20 Interaction" icon="coins" href="/evm/evm-parity/examples/erc20">
    Read metadata, check balances, transfer tokens, approve spenders, and query transfer history.
  </Card>

  <Card title="ERC-721 Interaction" icon="image" href="/evm/evm-parity/examples/erc721">
    Check ownership, transfer NFTs, manage approvals, and watch transfer events.
  </Card>

  <Card title="ERC-1155 Interaction" icon="grid-2" href="/evm/evm-parity/examples/erc1155">
    Batch balance queries, single and batch transfers, operator approvals, and event watching.
  </Card>

  <Card title="Multicall" icon="layer-group" href="/evm/evm-parity/examples/multicall">
    Batch multiple contract reads into a single RPC call with Multicall3 and viem/ethers/wagmi.
  </Card>

  <Card title="Pointer Contracts" icon="arrow-right-arrow-left" href="/evm/evm-parity/examples/pointer-contracts">
    Look up CW20/CW721/native pointer addresses and interact with CosmWasm tokens via ERC interfaces.
  </Card>

  <Card title="Sei Precompiles" icon="hexagon-nodes" href="/evm/evm-parity/examples/sei-precompiles">
    Native balances, staking, rewards, and governance voting from JavaScript.
  </Card>

  <Card title="Deploy and Verify" icon="rocket" href="/evm/evm-parity/examples/deploy-verify">
    Deploy contracts with viem, ethers, Foundry, or Hardhat and verify on Seiscan via Sourcify.
  </Card>

  <Card title="Transaction Lifecycle" icon="arrow-progress" href="/evm/evm-parity/examples/transaction-lifecycle">
    Send transactions, wait for receipts, and decode event logs.
  </Card>

  <Card title="Error Handling" icon="triangle-exclamation" href="/evm/evm-parity/examples/error-handling">
    Decode reverts, handle wallet rejections, and retry transient RPC failures.
  </Card>
</CardGroup>

## Community & Support

* [Discord](https://discord.gg/sei) — Join the Sei developer community
* [GitHub Issues](https://github.com/sei-protocol/sei-js/issues) — Report bugs and request features

---

URL: https://docs.sei.io/evm/sei-js/create-sei

# Scaffold Sei

> CLI tool for scaffolding production-ready Sei applications with pre-configured templates

`@sei-js/create-sei` is a CLI tool that scaffolds production-ready Sei dApps in seconds. Quickly spin up templates with Next.js, modern wallet integration, and TypeScript support.

```bash theme={"dark"}
npx @sei-js/create-sei app --name my-sei-app
```

Every generated project includes wallet connections, contract interactions, TypeScript, Tailwind CSS, Mantine UI, Biome for formatting, and responsive layouts — no additional setup required.

## Quick Start

You don't need to install `@sei-js/create-sei` globally. Use it directly with npx or pnpm:

<Tabs>
  <Tab title="npx">
    ```bash theme={"dark"}
    npx @sei-js/create-sei app --name my-sei-app
    ```
  </Tab>

  <Tab title="pnpm">
    ```bash theme={"dark"}
    pnpm create @sei-js/sei app --name my-sei-app
    ```
  </Tab>
</Tabs>

## Interactive Setup

<Steps>
  <Step title="Run the CLI">
    Execute the create-sei command with your project name:

    ```bash theme={"dark"}
    npx @sei-js/create-sei app
    ```
  </Step>

  <Step title="Install and run">
    ```bash theme={"dark"}
    cd my-sei-app
    npm install
    npm run dev
    ```
  </Step>

  <Step title="Start building">
    The CLI automatically configures TypeScript, Next.js, Tailwind CSS, Biome formatting, Mantine UI components, and Git initialization.
  </Step>
</Steps>

### CLI Options

| Command                 | Description                                           |
| ----------------------- | ----------------------------------------------------- |
| `app`                   | Create a new Sei dApp                                 |
| `app --name <name>`     | Specify a project name (must be a valid package name) |
| `app --extension <ext>` | Add an optional extension to your project             |
| `list-extensions`       | List available extensions                             |

## Default Template

The default template creates a **Next.js + Wagmi (EVM)** application — a production-ready Next.js app with Wagmi for type-safe Ethereum wallet connections and blockchain interactions. Includes built-in support for MetaMask, WalletConnect, Coinbase Wallet, and other popular wallets.

**Tech Stack:** Next.js 14, Wagmi v2, Viem, TanStack Query, Tailwind CSS

```bash theme={"dark"}
npx @sei-js/create-sei app --name my-sei-app
```

## Extensions

Enhance your project with additional functionality using extensions.

### List Available Extensions

```bash theme={"dark"}
npx @sei-js/create-sei list-extensions
```

### Precompiles Extension

Add Sei precompile contract integration with examples for querying native blockchain data like token supply, staking info, and governance proposals.

```bash theme={"dark"}
npx @sei-js/create-sei app --name my-sei-precompile-app --extension precompiles
```

Includes Bank precompile, Staking precompile, and Governance precompile examples.

## What's Included

After running the CLI, you'll have a fully configured Sei dApp ready for development:

* **Project structure** — Organized file structure with components, hooks, and utilities
* **Wallet integration** — Pre-configured wallet connections and hooks
* **Development tools** — TypeScript, Biome, Mantine UI, and Tailwind CSS with sensible defaults
* **Sei network integration** — Built-in network configuration and contract interaction examples

<Info>**Prerequisites:** Node.js v18 or higher is required. Use `node --version` to verify your installation.</Info>

## Troubleshooting

* **Node version conflicts** — Use `nvm use` to switch to the correct Node.js version
* **Permission errors** — Avoid using `sudo` with npm. Use `nvm` or fix npm permissions
* **Network timeouts** — Try switching to a different registry: `npm config set registry https://registry.npmjs.org/`

---

URL: https://docs.sei.io/evm/sei-js/ledger

# @sei-js/ledger

> TypeScript library for SEI Ledger app helper functions — address derivation, Amino signing, and CosmJS integration

The `@sei-js/ledger` package provides TypeScript helper functions for the SEI Ledger hardware wallet app. It enables address derivation and offline Amino signing for Cosmos-side transactions on Sei.

<Info>For EVM-side transaction signing with Ethers.js, see the [Ledger Setup (EVM)](/evm/ledger-ethers) guide instead.</Info>

## Installation

```bash theme={"dark"}
npm install @sei-js/ledger
```

## Hardware Requirements

* Ledger Nano S Plus, Nano X, or compatible device
* **SEI app** installed on the Ledger device (via Ledger Live Manager)
* USB or Bluetooth connection to your computer

## Core Functions

### createTransportAndApp

Creates a transport connection and app instance for communicating with the Ledger device.

```typescript theme={"dark"}
import { createTransportAndApp } from '@sei-js/ledger';

const { transport, app } = await createTransportAndApp();
```

**Returns:** `Promise<{ transport: Transport, app: SeiApp }>`

### getAddresses

Retrieves both EVM and Cosmos addresses from the Ledger device for a given derivation path.

```typescript theme={"dark"}
import { createTransportAndApp, getAddresses } from '@sei-js/ledger';

const { app } = await createTransportAndApp();
const { evmAddress, nativeAddress } = await getAddresses(app, "m/44'/60'/0'/0/0");

console.log('EVM address:', evmAddress);
console.log('Sei address:', nativeAddress);
```

**Parameters:**

| Parameter | Type     | Description                                    |
| --------- | -------- | ---------------------------------------------- |
| `app`     | `SeiApp` | Ledger Sei app instance                        |
| `path`    | `string` | HD derivation path (e.g. `"m/44'/60'/0'/0/0"`) |

**Returns:** `Promise<{ evmAddress: string, nativeAddress: string }>`

### SeiLedgerOfflineAminoSigner

A signer class compatible with CosmJS that enables offline Amino signing via Ledger.

```typescript theme={"dark"}
import { SeiLedgerOfflineAminoSigner } from '@sei-js/ledger';

const ledgerSigner = new SeiLedgerOfflineAminoSigner(app, "m/44'/60'/0'/0/0");
```

**Constructor Parameters:**

| Parameter | Type     | Description             |
| --------- | -------- | ----------------------- |
| `app`     | `SeiApp` | Ledger Sei app instance |
| `path`    | `string` | HD derivation path      |

#### getAccounts

Retrieves account information from the Ledger device.

```typescript theme={"dark"}
const accounts = await ledgerSigner.getAccounts();
// [{ address: 'sei1...', pubkey: { type: 'tendermint/PubKeySecp256k1', value: '...' } }]
```

#### signAmino

Signs a transaction document using the Ledger device. The device will prompt for physical confirmation.

```typescript theme={"dark"}
import { StdSignDoc } from '@cosmjs/amino';

const signDoc: StdSignDoc = {
  /* your transaction document */
};
const { signed, signature } = await ledgerSigner.signAmino('sei1...', signDoc);
```

## Complete Example: Delegating Tokens

```typescript theme={"dark"}
import { coins, SigningStargateClient, StdFee } from '@cosmjs/stargate';
import { createTransportAndApp, getAddresses, SeiLedgerOfflineAminoSigner } from '@sei-js/ledger';

async function delegateWithLedger() {
  const rpcUrl = 'https://rpc-testnet.sei-apis.com/';
  const path = "m/44'/60'/0'/0/0";

  const { app } = await createTransportAndApp();
  const { nativeAddress } = await getAddresses(app, path);
  const ledgerSigner = new SeiLedgerOfflineAminoSigner(app, path);

  const client = await SigningStargateClient.connectWithSigner(rpcUrl, ledgerSigner);

  const msgDelegate = {
    typeUrl: '/cosmos.staking.v1beta1.MsgDelegate',
    value: {
      delegatorAddress: nativeAddress,
      validatorAddress: 'seivaloper1...',
      amount: coins(500, 'usei')
    }
  };

  const fee: StdFee = {
    amount: [{ denom: 'usei', amount: '20000' }],
    gas: '200000'
  };

  const result = await client.signAndBroadcast(nativeAddress, [msgDelegate], fee, 'Delegation via Ledger');

  console.log('Broadcast result:', result);
}

delegateWithLedger();
```

## Security

* Ensure your Ledger device is genuine and purchased from official sources
* Always verify transaction details on the Ledger screen before confirming
* Keep your Ledger firmware and the SEI app updated
* Store your recovery phrase securely and never share it

---

URL: https://docs.sei.io/evm/sei-js/registry

# @sei-js/registry

> Chain constants, RPC endpoints, token metadata, and wallet info for Sei Network

`@sei-js/registry` is a typed reference package for Sei chain metadata — RPC endpoints, token lists, gas parameters, wallet info, and more. It pulls from the official [sei-protocol/chain-registry](https://github.com/sei-protocol/chain-registry) and is kept in sync as a git submodule.

## Install

```bash theme={"dark"}
npm install @sei-js/registry
```

## CHAIN\_IDS

Canonical chain IDs for each Sei network:

```ts theme={"dark"}
import { CHAIN_IDS } from '@sei-js/registry';

CHAIN_IDS.mainnet  // 'pacific-1'
CHAIN_IDS.testnet  // 'atlantic-2'
CHAIN_IDS.devnet   // 'arctic-1'
```

Use these constants anywhere you reference a Sei network by chain ID to avoid hardcoding strings.

## NETWORKS

RPC, REST, gRPC, EVM RPC, WebSocket, and explorer endpoints for each network:

```ts theme={"dark"}
import { NETWORKS } from '@sei-js/registry';

const mainnet = NETWORKS['pacific-1'];

// Pick the first available EVM RPC endpoint
const evmRpc = mainnet.evm_rpc?.[0].url;

// Pick the first available WebSocket endpoint
const evmWs = mainnet.evm_ws?.[0].url;

// Pick a Cosmos REST endpoint
const rest = mainnet.rest[0].url;
```

Each entry has `provider` (name) and `url` fields. Multiple providers are listed per category — iterate to implement fallback logic:

```ts theme={"dark"}
async function getWorkingRpc(network: 'pacific-1' | 'atlantic-2' | 'arctic-1') {
  const endpoints = NETWORKS[network].evm_rpc ?? [];
  for (const endpoint of endpoints) {
    try {
      const res = await fetch(endpoint.url, {
        method: 'POST',
        headers: { 'content-type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', method: 'eth_blockNumber', params: [], id: 1 }),
      });
      if (res.ok) return endpoint.url;
    } catch {}
  }
  throw new Error(`No working EVM RPC found for ${network}`);
}
```

## TOKEN\_LIST

Token registry per network — name, symbol, base denom, decimal exponents, images, and CoinGecko IDs:

```ts theme={"dark"}
import { TOKEN_LIST } from '@sei-js/registry';

// All tokens on mainnet
const tokens = TOKEN_LIST['pacific-1'];

// Find SEI
const sei = tokens.find(t => t.symbol === 'SEI');
// { base: 'usei', display: 'sei', denom_units: [{ denom: 'usei', exponent: 0 }, { denom: 'sei', exponent: 6 }] }

// Convert a raw usei amount to display amount
function toDisplayAmount(usei: bigint, token: typeof sei): string {
  const exp = token.denom_units.find(u => u.denom === token.display)?.exponent ?? 6;
  return (Number(usei) / 10 ** exp).toString();
}

// Look up a token by its on-chain denom
function findByDenom(denom: string) {
  return TOKEN_LIST['pacific-1'].find(t => t.base === denom);
}
```

Each token includes an `images` object with `png` and `svg` URLs suitable for display in wallet UIs or token pickers.

## GAS\_INFO

Minimum gas price and module-specific adjustments per network:

```ts theme={"dark"}
import { GAS_INFO } from '@sei-js/registry';

const { denom, min_gas_price } = GAS_INFO['pacific-1'];
// denom: 'usei', min_gas_price: 0.02

// Calculate the minimum fee for a given gas limit
function minFee(gasLimit: number): string {
  const { min_gas_price, denom } = GAS_INFO['pacific-1'];
  return `${Math.ceil(gasLimit * min_gas_price)}${denom}`;
}
```

<Info>The `min_gas_price` here is the Cosmos-side gas floor. For EVM transactions, always use `eth_gasPrice` or `eth_estimateGas` — the on-chain EVM gas floor is governed separately and can change. See [Gas and Fees](/evm/evm-parity/gas-and-fees).</Info>

## CHAIN\_INFO

Basic chain metadata: daemon name, Bech32 prefix, HD path coin type, and supported wallets:

```ts theme={"dark"}
import { CHAIN_INFO } from '@sei-js/registry';

CHAIN_INFO.bech32_prefix     // 'sei'
CHAIN_INFO.slip44            // 118  (HD wallet coin type)
CHAIN_INFO.supported_wallets // ['fin', 'compass', 'leap', 'keplr']

// Validate a Cosmos-side Sei address format
function isSeiAddress(address: string): boolean {
  return address.startsWith(CHAIN_INFO.bech32_prefix + '1');
}

// Derive the HD path for key generation
const path = `m/44'/${CHAIN_INFO.slip44}'/0'/0/0`;
```

## WALLETS

Wallet metadata including icons, URLs, and EVM/native capability flags:

```ts theme={"dark"}
import { WALLETS } from '@sei-js/registry';

// All wallets that support EVM
const evmWallets = WALLETS.filter(w => w.capabilities.includes('evm'));

// Find a specific wallet for displaying its icon
const compass = WALLETS.find(w => w.identifier === 'compass');
// { name: 'Compass Wallet', icon: 'https://...jpeg', url: 'https://compasswallet.io/', capabilities: ['native', 'evm'] }
```

Useful for building wallet selector UIs that show icons and filter by capability.

## Network Reference

| Constant     | `pacific-1` (mainnet)           | `atlantic-2` (testnet)           | `arctic-1` (devnet)            |
| ------------ | ------------------------------- | -------------------------------- | ------------------------------ |
| Chain ID     | `pacific-1`                     | `atlantic-2`                     | `arctic-1`                     |
| EVM Chain ID | 1329                            | 1328                             | 713715                         |
| EVM RPC      | `NETWORKS['pacific-1'].evm_rpc` | `NETWORKS['atlantic-2'].evm_rpc` | `NETWORKS['arctic-1'].evm_rpc` |
| EVM WS       | `NETWORKS['pacific-1'].evm_ws`  | `NETWORKS['atlantic-2'].evm_ws`  | `NETWORKS['arctic-1'].evm_ws`  |

---

URL: https://docs.sei.io/evm/videos

# Video Tutorials

> Watch video tutorials covering Sei EVM development, smart contract tooling, precompiles, and more.

A collection of video walkthroughs to help you get started building on Sei.

## EVM Development

### Sei EVM Overview

An introduction to developing on Sei's parallelized EVM, covering smart contract languages, tooling, and key concepts.

<iframe width="100%" height="450" src="https://www.youtube.com/embed/5-kRJYmURSI" title="Sei EVM Development" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen style={{ borderRadius: '8px', marginTop: '12px' }} />

Related docs: [EVM General](/evm/evm-general) · [EVM with Hardhat](/evm/evm-hardhat)

***

### Development with Foundry

Step-by-step guide to setting up Foundry for Sei, creating contracts with OpenZeppelin, and deploying to testnet and mainnet.

<iframe width="100%" height="450" src="https://www.youtube.com/embed/3jL52xdW_fY" title="Development With Foundry" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen style={{ borderRadius: '8px', marginTop: '12px' }} />

Related docs: [EVM with Foundry](/evm/evm-foundry)

***

## Precompiles

### Staking Precompile

Learn how to interact with Sei's native staking module directly from EVM smart contracts — delegation, undelegation, redelegation, and validator queries.

<iframe width="100%" height="450" src="https://www.youtube.com/embed/k9tpkMQk6kU" title="Sei Staking Precompile" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen style={{ borderRadius: '8px', marginTop: '12px' }} />

Related docs: [Staking Precompile](/evm/precompiles/staking)

***

### Distribution Precompile

Manage staking rewards and validator commissions through the distribution precompile — withdraw rewards, set withdrawal addresses, and more.

<iframe width="100%" height="450" src="https://www.youtube.com/embed/oUC29Kygvao" title="Sei Distribution Precompile" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen style={{ borderRadius: '8px', marginTop: '12px' }} />

Related docs: [Distribution Precompile](/evm/precompiles/distribution)

---

URL: https://docs.sei.io/evm/evm-parity/examples/viem-quickstart

# viem Quickstart

> Using viem with Sei in a Node.js script, CLI tool, or backend service

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

# viem Quickstart

This example shows how to use viem with Sei outside of a React context — in a Node.js script, CLI tool, or backend service. For React apps, see [wagmi](https://wagmi.sh) and the [frontend guide](/evm/building-a-frontend).

## Install

```bash theme={"dark"}
npm install viem
```

These snippets are TypeScript. Run any of them with no separate build step using [`tsx`](https://www.npmjs.com/package/tsx) (Node 18+):

```bash theme={"dark"}
npx tsx script.ts
```

## Public Client

A public client handles all read-only operations.

```ts theme={"dark"}
import { createPublicClient, http } from 'viem';
import { sei } from 'viem/chains';

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

To use a custom RPC endpoint, pass the URL to `http()`:

```ts theme={"dark"}
const client = createPublicClient({
  chain: sei,
  transport: http('https://evm-rpc.sei-apis.com'),
});
```

## Reading Chain Data

This is the first milestone — it needs no private key.

```ts theme={"dark"}
import { formatEther } from 'viem';

// Any valid Sei EVM address — swap in your own
const address = '0x0000000000000000000000000000000000000000';

const blockNumber = await client.getBlockNumber(); // bigint
console.log('Block number:', blockNumber);

const balance = await client.getBalance({ address }); // bigint, wei
console.log('Balance (SEI):', formatEther(balance));

const nonce = await client.getTransactionCount({ address }); // number
console.log('Nonce:', nonce);
```

**You're done when you see:**

```text theme={"dark"}
Block number: 148203117n
Balance (SEI): 12.5
Nonce: 7
```

The exact numbers are illustrative — your block number and balance will differ. Note the trailing `n`: `getBlockNumber()` and `getBalance()` return `bigint`, while `getTransactionCount()` returns a `number`.

## Try it live

Run these read-only calls against Sei mainnet right now — no install, no private key. They're the same reads the script above performs, issued straight from your browser.

<RunSnippet method="eth_blockNumber" network="mainnet" title="eth_blockNumber" description="Latest committed block on pacific-1. Returns a hex quantity — the widget decodes it to decimal below the response." />

<RunSnippet method="eth_chainId" network="mainnet" title="eth_chainId" description="Sei mainnet EVM chain ID. 0x531 = 1329." />

<RunSnippet method="eth_getBalance" params={["0x0000000000000000000000000000000000000000", "latest"]} network="mainnet" title="eth_getBalance" description="Balance in wei of the example address at the latest block — swap in any address." />

## Edit and run

The buttons above issue raw JSON-RPC. To run the full viem code from this page — imports, a public client, several reads — edit and re-run it live in the sandbox below. No install, no wallet, no key. Note the sandbox reads **testnet** (atlantic-2), so its block number and balances won't match the mainnet reads above:

<SandboxEmbed kind="codesandbox" src="https://codesandbox.io/embed/cgtx45?view=split&hidenavigation=1&theme=dark" title="viem · read Sei testnet" description="A real viem public client reading Sei testnet (atlantic-2). Edit index.js and the preview re-runs." />

## Wallet Client

A wallet client handles signing and broadcasting transactions.

```ts theme={"dark"}
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { sei } from 'viem/chains';

const account = privateKeyToAccount('0xYourPrivateKey');

const walletClient = createWalletClient({
  account,
  chain: sei,
  transport: http(),
});
```

For browser use, replace `http()` with `custom(window.ethereum)` and call `walletClient.getAddresses()` to get the connected account.

## Sending a Transaction

Next step — this requires a funded account; get testnet SEI from the [faucet](/learn/faucet).

```ts theme={"dark"}
import { parseEther } from 'viem';

const hash = await walletClient.sendTransaction({
  to: '0xRecipient',
  value: parseEther('1'),
});

const receipt = await client.waitForTransactionReceipt({ hash });
// receipt is final immediately — Sei has instant finality
```

## Reading a Contract

```ts theme={"dark"}
import { parseAbi } from 'viem';

const abi = parseAbi(['function balanceOf(address owner) view returns (uint256)']);

const balance = await client.readContract({
  address: '0xTokenAddress',
  abi,
  functionName: 'balanceOf',
  args: ['0xYourAddress'],
});
```

## Writing to a Contract

```ts theme={"dark"}
const hash = await walletClient.writeContract({
  address: '0xTokenAddress',
  abi,
  functionName: 'transfer',
  args: ['0xRecipient', 1_000_000n],
});

const receipt = await client.waitForTransactionReceipt({ hash });
```

## Simulating Before Writing

```ts theme={"dark"}
const { result } = await client.simulateContract({
  address: '0xTokenAddress',
  abi,
  functionName: 'transfer',
  args: ['0xRecipient', 1_000_000n],
  account,
});

// If simulation succeeds, execute it
const hash = await walletClient.writeContract(result);
```

## Estimating Gas

Always use `estimateGas` rather than hard-coding values. SSTORE costs on Sei are governance-adjustable.

```ts theme={"dark"}
const gas = await client.estimateGas({
  account,
  to: '0xContractAddress',
  data: '0xCalldata',
});
```

## Next Steps

* [Python quickstart (web3.py)](/evm/python-quickstart) — the same first steps in Python
* [ERC-20 interaction](/evm/evm-parity/examples/erc20) — full token read/write examples
* [ERC-721 interaction](/evm/evm-parity/examples/erc721) — NFT ownership, transfers, and approvals
* [Pointer contracts](/evm/evm-parity/examples/pointer-contracts) — interact with CosmWasm tokens via ERC interfaces
* [WebSocket connections](/evm/evm-parity/websocket) — real-time block and event subscriptions

---

URL: https://docs.sei.io/evm/evm-parity/examples/ethers-quickstart

# ethers v6 Quickstart

> Using ethers v6 with Sei in a Node.js script or browser context

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

# ethers v6 Quickstart

This example covers ethers v6 with Sei. The patterns apply whether you are writing a Node.js script, a CLI tool, or a browser app.

## Install

```bash theme={"dark"}
npm install ethers
```

These snippets are TypeScript. Run any of them with no separate build step using [`tsx`](https://www.npmjs.com/package/tsx) (Node 18+):

```bash theme={"dark"}
npx tsx script.ts
```

## Read-Only Provider

```ts theme={"dark"}
import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
```

## Reading Chain Data

This is the first milestone — it needs no private key.

```ts theme={"dark"}
// Any valid Sei EVM address — swap in your own
const address = '0x0000000000000000000000000000000000000000';

const blockNumber = await provider.getBlockNumber(); // number
console.log('Block number:', blockNumber);

const balance = await provider.getBalance(address); // bigint, wei
console.log('Balance (SEI):', ethers.formatEther(balance));

const nonce = await provider.getTransactionCount(address); // number
console.log('Nonce:', nonce);
```

**You're done when you see:**

```text theme={"dark"}
Block number: 148203117
Balance (SEI): 12.5
Nonce: 7
```

The exact numbers are illustrative — your block number and balance will differ. `getBlockNumber()` and `getTransactionCount()` return a `number`, while `getBalance()` returns a `bigint` in wei (format it with `ethers.formatEther()`).

## Try it live

Run these read-only calls against Sei mainnet right now — no install, no private key. They're plain JSON-RPC, the same reads the script above performs.

<RunSnippet method="eth_blockNumber" network="mainnet" title="eth_blockNumber" />

<RunSnippet method="eth_getBalance" params={["0x0000000000000000000000000000000000000000", "latest"]} network="mainnet" title="eth_getBalance" description="Balance in wei of the example address at the latest block — swap in any address." />

## Edit and run

Edit and re-run the full ethers code from this page live in the browser — a real ethers v6 `JsonRpcProvider` reading Sei **testnet** (atlantic-2), so its block number and balances won't match the mainnet reads above:

<SandboxEmbed kind="codesandbox" src="https://codesandbox.io/embed/qs82lw?view=split&hidenavigation=1&theme=dark" title="ethers · read Sei testnet" description="A real ethers v6 provider reading Sei testnet (atlantic-2). Edit index.js and the preview re-runs." />

## Browser Provider

In a browser context, connect to the user's injected wallet:

```ts theme={"dark"}
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const address = await signer.getAddress();
```

## Wallet from Private Key

For scripts and backend services:

```ts theme={"dark"}
const wallet = new ethers.Wallet('0xYourPrivateKey', provider);
```

## Sending a Transaction

Next step — this requires a funded account; get testnet SEI from the [faucet](/learn/faucet).

```ts theme={"dark"}
const tx = await wallet.sendTransaction({
  to: '0xRecipient',
  value: ethers.parseEther('1'),
});

const receipt = await tx.wait();
// receipt is final immediately — Sei has instant finality
```

## Reading a Contract

```ts theme={"dark"}
const abi = ['function balanceOf(address owner) view returns (uint256)'];
const contract = new ethers.Contract('0xTokenAddress', abi, provider);

const balance = await contract.balanceOf('0xYourAddress');
```

## Writing to a Contract

Pass a signer (wallet or browser signer) to the contract constructor for write operations:

```ts theme={"dark"}
const contract = new ethers.Contract('0xTokenAddress', abi, wallet);

const tx = await contract.transfer('0xRecipient', 1_000_000n);
const receipt = await tx.wait();
```

## Estimating Gas

```ts theme={"dark"}
const gas = await provider.estimateGas({
  from: wallet.address,
  to: '0xContractAddress',
  data: '0xCalldata',
});
```

## Listening for Events

```ts theme={"dark"}
contract.on('Transfer', (from, to, value) => {
  console.log('Transfer:', { from, to, value });
});

// Stop listening
contract.off('Transfer');
```

## Next Steps

* [Python quickstart (web3.py)](/evm/python-quickstart) — the same first steps in Python
* [ERC-20 interaction](/evm/evm-parity/examples/erc20) — full token read/write examples
* [ERC-721 interaction](/evm/evm-parity/examples/erc721) — NFT ownership, transfers, and approvals
* [Pointer contracts](/evm/evm-parity/examples/pointer-contracts) — interact with CosmWasm tokens via ERC interfaces
* [WebSocket connections](/evm/evm-parity/websocket) — real-time block and event subscriptions

---

URL: https://docs.sei.io/evm/evm-parity/examples/wagmi-react

# Wagmi + React

> Connect wallets, read chain state, and write transactions in a React app on Sei using Wagmi

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

# Wagmi + React

[Wagmi](https://wagmi.sh) is the standard React library for EVM wallet connections and contract interactions. This page covers the essential patterns for a Sei frontend: configuration, wallet connect/disconnect, reading balances, and writing to contracts.

For Node.js scripts and backend services, see the [viem Quickstart](/evm/evm-parity/examples/viem-quickstart) instead.

## Try it live

The hooks below — `useBlockNumber`, `useBalance` — are thin wrappers over JSON-RPC reads. Here are those same reads issued directly against Sei mainnet, no wallet connection required, so you can see the data your components will render.

<RunSnippet method="eth_blockNumber" network="mainnet" title="eth_blockNumber" description="What useBlockNumber() resolves to — the latest committed block on pacific-1." />

<RunSnippet method="eth_getBalance" params={['0x0000000000000000000000000000000000000000', 'latest']} network="mainnet" title="eth_getBalance" description="What useBalance({ address }) reads under the hood — wei balance at the latest block. Swap in any address." />

## Install

```bash theme={"dark"}
npm install wagmi viem @sei-js/precompiles @tanstack/react-query
```

## Configuration

Configure Wagmi with the Sei chain and your preferred wallet connectors:

```ts theme={"dark"}
// wagmi.config.ts
import { createConfig, http } from 'wagmi';
import { injected, walletConnect } from 'wagmi/connectors';
import { sei, seiTestnet } from 'viem/chains';

export const config = createConfig({
  chains: [sei, seiTestnet],
  connectors: [
    injected(),
    walletConnect({ projectId: 'YOUR_WALLETCONNECT_PROJECT_ID' }),
  ],
  transports: {
    [sei.id]: http(),
    [seiTestnet.id]: http(),
  },
});
```

## Provider Setup

Wrap your app with `WagmiProvider` and `QueryClientProvider`:

```tsx theme={"dark"}
// App.tsx
import { WagmiProvider } from 'wagmi';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { config } from './wagmi.config';

const queryClient = new QueryClient();

export function App() {
  return (
    <WagmiProvider config={config}>
      <QueryClientProvider client={queryClient}>
        <YourApp />
      </QueryClientProvider>
    </WagmiProvider>
  );
}
```

## Connecting a Wallet

```tsx theme={"dark"}
import { useConnect, useDisconnect, useAccount } from 'wagmi';

export function WalletButton() {
  const { connectors, connect } = useConnect();
  const { disconnect } = useDisconnect();
  const { address, isConnected } = useAccount();

  if (isConnected) {
    return (
      <div>
        <span>{address}</span>
        <button onClick={() => disconnect()}>Disconnect</button>
      </div>
    );
  }

  return (
    <div>
      {connectors.map((connector) => (
        <button key={connector.id} onClick={() => connect({ connector })}>
          Connect {connector.name}
        </button>
      ))}
    </div>
  );
}
```

## Reading the Native SEI Balance

```tsx theme={"dark"}
import { useBalance, useAccount } from 'wagmi';
import { formatEther } from 'viem';

export function SeiBalance() {
  const { address } = useAccount();
  const { data: balance } = useBalance({ address });

  if (!balance) return null;

  return (
    <p>Balance: {formatEther(balance.value)} SEI</p>
  );
}
```

## Reading a Contract

```tsx theme={"dark"}
import { useReadContract } from 'wagmi';
import { parseAbi } from 'viem';

const ERC20_ABI = parseAbi([
  'function balanceOf(address owner) view returns (uint256)',
  'function symbol() view returns (string)',
]);

export function TokenBalance({ tokenAddress, owner }: { tokenAddress: `0x${string}`; owner: `0x${string}` }) {
  const { data: balance } = useReadContract({
    address: tokenAddress,
    abi: ERC20_ABI,
    functionName: 'balanceOf',
    args: [owner],
  });

  const { data: symbol } = useReadContract({
    address: tokenAddress,
    abi: ERC20_ABI,
    functionName: 'symbol',
  });

  if (balance === undefined) return null;

  return <p>{balance.toString()} {symbol}</p>;
}
```

## Writing to a Contract

Use `useWriteContract` for transactions that mutate state, and `useWaitForTransactionReceipt` to track confirmation:

```tsx theme={"dark"}
import { useWriteContract, useWaitForTransactionReceipt } from 'wagmi';
import { parseAbi, parseUnits } from 'viem';

const ERC20_ABI = parseAbi([
  'function transfer(address to, uint256 amount) returns (bool)',
]);

export function TransferButton({ tokenAddress }: { tokenAddress: `0x${string}` }) {
  const { writeContract, data: hash, isPending } = useWriteContract();
  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash });

  function handleTransfer() {
    writeContract({
      address: tokenAddress,
      abi: ERC20_ABI,
      functionName: 'transfer',
      args: ['0xRecipient', parseUnits('10', 18)],
    });
  }

  return (
    <div>
      <button onClick={handleTransfer} disabled={isPending || isConfirming}>
        {isPending ? 'Confirm in wallet...' : isConfirming ? 'Confirming...' : 'Transfer'}
      </button>
      {isSuccess && <p>Transfer confirmed.</p>}
    </div>
  );
}
```

<Info>Sei has instant finality — `useWaitForTransactionReceipt` resolves as soon as the transaction is included in a block. A single confirmation is final. See [Finality](/evm/evm-parity/finality).</Info>

## Watching the Connected Chain

```tsx theme={"dark"}
import { useChainId, useSwitchChain } from 'wagmi';
import { sei, seiTestnet } from 'viem/chains';

export function NetworkSwitcher() {
  const chainId = useChainId();
  const { switchChain } = useSwitchChain();

  return (
    <div>
      <p>Connected to chain {chainId}</p>
      {chainId !== sei.id && (
        <button onClick={() => switchChain({ chainId: sei.id })}>
          Switch to Sei Mainnet
        </button>
      )}
    </div>
  );
}
```

---

URL: https://docs.sei.io/evm/evm-parity/examples/erc20

# ERC-20 Interaction

> Reading and writing ERC-20 tokens on Sei with viem and ethers

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

# ERC-20 Interaction

Standard ERC-20 contracts work on Sei without modification. This page covers the common read and write operations using viem and ethers.

## Try it: deploy an ERC-20

Compile and deploy a real ERC-20 to Sei testnet from the browser — the Remix sandbox preloads an OpenZeppelin-based `DemoToken`. Then point the read/write patterns below at your deployed address.

First, add Sei testnet to your wallet:

<AddSeiButton network="testnet" label="Add Sei testnet" />

In Remix, compile under **Solidity Compiler**, then **Deploy & Run** with **Environment** set to **Injected Provider — MetaMask**.

<SandboxEmbed kind="remix" src="https://remix.ethereum.org/?#activate=solidity,fileManager&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVApwcmFnbWEgc29saWRpdHkgXjAuOC4yNDsKCmltcG9ydCAiQG9wZW56ZXBwZWxpbi9jb250cmFjdHMvdG9rZW4vRVJDMjAvRVJDMjAuc29sIjsKCmNvbnRyYWN0IERlbW9Ub2tlbiBpcyBFUkMyMCB7CiAgICBjb25zdHJ1Y3RvcigpIEVSQzIwKCJEZW1vIFRva2VuIiwgIkRFTU8iKSB7CiAgICAgICAgX21pbnQobXNnLnNlbmRlciwgMV8wMDBfMDAwICogMTAgKiogZGVjaW1hbHMoKSk7CiAgICB9Cn0" title="DemoToken (ERC-20) · deploy to Sei testnet" description="Remix IDE with an OpenZeppelin ERC-20 preloaded. Compile in-browser and deploy to Sei testnet." />

## Setup

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, createWalletClient, http, parseAbi } from 'viem';
  import { privateKeyToAccount } from 'viem/accounts';
  import { sei } from 'viem/chains';

  const client = createPublicClient({ chain: sei, transport: http() });
  const account = privateKeyToAccount('0xYourPrivateKey');
  const walletClient = createWalletClient({ account, chain: sei, transport: http() });

  const ERC20_ABI = parseAbi([
    'function name() view returns (string)',
    'function symbol() view returns (string)',
    'function decimals() view returns (uint8)',
    'function totalSupply() view returns (uint256)',
    'function balanceOf(address owner) view returns (uint256)',
    'function allowance(address owner, address spender) view returns (uint256)',
    'function transfer(address to, uint256 amount) returns (bool)',
    'function approve(address spender, uint256 amount) returns (bool)',
    'function transferFrom(address from, address to, uint256 amount) returns (bool)',
    'event Transfer(address indexed from, address indexed to, uint256 value)',
    'event Approval(address indexed owner, address indexed spender, uint256 value)',
  ]);

  const TOKEN = '0xTokenAddress';
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
  const wallet = new ethers.Wallet('0xYourPrivateKey', provider);

  const ERC20_ABI = [
    'function name() view returns (string)',
    'function symbol() view returns (string)',
    'function decimals() view returns (uint8)',
    'function totalSupply() view returns (uint256)',
    'function balanceOf(address owner) view returns (uint256)',
    'function allowance(address owner, address spender) view returns (uint256)',
    'function transfer(address to, uint256 amount) returns (bool)',
    'function approve(address spender, uint256 amount) returns (bool)',
    'function transferFrom(address from, address to, uint256 amount) returns (bool)',
    'event Transfer(address indexed from, address indexed to, uint256 value)',
    'event Approval(address indexed owner, address indexed spender, uint256 value)',
  ];

  const TOKEN = '0xTokenAddress';
  const readContract = new ethers.Contract(TOKEN, ERC20_ABI, provider);
  const writeContract = new ethers.Contract(TOKEN, ERC20_ABI, wallet);
  ```
</CodeGroup>

## Reading Token Metadata

<CodeGroup>
  ```ts viem theme={"dark"}
  const [name, symbol, decimals, totalSupply] = await Promise.all([
    client.readContract({ address: TOKEN, abi: ERC20_ABI, functionName: 'name' }),
    client.readContract({ address: TOKEN, abi: ERC20_ABI, functionName: 'symbol' }),
    client.readContract({ address: TOKEN, abi: ERC20_ABI, functionName: 'decimals' }),
    client.readContract({ address: TOKEN, abi: ERC20_ABI, functionName: 'totalSupply' }),
  ]);
  ```

  ```ts ethers theme={"dark"}
  const [name, symbol, decimals, totalSupply] = await Promise.all([
    readContract.name(),
    readContract.symbol(),
    readContract.decimals(),
    readContract.totalSupply(),
  ]);
  ```
</CodeGroup>

## Reading Balances and Allowances

<CodeGroup>
  ```ts viem theme={"dark"}
  const balance = await client.readContract({
    address: TOKEN,
    abi: ERC20_ABI,
    functionName: 'balanceOf',
    args: ['0xOwnerAddress'],
  });

  const allowance = await client.readContract({
    address: TOKEN,
    abi: ERC20_ABI,
    functionName: 'allowance',
    args: ['0xOwnerAddress', '0xSpenderAddress'],
  });
  ```

  ```ts ethers theme={"dark"}
  const balance = await readContract.balanceOf('0xOwnerAddress');
  const allowance = await readContract.allowance('0xOwnerAddress', '0xSpenderAddress');
  ```
</CodeGroup>

## Transferring Tokens

<CodeGroup>
  ```ts viem theme={"dark"}
  import { parseUnits } from 'viem';

  const hash = await walletClient.writeContract({
    address: TOKEN,
    abi: ERC20_ABI,
    functionName: 'transfer',
    args: ['0xRecipient', parseUnits('10', 18)],
  });

  const receipt = await client.waitForTransactionReceipt({ hash });
  ```

  ```ts ethers theme={"dark"}
  const tx = await writeContract.transfer('0xRecipient', ethers.parseUnits('10', 18));
  const receipt = await tx.wait();
  ```
</CodeGroup>

## Approving a Spender

<CodeGroup>
  ```ts viem theme={"dark"}
  import { parseUnits, maxUint256 } from 'viem';

  // Approve a specific amount
  const hash = await walletClient.writeContract({
    address: TOKEN,
    abi: ERC20_ABI,
    functionName: 'approve',
    args: ['0xSpenderAddress', parseUnits('100', 18)],
  });

  // Or approve max (unlimited)
  const hashMax = await walletClient.writeContract({
    address: TOKEN,
    abi: ERC20_ABI,
    functionName: 'approve',
    args: ['0xSpenderAddress', maxUint256],
  });
  ```

  ```ts ethers theme={"dark"}
  // Approve a specific amount
  const tx = await writeContract.approve('0xSpenderAddress', ethers.parseUnits('100', 18));

  // Or approve max (unlimited)
  const txMax = await writeContract.approve('0xSpenderAddress', ethers.MaxUint256);
  ```
</CodeGroup>

## Watching Transfer Events

<CodeGroup>
  ```ts viem theme={"dark"}
  const unwatch = client.watchContractEvent({
    address: TOKEN,
    abi: ERC20_ABI,
    eventName: 'Transfer',
    onLogs: (logs) => {
      logs.forEach(({ args }) => {
        console.log(`${args.from} → ${args.to}: ${args.value}`);
      });
    },
  });

  // Stop watching
  unwatch();
  ```

  ```ts ethers theme={"dark"}
  readContract.on('Transfer', (from, to, value) => {
    console.log(`${from} → ${to}: ${value}`);
  });

  // Stop watching
  readContract.off('Transfer');
  ```
</CodeGroup>

## Fetching Historical Transfers

<CodeGroup>
  ```ts viem theme={"dark"}
  const logs = await client.getContractEvents({
    address: TOKEN,
    abi: ERC20_ABI,
    eventName: 'Transfer',
    fromBlock: 0n,
    toBlock: 'latest',
  });
  ```

  ```ts ethers theme={"dark"}
  const filter = readContract.filters.Transfer();
  const logs = await readContract.queryFilter(filter, 0, 'latest');
  ```
</CodeGroup>

## CosmWasm Token Compatibility

CW20 tokens on Sei have ERC-20 pointer contracts that expose the standard ERC-20 interface. You can use all of the patterns above against a CW20 pointer address. See [Pointer Contracts](/evm/evm-parity/examples/pointer-contracts) for how to look up the pointer address.

---

URL: https://docs.sei.io/evm/evm-parity/examples/erc721

# ERC-721 Interaction

> Reading and writing ERC-721 NFTs on Sei with viem and ethers

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

# ERC-721 Interaction

Standard ERC-721 contracts work on Sei without modification. This page covers reading token ownership, transferring NFTs, and managing approvals.

## Try it: deploy an ERC-721

Compile and deploy a real ERC-721 to Sei testnet from the browser — the Remix sandbox preloads an OpenZeppelin-based `DemoNFT` with a public `mint()`. Then point the patterns below at your deployed address.

First, add Sei testnet to your wallet:

<AddSeiButton network="testnet" label="Add Sei testnet" />

In Remix, compile under **Solidity Compiler**, then **Deploy & Run** with **Environment** set to **Injected Provider — MetaMask**.

<SandboxEmbed kind="remix" src="https://remix.ethereum.org/?#activate=solidity,fileManager&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVApwcmFnbWEgc29saWRpdHkgXjAuOC4yNDsKCmltcG9ydCAiQG9wZW56ZXBwZWxpbi9jb250cmFjdHMvdG9rZW4vRVJDNzIxL0VSQzcyMS5zb2wiOwoKY29udHJhY3QgRGVtb05GVCBpcyBFUkM3MjEgewogICAgdWludDI1NiBwdWJsaWMgbmV4dElkOwogICAgY29uc3RydWN0b3IoKSBFUkM3MjEoIkRlbW8gTkZUIiwgIkRORlQiKSB7fQogICAgZnVuY3Rpb24gbWludCgpIGV4dGVybmFsIHsgX3NhZmVNaW50KG1zZy5zZW5kZXIsIG5leHRJZCsrKTsgfQp9" title="DemoNFT (ERC-721) · deploy to Sei testnet" description="Remix IDE with an OpenZeppelin ERC-721 preloaded. Compile in-browser and deploy to Sei testnet." />

## Setup

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, createWalletClient, http, parseAbi } from 'viem';
  import { privateKeyToAccount } from 'viem/accounts';
  import { sei } from 'viem/chains';

  const client = createPublicClient({ chain: sei, transport: http() });
  const account = privateKeyToAccount('0xYourPrivateKey');
  const walletClient = createWalletClient({ account, chain: sei, transport: http() });

  const ERC721_ABI = parseAbi([
    'function name() view returns (string)',
    'function symbol() view returns (string)',
    'function totalSupply() view returns (uint256)',
    'function balanceOf(address owner) view returns (uint256)',
    'function ownerOf(uint256 tokenId) view returns (address)',
    'function tokenURI(uint256 tokenId) view returns (string)',
    'function getApproved(uint256 tokenId) view returns (address)',
    'function isApprovedForAll(address owner, address operator) view returns (bool)',
    'function approve(address to, uint256 tokenId)',
    'function setApprovalForAll(address operator, bool approved)',
    'function transferFrom(address from, address to, uint256 tokenId)',
    'function safeTransferFrom(address from, address to, uint256 tokenId)',
    'event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)',
    'event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)',
  ]);

  const NFT = '0xNFTContractAddress';
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
  const wallet = new ethers.Wallet('0xYourPrivateKey', provider);

  const ERC721_ABI = [
    'function name() view returns (string)',
    'function symbol() view returns (string)',
    'function totalSupply() view returns (uint256)',
    'function balanceOf(address owner) view returns (uint256)',
    'function ownerOf(uint256 tokenId) view returns (address)',
    'function tokenURI(uint256 tokenId) view returns (string)',
    'function getApproved(uint256 tokenId) view returns (address)',
    'function isApprovedForAll(address owner, address operator) view returns (bool)',
    'function approve(address to, uint256 tokenId)',
    'function setApprovalForAll(address operator, bool approved)',
    'function transferFrom(address from, address to, uint256 tokenId)',
    'function safeTransferFrom(address from, address to, uint256 tokenId)',
    'event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)',
    'event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)',
  ];

  const NFT = '0xNFTContractAddress';
  const readContract = new ethers.Contract(NFT, ERC721_ABI, provider);
  const writeContract = new ethers.Contract(NFT, ERC721_ABI, wallet);
  ```
</CodeGroup>

## Reading Token Data

<CodeGroup>
  ```ts viem theme={"dark"}
  const tokenId = 1n;

  const [owner, uri, approved] = await Promise.all([
    client.readContract({ address: NFT, abi: ERC721_ABI, functionName: 'ownerOf', args: [tokenId] }),
    client.readContract({ address: NFT, abi: ERC721_ABI, functionName: 'tokenURI', args: [tokenId] }),
    client.readContract({ address: NFT, abi: ERC721_ABI, functionName: 'getApproved', args: [tokenId] }),
  ]);
  ```

  ```ts ethers theme={"dark"}
  const tokenId = 1n;

  const [owner, uri, approved] = await Promise.all([
    readContract.ownerOf(tokenId),
    readContract.tokenURI(tokenId),
    readContract.getApproved(tokenId),
  ]);
  ```
</CodeGroup>

## Checking Ownership Count

<CodeGroup>
  ```ts viem theme={"dark"}
  const balance = await client.readContract({
    address: NFT,
    abi: ERC721_ABI,
    functionName: 'balanceOf',
    args: ['0xOwnerAddress'],
  });
  ```

  ```ts ethers theme={"dark"}
  const balance = await readContract.balanceOf('0xOwnerAddress');
  ```
</CodeGroup>

## Transferring an NFT

<CodeGroup>
  ```ts viem theme={"dark"}
  const hash = await walletClient.writeContract({
    address: NFT,
    abi: ERC721_ABI,
    functionName: 'safeTransferFrom',
    args: [account.address, '0xRecipient', 1n],
  });

  const receipt = await client.waitForTransactionReceipt({ hash });
  ```

  ```ts ethers theme={"dark"}
  const tx = await writeContract.safeTransferFrom(wallet.address, '0xRecipient', 1n);
  const receipt = await tx.wait();
  ```
</CodeGroup>

## Approving a Single Token

<CodeGroup>
  ```ts viem theme={"dark"}
  const hash = await walletClient.writeContract({
    address: NFT,
    abi: ERC721_ABI,
    functionName: 'approve',
    args: ['0xOperatorAddress', 1n],
  });
  ```

  ```ts ethers theme={"dark"}
  const tx = await writeContract.approve('0xOperatorAddress', 1n);
  ```
</CodeGroup>

## Approving All Tokens (Operator)

<CodeGroup>
  ```ts viem theme={"dark"}
  // Grant operator approval
  const hash = await walletClient.writeContract({
    address: NFT,
    abi: ERC721_ABI,
    functionName: 'setApprovalForAll',
    args: ['0xOperatorAddress', true],
  });

  // Revoke
  const revokeHash = await walletClient.writeContract({
    address: NFT,
    abi: ERC721_ABI,
    functionName: 'setApprovalForAll',
    args: ['0xOperatorAddress', false],
  });
  ```

  ```ts ethers theme={"dark"}
  // Grant operator approval
  const tx = await writeContract.setApprovalForAll('0xOperatorAddress', true);

  // Revoke
  const revokeTx = await writeContract.setApprovalForAll('0xOperatorAddress', false);
  ```
</CodeGroup>

## Watching Transfer Events

<CodeGroup>
  ```ts viem theme={"dark"}
  const unwatch = client.watchContractEvent({
    address: NFT,
    abi: ERC721_ABI,
    eventName: 'Transfer',
    onLogs: (logs) => {
      logs.forEach(({ args }) => {
        console.log(`Token ${args.tokenId}: ${args.from} → ${args.to}`);
      });
    },
  });

  // Stop watching
  unwatch();
  ```

  ```ts ethers theme={"dark"}
  readContract.on('Transfer', (from, to, tokenId) => {
    console.log(`Token ${tokenId}: ${from} → ${to}`);
  });

  // Stop watching
  readContract.off('Transfer');
  ```
</CodeGroup>

## CosmWasm NFT Compatibility

CW721 tokens on Sei have ERC-721 pointer contracts that expose the standard ERC-721 interface. You can use all of the patterns above against a CW721 pointer address. See [Pointer Contracts](/evm/evm-parity/examples/pointer-contracts) for how to look up the pointer address.

---

URL: https://docs.sei.io/evm/evm-parity/examples/erc1155

# ERC-1155 Interaction

> Reading and writing ERC-1155 multi-token contracts on Sei with viem and ethers

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

# ERC-1155 Interaction

ERC-1155 is the multi-token standard — a single contract can hold both fungible tokens (like gold coins in a game) and non-fungible tokens (like unique items), with efficient batch operations built in. Standard ERC-1155 contracts work on Sei without modification.

## Try it: deploy an ERC-1155

Compile and deploy a real ERC-1155 to Sei testnet from the browser — the Remix sandbox preloads an OpenZeppelin-based `DemoMultiToken` with a public `mint(id, amount)`. Then point the read/write patterns below at your deployed address.

First, add Sei testnet to your wallet:

<AddSeiButton network="testnet" label="Add Sei testnet" />

In Remix, compile under **Solidity Compiler**, then **Deploy & Run** with **Environment** set to **Injected Provider — MetaMask**.

<SandboxEmbed kind="remix" src="https://remix.ethereum.org/?#activate=solidity,fileManager&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVApwcmFnbWEgc29saWRpdHkgXjAuOC4yNDsKCmltcG9ydCAiQG9wZW56ZXBwZWxpbi9jb250cmFjdHMvdG9rZW4vRVJDMTE1NS9FUkMxMTU1LnNvbCI7Cgpjb250cmFjdCBEZW1vTXVsdGlUb2tlbiBpcyBFUkMxMTU1IHsKICAgIHVpbnQyNTYgcHVibGljIGNvbnN0YW50IEdPTEQgPSAwOwogICAgdWludDI1NiBwdWJsaWMgY29uc3RhbnQgU0lMVkVSID0gMTsKICAgIGNvbnN0cnVjdG9yKCkgRVJDMTE1NSgiaHR0cHM6Ly9leGFtcGxlLmNvbS9hcGkvaXRlbS97aWR9Lmpzb24iKSB7fQogICAgZnVuY3Rpb24gbWludCh1aW50MjU2IGlkLCB1aW50MjU2IGFtb3VudCkgZXh0ZXJuYWwgeyBfbWludChtc2cuc2VuZGVyLCBpZCwgYW1vdW50LCAiIik7IH0KfQo" title="DemoMultiToken (ERC-1155) · deploy to Sei testnet" description="Remix IDE with an OpenZeppelin ERC-1155 preloaded. Compile in-browser and deploy to Sei testnet." />

## Setup

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, createWalletClient, http, parseAbi } from 'viem';
  import { privateKeyToAccount } from 'viem/accounts';
  import { sei } from 'viem/chains';

  const client = createPublicClient({ chain: sei, transport: http() });
  const account = privateKeyToAccount('0xYourPrivateKey');
  const walletClient = createWalletClient({ account, chain: sei, transport: http() });

  const ERC1155_ABI = parseAbi([
    'function balanceOf(address account, uint256 id) view returns (uint256)',
    'function balanceOfBatch(address[] accounts, uint256[] ids) view returns (uint256[])',
    'function isApprovedForAll(address account, address operator) view returns (bool)',
    'function setApprovalForAll(address operator, bool approved)',
    'function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data)',
    'function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data)',
    'function uri(uint256 id) view returns (string)',
    'event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value)',
    'event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values)',
  ]);

  const CONTRACT = '0xContractAddress';
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
  const wallet = new ethers.Wallet('0xYourPrivateKey', provider);

  const ERC1155_ABI = [
    'function balanceOf(address account, uint256 id) view returns (uint256)',
    'function balanceOfBatch(address[] accounts, uint256[] ids) view returns (uint256[])',
    'function isApprovedForAll(address account, address operator) view returns (bool)',
    'function setApprovalForAll(address operator, bool approved)',
    'function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data)',
    'function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data)',
    'function uri(uint256 id) view returns (string)',
    'event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value)',
    'event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values)',
  ];

  const CONTRACT = '0xContractAddress';
  const readContract = new ethers.Contract(CONTRACT, ERC1155_ABI, provider);
  const writeContract = new ethers.Contract(CONTRACT, ERC1155_ABI, wallet);
  ```
</CodeGroup>

## Reading a Single Balance

<CodeGroup>
  ```ts viem theme={"dark"}
  const balance = await client.readContract({
    address: CONTRACT,
    abi: ERC1155_ABI,
    functionName: 'balanceOf',
    args: ['0xOwnerAddress', 1n], // token ID 1
  });
  ```

  ```ts ethers theme={"dark"}
  const balance = await readContract.balanceOf('0xOwnerAddress', 1n);
  ```
</CodeGroup>

## Batch Balance Query

`balanceOfBatch` retrieves multiple owner/ID pairs in one call — the most efficient way to load a user's inventory:

<CodeGroup>
  ```ts viem theme={"dark"}
  const owners = ['0xOwner', '0xOwner', '0xOwner'] as const;
  const ids = [1n, 2n, 3n];

  const balances = await client.readContract({
    address: CONTRACT,
    abi: ERC1155_ABI,
    functionName: 'balanceOfBatch',
    args: [owners, ids],
  });
  // balances[0] = balance of token 1, balances[1] = token 2, etc.
  ```

  ```ts ethers theme={"dark"}
  const owners = ['0xOwner', '0xOwner', '0xOwner'];
  const ids = [1n, 2n, 3n];

  const balances = await readContract.balanceOfBatch(owners, ids);
  ```
</CodeGroup>

## Reading Token Metadata URI

```ts viem theme={"dark"}
const uri = await client.readContract({
  address: CONTRACT,
  abi: ERC1155_ABI,
  functionName: 'uri',
  args: [1n],
});
// URI often contains {id} — replace it with the hex token ID per ERC-1155 spec
const resolvedUri = uri.replace('{id}', (1n).toString(16).padStart(64, '0'));
```

## Transferring a Single Token

<CodeGroup>
  ```ts viem theme={"dark"}
  const hash = await walletClient.writeContract({
    address: CONTRACT,
    abi: ERC1155_ABI,
    functionName: 'safeTransferFrom',
    args: [account.address, '0xRecipient', 1n, 5n, '0x'], // transfer 5 of token ID 1
  });

  const receipt = await client.waitForTransactionReceipt({ hash });
  ```

  ```ts ethers theme={"dark"}
  const tx = await writeContract.safeTransferFrom(wallet.address, '0xRecipient', 1n, 5n, '0x');
  const receipt = await tx.wait();
  ```
</CodeGroup>

## Batch Transfer

Send multiple token IDs in a single transaction:

<CodeGroup>
  ```ts viem theme={"dark"}
  const hash = await walletClient.writeContract({
    address: CONTRACT,
    abi: ERC1155_ABI,
    functionName: 'safeBatchTransferFrom',
    args: [
      account.address,
      '0xRecipient',
      [1n, 2n, 3n],     // token IDs
      [5n, 10n, 1n],    // amounts
      '0x',
    ],
  });
  ```

  ```ts ethers theme={"dark"}
  const tx = await writeContract.safeBatchTransferFrom(
    wallet.address,
    '0xRecipient',
    [1n, 2n, 3n],
    [5n, 10n, 1n],
    '0x',
  );
  ```
</CodeGroup>

## Operator Approval

<CodeGroup>
  ```ts viem theme={"dark"}
  // Grant an operator permission to transfer all tokens
  const hash = await walletClient.writeContract({
    address: CONTRACT,
    abi: ERC1155_ABI,
    functionName: 'setApprovalForAll',
    args: ['0xOperatorAddress', true],
  });

  // Check approval status
  const isApproved = await client.readContract({
    address: CONTRACT,
    abi: ERC1155_ABI,
    functionName: 'isApprovedForAll',
    args: ['0xOwnerAddress', '0xOperatorAddress'],
  });
  ```

  ```ts ethers theme={"dark"}
  const tx = await writeContract.setApprovalForAll('0xOperatorAddress', true);

  const isApproved = await readContract.isApprovedForAll('0xOwnerAddress', '0xOperatorAddress');
  ```
</CodeGroup>

## Watching Transfer Events

<CodeGroup>
  ```ts viem theme={"dark"}
  // Watch single transfers
  const unwatch = client.watchContractEvent({
    address: CONTRACT,
    abi: ERC1155_ABI,
    eventName: 'TransferSingle',
    onLogs: (logs) => {
      logs.forEach(({ args }) => {
        console.log(`Token ${args.id}: ${args.from} → ${args.to}, amount: ${args.value}`);
      });
    },
  });

  // Watch batch transfers
  const unwatchBatch = client.watchContractEvent({
    address: CONTRACT,
    abi: ERC1155_ABI,
    eventName: 'TransferBatch',
    onLogs: (logs) => {
      logs.forEach(({ args }) => {
        console.log(`Batch from ${args.from} → ${args.to}:`, args.ids, args.values);
      });
    },
  });
  ```

  ```ts ethers theme={"dark"}
  readContract.on('TransferSingle', (operator, from, to, id, value) => {
    console.log(`Token ${id}: ${from} → ${to}, amount: ${value}`);
  });

  readContract.on('TransferBatch', (operator, from, to, ids, values) => {
    console.log(`Batch from ${from} → ${to}:`, ids, values);
  });
  ```
</CodeGroup>

---

URL: https://docs.sei.io/evm/evm-parity/examples/multicall

# Multicall

> Batch multiple contract reads into a single RPC call using Multicall3 on Sei

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

# Multicall

Multicall3 lets you batch multiple read calls into a single RPC round-trip, dramatically reducing latency for dashboards, portfolio pages, and any view that needs data from multiple contracts at once.

Multicall3 is deployed at `0xcA11bde05977b3631167028862bE2a173976CA11` on Sei mainnet and testnet — the same address as Ethereum.

## Try it live

Multicall3 is a normal contract — you can hit it with a single `eth_call` and no SDK. These run its two zero-argument helpers on Sei mainnet; the hex results decode to decimal below each response.

<RunSnippet method="eth_call" params={[{ to: '0xcA11bde05977b3631167028862bE2a173976CA11', data: '0x42cbb15c' }, 'latest']} network="mainnet" title="Multicall3.getBlockNumber()" description="Selector 0x42cbb15c on Multicall3 at 0xcA11…CA11 — returns the current block number." />

<RunSnippet method="eth_call" params={[{ to: '0xcA11bde05977b3631167028862bE2a173976CA11', data: '0x0f28c97d' }, 'latest']} network="mainnet" title="Multicall3.getCurrentBlockTimestamp()" description="Selector 0x0f28c97d — returns the latest block's Unix timestamp in seconds." />

## Batching ERC-20 Reads with viem

viem's `multicall` action wraps Multicall3 automatically:

```ts theme={"dark"}
import { createPublicClient, http, parseAbi } from 'viem';
import { sei } from 'viem/chains';

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

const ERC20_ABI = parseAbi([
  'function balanceOf(address owner) view returns (uint256)',
  'function symbol() view returns (string)',
  'function decimals() view returns (uint8)',
]);

const tokens = [
  '0xTokenA',
  '0xTokenB',
  '0xTokenC',
] as const;

const owner = '0xYourAddress';

// Fetch symbol, decimals, and balance for every token in one call
const results = await client.multicall({
  contracts: tokens.flatMap((address) => [
    { address, abi: ERC20_ABI, functionName: 'symbol' },
    { address, abi: ERC20_ABI, functionName: 'decimals' },
    { address, abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
  ]),
});

// Results are returned in the same order as the input contracts array
// Each result has { status: 'success' | 'failure', result, error }
tokens.forEach((address, i) => {
  const symbol  = results[i * 3];
  const decimals = results[i * 3 + 1];
  const balance  = results[i * 3 + 2];

  if (symbol.status === 'success' && balance.status === 'success') {
    console.log(`${address}: ${balance.result} (${symbol.result})`);
  }
});
```

## Allowing Individual Call Failures

By default, a single failed call causes the entire batch to revert. Use `allowFailure: true` (the default in viem) to get partial results instead:

```ts theme={"dark"}
const results = await client.multicall({
  contracts: [
    { address: '0xTokenA', abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
    { address: '0xMaybeInvalid', abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
  ],
  allowFailure: true, // default — individual failures don't abort the batch
});

results.forEach((result) => {
  if (result.status === 'success') {
    console.log('Balance:', result.result);
  } else {
    console.warn('Call failed:', result.error);
  }
});
```

## Batching with ethers

ethers doesn't have a built-in multicall action, but you can call the Multicall3 contract directly:

```ts theme={"dark"}
import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');

const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
const MULTICALL3_ABI = [
  'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) view returns (tuple(bool success, bytes returnData)[] returnData)',
];

const multicall = new ethers.Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);

const ERC20_INTERFACE = new ethers.Interface([
  'function balanceOf(address owner) view returns (uint256)',
]);

const owner = '0xYourAddress';
const tokens = ['0xTokenA', '0xTokenB', '0xTokenC'];

const calls = tokens.map((target) => ({
  target,
  allowFailure: true,
  callData: ERC20_INTERFACE.encodeFunctionData('balanceOf', [owner]),
}));

const results = await multicall.aggregate3(calls);

results.forEach(({ success, returnData }: { success: boolean; returnData: string }, i: number) => {
  if (success) {
    const [balance] = ERC20_INTERFACE.decodeFunctionResult('balanceOf', returnData);
    console.log(`${tokens[i]}: ${balance}`);
  }
});
```

## Wagmi

In React apps, `useReadContracts` handles batching automatically:

```tsx theme={"dark"}
import { useReadContracts } from 'wagmi';
import { parseAbi } from 'viem';

const ERC20_ABI = parseAbi([
  'function balanceOf(address owner) view returns (uint256)',
  'function symbol() view returns (string)',
]);

const TOKEN_A = '0xTokenA' as const;
const TOKEN_B = '0xTokenB' as const;
const owner   = '0xYourAddress' as const;

export function MultiTokenBalances() {
  const { data } = useReadContracts({
    contracts: [
      { address: TOKEN_A, abi: ERC20_ABI, functionName: 'symbol' },
      { address: TOKEN_A, abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
      { address: TOKEN_B, abi: ERC20_ABI, functionName: 'symbol' },
      { address: TOKEN_B, abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
    ],
  });

  if (!data) return null;

  return (
    <ul>
      <li>{data[0].result}: {data[1].result?.toString()}</li>
      <li>{data[2].result}: {data[3].result?.toString()}</li>
    </ul>
  );
}
```

---

URL: https://docs.sei.io/evm/evm-parity/examples/pointer-contracts

# Pointer Contracts

> Looking up and interacting with pointer contracts that bridge CosmWasm and EVM tokens on Sei

# Pointer Contracts

Sei runs two token execution environments side by side — EVM and CosmWasm. Pointer contracts are automatically deployed EVM contracts that proxy a CosmWasm token, and vice versa.

| Token                          | Pointer type    | EVM interface    |
| ------------------------------ | --------------- | ---------------- |
| CW20 (CosmWasm fungible token) | ERC-20 pointer  | Standard ERC-20  |
| CW721 (CosmWasm NFT)           | ERC-721 pointer | Standard ERC-721 |
| Native Sei token (bank module) | ERC-20 pointer  | Standard ERC-20  |

Once you have the pointer address, you interact with it using the standard ERC-20 or ERC-721 interface — no Sei-specific code needed.

For background on how pointer contracts work, see the [Pointers overview](/learn/pointers).

## Looking Up a Pointer Address

The pointerview precompile resolves pointer addresses by CosmWasm contract address or native denom. Its ABI and address are exported from `@sei-js/precompiles`.

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, http } from 'viem';
  import { sei } from 'viem/chains';
  import {
    POINTERVIEW_PRECOMPILE_ABI,
    POINTERVIEW_PRECOMPILE_ADDRESS,
  } from '@sei-js/precompiles';

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

  // CW20 → ERC-20 pointer
  const erc20Pointer = await client.readContract({
    address: POINTERVIEW_PRECOMPILE_ADDRESS,
    abi: POINTERVIEW_PRECOMPILE_ABI,
    functionName: 'getCW20Pointer',
    args: ['sei1...cw20ContractAddress'],
  });

  // CW721 → ERC-721 pointer
  const erc721Pointer = await client.readContract({
    address: POINTERVIEW_PRECOMPILE_ADDRESS,
    abi: POINTERVIEW_PRECOMPILE_ABI,
    functionName: 'getCW721Pointer',
    args: ['sei1...cw721ContractAddress'],
  });

  // Native denom → ERC-20 pointer
  const nativePointer = await client.readContract({
    address: POINTERVIEW_PRECOMPILE_ADDRESS,
    abi: POINTERVIEW_PRECOMPILE_ABI,
    functionName: 'getNativePointer',
    args: ['usei'],
  });
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';
  import {
    POINTERVIEW_PRECOMPILE_ABI,
    POINTERVIEW_PRECOMPILE_ADDRESS,
  } from '@sei-js/precompiles';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');

  const pointerview = new ethers.Contract(
    POINTERVIEW_PRECOMPILE_ADDRESS,
    POINTERVIEW_PRECOMPILE_ABI,
    provider,
  );

  // CW20 → ERC-20 pointer
  const erc20Pointer = await pointerview.getCW20Pointer('sei1...cw20ContractAddress');

  // CW721 → ERC-721 pointer
  const erc721Pointer = await pointerview.getCW721Pointer('sei1...cw721ContractAddress');

  // Native denom → ERC-20 pointer
  const nativePointer = await pointerview.getNativePointer('usei');
  ```
</CodeGroup>

The return value includes the pointer address and an `exists` boolean. Check `exists` before interacting with the pointer — not all CosmWasm tokens have a deployed pointer.

## Interacting with a CW20 Pointer as ERC-20

Once you have the pointer address, use it as a standard ERC-20 contract.

<CodeGroup>
  ```ts viem theme={"dark"}
  import { parseAbi } from 'viem';

  const ERC20_ABI = parseAbi([
    'function balanceOf(address owner) view returns (uint256)',
    'function transfer(address to, uint256 amount) returns (bool)',
  ]);

  const balance = await client.readContract({
    address: erc20Pointer.addr,
    abi: ERC20_ABI,
    functionName: 'balanceOf',
    args: ['0xYourAddress'],
  });
  ```

  ```ts ethers theme={"dark"}
  const ERC20_ABI = [
    'function balanceOf(address owner) view returns (uint256)',
    'function transfer(address to, uint256 amount) returns (bool)',
  ];

  const token = new ethers.Contract(erc20Pointer.addr, ERC20_ABI, provider);
  const balance = await token.balanceOf('0xYourAddress');
  ```
</CodeGroup>

## Interacting with a CW721 Pointer as ERC-721

<CodeGroup>
  ```ts viem theme={"dark"}
  import { parseAbi } from 'viem';

  const ERC721_ABI = parseAbi([
    'function ownerOf(uint256 tokenId) view returns (address)',
    'function tokenURI(uint256 tokenId) view returns (string)',
  ]);

  const owner = await client.readContract({
    address: erc721Pointer.addr,
    abi: ERC721_ABI,
    functionName: 'ownerOf',
    args: [1n],
  });
  ```

  ```ts ethers theme={"dark"}
  const ERC721_ABI = [
    'function ownerOf(uint256 tokenId) view returns (address)',
    'function tokenURI(uint256 tokenId) view returns (string)',
  ];

  const nft = new ethers.Contract(erc721Pointer.addr, ERC721_ABI, provider);
  const owner = await nft.ownerOf(1n);
  ```
</CodeGroup>

For full ERC-20 and ERC-721 examples including transfers, approvals, and events, see the [ERC-20](/evm/evm-parity/examples/erc20) and [ERC-721](/evm/evm-parity/examples/erc721) pages.

---

URL: https://docs.sei.io/evm/evm-parity/examples/sei-precompiles

# Sei Precompiles

> Interact with native Sei chain features — staking, governance, native token balances, and more — from EVM applications

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

Sei exposes native chain functionality through precompiled contracts at deterministic EVM addresses. You can call them from any EVM library (viem, ethers, wagmi) using the ABIs exported from `@sei-js/precompiles` — no special SDK required.

Available precompiles include:

* **Bank** — query native denom balances (usei, factory tokens)
* **Staking** — delegate, undelegate, query delegations
* **Distribution** — claim staking rewards
* **Governance** — vote on active proposals
* **JSON** — parse JSON payloads within contracts
* **P256** — verify P-256 elliptic curve signatures

## Try it live

Precompiles are callable like any contract — even with a plain `eth_call` from the browser. This hits the **Bank** precompile at `0x0000000000000000000000000000000000001001` on Sei mainnet, calling `name("usei")`. The response is ABI-encoded; it contains the bytes `53 45 49` — ASCII for `SEI`.

<RunSnippet method="eth_call" params={[{ to: '0x0000000000000000000000000000000000001001', data: '0x5b43bc99000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000047573656900000000000000000000000000000000000000000000000000000000' }, 'latest']} network="mainnet" decode="off" title="Bank.name('usei')" description="Raw eth_call to the Bank precompile. Decoding off because the result is an ABI-encoded string, not a numeric quantity." />

For installation instructions, code examples (viem and ethers), common patterns, and a full working Node.js script, see the precompiles reference:

<Card title="Precompile Example Usage" icon="hexagon-nodes" href="/evm/precompiles/example-usage">
  Usage examples for all precompiles with viem and ethers — Bank, Staking, Distribution, Governance, JSON, and P256.
</Card>

For the full ABI reference and every available function on each precompile:

<CardGroup cols={2}>
  <Card title="Staking Precompile" href="/evm/precompiles/staking" />

  <Card title="Governance Precompile" href="/evm/precompiles/governance" />

  <Card title="Distribution Precompile" href="/evm/precompiles/distribution" />

  <Card title="JSON Precompile" href="/evm/precompiles/json" />

  <Card title="P256 Precompile" href="/evm/precompiles/p256-precompile" />
</CardGroup>

---

URL: https://docs.sei.io/evm/evm-parity/examples/deploy-verify

# Deploy and Verify

> Deploying and verifying smart contracts on Sei with viem, ethers, Foundry, and Hardhat

export const AddSeiButton = ({network = 'mainnet', label = 'Add Sei to MetaMask'}) => {
  const SEI_MAINNET_CHAIN_PARAMS = {
    chainId: '0x531',
    chainName: 'Sei Network',
    rpcUrls: ['https://evm-rpc.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://seiscan.io']
  };
  const SEI_TESTNET_CHAIN_PARAMS = {
    chainId: '0x530',
    chainName: 'Sei Testnet',
    rpcUrls: ['https://evm-rpc-testnet.sei-apis.com'],
    nativeCurrency: {
      name: 'Sei',
      symbol: 'SEI',
      decimals: 18
    },
    blockExplorerUrls: ['https://testnet.seiscan.io']
  };
  const chainParams = network === 'testnet' ? SEI_TESTNET_CHAIN_PARAMS : SEI_MAINNET_CHAIN_PARAMS;
  const [status, setStatus] = useState(null);
  const [isHovered, setIsHovered] = useState(false);
  const [isBusy, setIsBusy] = useState(false);
  const addOrSwitchSeiNetwork = async params => {
    if (typeof window === 'undefined' || !window.ethereum) {
      throw new Error('MetaMask is not installed');
    }
    const ethereum = window.ethereum;
    try {
      await ethereum.request({
        method: 'wallet_switchEthereumChain',
        params: [{
          chainId: params.chainId
        }]
      });
    } catch (switchError) {
      if (switchError && switchError.code === 4902) {
        await ethereum.request({
          method: 'wallet_addEthereumChain',
          params: [params]
        });
      } else {
        throw switchError;
      }
    }
  };
  const onClick = async e => {
    e.preventDefault();
    setIsBusy(true);
    setStatus(null);
    try {
      await addOrSwitchSeiNetwork(chainParams);
      setStatus({
        type: 'success',
        message: `${chainParams.chainName} added or switched.`
      });
    } catch (err) {
      const message = err && err.message ? err.message : 'Failed to add or switch network.';
      setStatus({
        type: 'error',
        message
      });
    } finally {
      setIsBusy(false);
    }
  };
  return <span className="inline-flex flex-col items-start gap-1">
      <button type="button" onClick={onClick} disabled={isBusy} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} className="inline-flex items-center gap-1 px-3 py-1.5 text-white transition-colors min-w-[160px]" style={{
    backgroundColor: isHovered ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: isBusy ? 0.7 : 1,
    cursor: isBusy ? 'default' : 'pointer'
  }}>
        {isBusy ? 'Adding…' : label}
      </button>
      {status && <span className={status.type === 'error' ? 'text-red-600 dark:text-red-400' : 'text-green-600 dark:text-green-400'} style={{
    fontSize: '11px'
  }}>
          {status.message}
        </span>}
    </span>;
};

export const SandboxEmbed = props => {
  const {src, kind = 'codesandbox', title, description, height, label} = props || ({});
  const KINDS = {
    codesandbox: {
      name: 'CodeSandbox',
      host: 'codesandbox.io',
      defaultHeight: 500
    },
    remix: {
      name: 'Remix IDE',
      host: 'remix.ethereum.org',
      defaultHeight: 620
    },
    stackblitz: {
      name: 'StackBlitz',
      host: 'stackblitz.com',
      defaultHeight: 500
    }
  };
  const meta = KINDS[kind] || KINDS.codesandbox;
  const parsedHeight = Number(height);
  const frameHeight = Number.isFinite(parsedHeight) && parsedHeight > 0 ? parsedHeight : meta.defaultHeight;
  const allowAttr = 'clipboard-read; clipboard-write';
  const [loaded, setLoaded] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    cursor: 'pointer'
  };
  const PlayIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
			<path d="M8 5v14l11-7z" />
		</svg>;
  const ExternalIcon = () => <svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
			<path d="M14 5h5v5" />
			<path d="M19 5l-9 9" />
			<path d="M19 14v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h5" />
		</svg>;
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || meta.name}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{meta.name}</span>
				</div>
				<div className="flex items-center gap-3 shrink-0">
					{src ? <a href={src} target="_blank" rel="noopener noreferrer" className="inline-flex items-center gap-1 text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							Open <ExternalIcon />
						</a> : null}
					{!loaded && src ? <button type="button" onClick={() => setLoaded(true)} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 transition-colors" style={buttonStyle}>
							<PlayIcon />
							{label || 'Load editor'}
						</button> : null}
				</div>
			</div>

			{description ? <div className="px-4 pt-3 pb-1 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			{!src ? <div className="px-4 py-6 text-sm text-red-600 dark:text-red-400" style={monoStyle}>
					SandboxEmbed: missing required `src`.
				</div> : loaded ? <iframe src={src} title={title || meta.name} className="w-full block border-0" style={{
    height: frameHeight + 'px',
    backgroundColor: 'rgba(128, 128, 128, 0.05)'
  }} allow={allowAttr} loading="lazy" allowFullScreen /> : <button type="button" onClick={() => setLoaded(true)} className="w-full flex flex-col items-center justify-center gap-2 text-neutral-500 dark:text-neutral-400 hover:text-neutral-800 dark:hover:text-neutral-200 transition-colors" style={{
    height: frameHeight + 'px',
    cursor: 'pointer',
    ...surfaceStyle
  }}>
					<PlayIcon />
					<span className="text-sm" style={monoStyle}>Click to load {meta.name}</span>
					<span className="text-xs">Loads {meta.host} in an embedded editor</span>
				</button>}
		</div>;
};

Sei is EVM-compatible — standard deployment tooling works without modification. This page covers deploying a contract and verifying its source on the Sei block explorer.

For a deeper look at verification options (Remix, Sourcify UI, batch verification), see the [Verify Contracts](/evm/evm-verify-contracts) page.

## Try it: deploy from your browser

No local toolchain required — compile and deploy a contract to Sei testnet straight from the browser. The Remix sandbox below preloads a minimal `Counter.sol`.

First, add Sei testnet to your wallet:

<AddSeiButton network="testnet" label="Add Sei testnet" />

Then in Remix: compile under the **Solidity Compiler** tab, open **Deploy & Run**, set **Environment** to **Injected Provider — MetaMask**, and click **Deploy**. Sei has instant finality, so the deployment confirms in well under a second.

<SandboxEmbed kind="remix" src="https://remix.ethereum.org/?#activate=solidity,fileManager&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVApwcmFnbWEgc29saWRpdHkgXjAuOC4yNDsKCi8vLyBAdGl0bGUgQ291bnRlciDigJQgbWluaW1hbCBjb250cmFjdCB0byBjb21waWxlICYgZGVwbG95IHRvIFNlaSB0ZXN0bmV0Lgpjb250cmFjdCBDb3VudGVyIHsKICAgIHVpbnQyNTYgcHVibGljIGNvdW50OwogICAgZnVuY3Rpb24gaW5jcmVtZW50KCkgZXh0ZXJuYWwgeyBjb3VudCsrOyB9CiAgICBmdW5jdGlvbiBkZWNyZW1lbnQoKSBleHRlcm5hbCB7IGNvdW50LS07IH0KfQ" title="Counter.sol · deploy to Sei testnet" description="Remix IDE with a minimal Counter contract preloaded. Compile in-browser, then deploy to Sei testnet." />

## Deploying with viem or ethers

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, createWalletClient, http } from 'viem';
  import { privateKeyToAccount } from 'viem/accounts';
  import { sei } from 'viem/chains';

  const account = privateKeyToAccount('0xYourPrivateKey');
  const publicClient = createPublicClient({ chain: sei, transport: http() });
  const walletClient = createWalletClient({ account, chain: sei, transport: http() });

  const hash = await walletClient.deployContract({
    abi: CONTRACT_ABI,
    bytecode: '0x608060...',
    args: [/* constructor args */],
  });

  const { contractAddress } = await publicClient.waitForTransactionReceipt({ hash });
  console.log('Deployed at:', contractAddress);
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
  const wallet = new ethers.Wallet('0xYourPrivateKey', provider);

  const factory = new ethers.ContractFactory(CONTRACT_ABI, '0x608060...', wallet);
  const contract = await factory.deploy(/* constructor args */);

  await contract.waitForDeployment();
  console.log('Deployed at:', await contract.getAddress());
  ```
</CodeGroup>

## Deploying with Foundry

Foundry works against Sei with the standard `--rpc-url` flag.

```bash theme={"dark"}
forge create src/MyContract.sol:MyContract \
  --rpc-url https://evm-rpc.sei-apis.com \
  --private-key $PRIVATE_KEY \
  --constructor-args arg1 arg2
```

For testnet:

```bash theme={"dark"}
forge create src/MyContract.sol:MyContract \
  --rpc-url https://evm-rpc-testnet.sei-apis.com \
  --private-key $PRIVATE_KEY
```

## Deploying with Hardhat

Add Sei networks to your `hardhat.config.ts` (Hardhat 3). Keep the toolbox in the `plugins` array — it ships with projects created by `npx hardhat --init` and provides Hardhat Ignition for deployments:

```ts theme={"dark"}
import { defineConfig, configVariable } from 'hardhat/config';
import hardhatToolboxMochaEthers from '@nomicfoundation/hardhat-toolbox-mocha-ethers';

export default defineConfig({
  networks: {
    sei: {
      type: 'http',
      chainId: 1329,
      url: 'https://evm-rpc.sei-apis.com',
      accounts: [configVariable('SEI_PRIVATE_KEY')],
    },
    seiTestnet: {
      type: 'http',
      chainId: 1328,
      url: 'https://evm-rpc-testnet.sei-apis.com',
      accounts: [configVariable('SEI_PRIVATE_KEY')],
    },
  },

  plugins: [hardhatToolboxMochaEthers],
});
```

Store your private key in Hardhat's encrypted keystore so it never lives in a plaintext file:

```bash theme={"dark"}
npx hardhat keystore set SEI_PRIVATE_KEY
```

Describe the deployment in a minimal Ignition module at `ignition/modules/MyContract.ts`:

```ts theme={"dark"}
import { buildModule } from '@nomicfoundation/hardhat-ignition/modules';

export default buildModule('MyContractModule', (m) => {
  const myContract = m.contract('MyContract', [/* constructor args */]);
  return { myContract };
});
```

Then deploy it:

```bash theme={"dark"}
npx hardhat ignition deploy ignition/modules/MyContract.ts --network sei
```

## Verifying Contracts

Sei's block explorer is [Seiscan](https://seiscan.io). The recommended verification method is [Sourcify](https://sourcify.dev/) — no API key required.

### Foundry

Verify after deployment:

```bash theme={"dark"}
forge verify-contract \
  --verifier sourcify \
  --chain-id 1329 \
  0xDeployedContractAddress \
  src/MyContract.sol:MyContract
```

Or deploy and verify in one step:

```bash theme={"dark"}
forge create src/MyContract.sol:MyContract \
  --rpc-url https://evm-rpc.sei-apis.com \
  --private-key $PRIVATE_KEY \
  --verify \
  --verifier sourcify \
  --chain-id 1329
```

For testnet, use `--chain-id 1328` and `--rpc-url https://evm-rpc-testnet.sei-apis.com`.

### Hardhat

If you use a Hardhat toolbox (as in the config above), `hardhat-verify` is already bundled and active — skip ahead to the verify command. Without a toolbox, install the plugin:

```bash theme={"dark"}
npm install --save-dev @nomicfoundation/hardhat-verify
```

Then add it to the `plugins` array in `hardhat.config.ts` — Sourcify verification is enabled by default in `hardhat-verify` and needs no API key:

```ts theme={"dark"}
import { defineConfig, configVariable } from 'hardhat/config';
import hardhatVerify from '@nomicfoundation/hardhat-verify';

export default defineConfig({
  networks: {
    sei: {
      type: 'http',
      chainId: 1329,
      url: 'https://evm-rpc.sei-apis.com',
      accounts: [configVariable('SEI_PRIVATE_KEY')],
    },
    seiTestnet: {
      type: 'http',
      chainId: 1328,
      url: 'https://evm-rpc-testnet.sei-apis.com',
      accounts: [configVariable('SEI_PRIVATE_KEY')],
    },
  },

  plugins: [hardhatVerify],
});
```

Verify a deployed contract on Sourcify:

```bash theme={"dark"}
npx hardhat verify sourcify --network sei 0xDeployedContractAddress
```

If your contract has constructor arguments:

```bash theme={"dark"}
npx hardhat verify sourcify --network sei 0xDeployedContractAddress "arg1" "arg2"
```

Running `npx hardhat verify` without the `sourcify` subtask attempts verification on all enabled providers (Etherscan, Blockscout, and Sourcify) in a single run.

## Network Reference

| Network | Chain ID | RPC                                     | Explorer                                         |
| ------- | -------- | --------------------------------------- | ------------------------------------------------ |
| Mainnet | 1329     | `https://evm-rpc.sei-apis.com`          | [seiscan.io](https://seiscan.io)                 |
| Testnet | 1328     | `https://evm-rpc-testnet.sei-apis.com`  | [testnet.seiscan.io](https://testnet.seiscan.io) |
| Devnet  | 713715   | `https://evm-rpc-arctic-1.sei-apis.com` | —                                                |

---

URL: https://docs.sei.io/evm/evm-parity/examples/transaction-lifecycle

# Transaction Lifecycle

> Send transactions, wait for receipts, and decode event logs on Sei

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

# Transaction Lifecycle

This page covers the full round-trip of a transaction: building and sending it, waiting for the receipt, and reading the event logs it emitted.

## Try it live

Before you send anything, read the live chain state your transaction will interact with — straight from your browser against Sei mainnet, no install or key required.

<RunSnippet method="eth_gasPrice" network="mainnet" title="eth_gasPrice" description="Current gas price in wei — the widget decodes the hex quantity to decimal below the response." />

<RunSnippet method="eth_blockNumber" network="mainnet" title="eth_blockNumber" description="Latest committed block on pacific-1. Your transaction lands a block or two after whatever this returns." />

## Sending a Transaction

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createWalletClient, http, parseEther } from 'viem';
  import { privateKeyToAccount } from 'viem/accounts';
  import { sei } from 'viem/chains';

  const account = privateKeyToAccount('0xYourPrivateKey');
  const walletClient = createWalletClient({ account, chain: sei, transport: http() });

  const hash = await walletClient.sendTransaction({
    to: '0xRecipient',
    value: parseEther('1'),
  });
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');
  const wallet = new ethers.Wallet('0xYourPrivateKey', provider);

  const tx = await wallet.sendTransaction({
    to: '0xRecipient',
    value: ethers.parseEther('1'),
  });
  ```
</CodeGroup>

## Waiting for the Receipt

<CodeGroup>
  ```ts viem theme={"dark"}
  import { createPublicClient, http } from 'viem';

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

  const receipt = await client.waitForTransactionReceipt({ hash });

  console.log('Status:', receipt.status);           // 'success' | 'reverted'
  console.log('Block:', receipt.blockNumber);
  console.log('Gas used:', receipt.gasUsed);
  ```

  ```ts ethers theme={"dark"}
  const receipt = await tx.wait();
  // or wait for a specific number of confirmations:
  // const receipt = await tx.wait(1);

  console.log('Status:', receipt.status); // 1 = success, 0 = reverted
  console.log('Block:', receipt.blockNumber);
  console.log('Gas used:', receipt.gasUsed);
  ```
</CodeGroup>

<Info>Sei has instant finality — the receipt is final as soon as it arrives. One confirmation is sufficient. See [Finality](/evm/evm-parity/finality).</Info>

## Decoding Event Logs from a Receipt

After a contract interaction, decode the events the transaction emitted:

<CodeGroup>
  ```ts viem theme={"dark"}
  import { parseAbi, decodeEventLog } from 'viem';

  const ERC20_ABI = parseAbi([
    'function transfer(address to, uint256 amount) returns (bool)',
    'event Transfer(address indexed from, address indexed to, uint256 value)',
  ]);

  const hash = await walletClient.writeContract({
    address: TOKEN,
    abi: ERC20_ABI,
    functionName: 'transfer',
    args: ['0xRecipient', 1_000_000n],
  });

  const receipt = await client.waitForTransactionReceipt({ hash });

  // viem returns typed logs automatically when you pass the ABI to getTransactionReceipt
  const typedReceipt = await client.getTransactionReceipt({ hash });

  // Or decode manually from raw logs
  for (const log of receipt.logs) {
    try {
      const event = decodeEventLog({ abi: ERC20_ABI, ...log });
      console.log('Event:', event.eventName, event.args);
    } catch {
      // Log from a different contract or unknown ABI
    }
  }
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  const ERC20_ABI = [
    'function transfer(address to, uint256 amount) returns (bool)',
    'event Transfer(address indexed from, address indexed to, uint256 value)',
  ];

  const contract = new ethers.Contract(TOKEN, ERC20_ABI, wallet);
  const tx = await contract.transfer('0xRecipient', 1_000_000n);
  const receipt = await tx.wait();

  // ethers parses logs automatically when using a Contract instance
  for (const log of receipt.logs) {
    try {
      const parsed = contract.interface.parseLog(log);
      if (parsed) {
        console.log('Event:', parsed.name, parsed.args);
        // e.g. Event: Transfer [ '0xFrom', '0xTo', 1000000n ]
      }
    } catch {
      // Log from a different contract
    }
  }
  ```
</CodeGroup>

## Checking for Revert

A receipt with `status: 'reverted'` (viem) or `status: 0` (ethers) means the transaction was included but the execution failed. The gas was still consumed.

```ts viem theme={"dark"}
const receipt = await client.waitForTransactionReceipt({ hash });

if (receipt.status === 'reverted') {
  // Transaction was mined but execution failed.
  // Simulate the call to get the revert reason.
  console.error('Transaction reverted at block', receipt.blockNumber);
}
```

## Fetching a Past Transaction

```ts viem theme={"dark"}
const tx = await client.getTransaction({ hash: '0xTxHash' });
console.log('From:', tx.from);
console.log('To:', tx.to);
console.log('Value:', tx.value);
console.log('Input data:', tx.input);
```

```ts ethers theme={"dark"}
const tx = await provider.getTransaction('0xTxHash');
const receipt = await provider.getTransactionReceipt('0xTxHash');
```

## Getting Logs for a Specific Transaction

To fetch only the events emitted by a specific transaction (rather than decoding from the receipt):

```ts viem theme={"dark"}
const logs = await client.getContractEvents({
  address: TOKEN,
  abi: ERC20_ABI,
  eventName: 'Transfer',
  blockHash: receipt.blockHash,
});

const txLogs = logs.filter((log) => log.transactionHash === hash);
```

---

URL: https://docs.sei.io/evm/evm-parity/examples/error-handling

# Error Handling

> Decode contract reverts, handle wallet rejections, and recover from RPC errors in Sei apps

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

# Error Handling

Most transaction failures fall into three categories: contract reverts, wallet rejections, and RPC errors. This page shows how to decode each type and respond correctly.

## Try it: see real errors

The `RunSnippet` widget surfaces whatever the RPC returns — including failures. These two calls fail on purpose so you can see the exact error shape your code has to handle, live against Sei mainnet.

<RunSnippet method="eth_call" params={[{ to: '0xcA11bde05977b3631167028862bE2a173976CA11', data: '0xdeadbeef' }, 'latest']} network="mainnet" title="A contract revert" description="Calls an unknown selector (0xdeadbeef) on Multicall3. The node rejects it with execution reverted — the same class of failure as the Contract Reverts section below." />

<RunSnippet method="eth_getBalance" params={['0x123', 'latest']} network="mainnet" title="An RPC argument error" description="A malformed address (0x123) triggers a JSON-RPC -32602 invalid argument error — distinct from a revert, and the kind of failure the RPC Errors and Retries section below handles." />

## Contract Reverts

When a transaction reverts, the error contains the revert reason if the contract provides one.

<CodeGroup>
  ```ts viem theme={"dark"}
  import { ContractFunctionRevertedError, BaseError } from 'viem';

  try {
    await client.simulateContract({
      address: TOKEN,
      abi: ERC20_ABI,
      functionName: 'transfer',
      args: ['0xRecipient', 1_000_000n],
      account,
    });
  } catch (err) {
    if (err instanceof BaseError) {
      const revert = err.walk((e) => e instanceof ContractFunctionRevertedError);
      if (revert instanceof ContractFunctionRevertedError) {
        console.error('Revert reason:', revert.data?.errorName);
        // e.g. 'ERC20InsufficientBalance'
      }
    }
  }
  ```

  ```ts ethers theme={"dark"}
  import { ethers } from 'ethers';

  try {
    await writeContract.transfer('0xRecipient', 1_000_000n);
  } catch (err: any) {
    if (err.code === 'CALL_EXCEPTION') {
      // Decode using the contract's ABI
      const decoded = writeContract.interface.parseError(err.data);
      if (decoded) {
        console.error('Revert:', decoded.name, decoded.args);
      } else {
        console.error('Unknown revert data:', err.data);
      }
    }
  }
  ```
</CodeGroup>

## Simulating Before Sending

Always simulate write calls before submitting them. Simulation runs the call against current chain state and surfaces reverts before you spend gas:

```ts viem theme={"dark"}
import { ContractFunctionRevertedError, BaseError } from 'viem';

async function safeWrite(params: Parameters<typeof walletClient.writeContract>[0]) {
  // 1. Simulate — reverts here cost no gas
  const { request } = await client.simulateContract(params);
  // 2. Execute only if simulation passes
  return walletClient.writeContract(request);
}
```

## Wallet Rejections

Users can reject signature and transaction requests. These rejections have a predictable error code:

<CodeGroup>
  ```ts viem theme={"dark"}
  import { UserRejectedRequestError } from 'viem';

  try {
    await walletClient.sendTransaction({ to: '0xRecipient', value: 1n });
  } catch (err) {
    if (err instanceof UserRejectedRequestError) {
      // User cancelled — don't show an error, just reset UI state
      console.log('User rejected the request');
    }
  }
  ```

  ```ts ethers theme={"dark"}
  try {
    await signer.sendTransaction({ to: '0xRecipient', value: 1n });
  } catch (err: any) {
    if (err.code === 4001 || err.code === 'ACTION_REJECTED') {
      console.log('User rejected the request');
    }
  }
  ```
</CodeGroup>

## Insufficient Funds

<CodeGroup>
  ```ts viem theme={"dark"}
  import { InsufficientFundsError } from 'viem';

  try {
    await walletClient.sendTransaction({ to: '0xRecipient', value: parseEther('9999') });
  } catch (err) {
    if (err instanceof InsufficientFundsError) {
      console.error('Not enough SEI for this transaction');
    }
  }
  ```

  ```ts ethers theme={"dark"}
  try {
    await wallet.sendTransaction({ to: '0xRecipient', value: ethers.parseEther('9999') });
  } catch (err: any) {
    if (err.code === 'INSUFFICIENT_FUNDS') {
      console.error('Not enough SEI for this transaction');
    }
  }
  ```
</CodeGroup>

## Classifying Any Error

A utility to handle the most common cases in one place:

```ts theme={"dark"}
import {
  BaseError,
  ContractFunctionRevertedError,
  UserRejectedRequestError,
  InsufficientFundsError,
} from 'viem';

function classifyError(err: unknown): string {
  if (err instanceof UserRejectedRequestError) return 'rejected';
  if (err instanceof InsufficientFundsError)  return 'insufficient_funds';

  if (err instanceof BaseError) {
    const revert = err.walk((e) => e instanceof ContractFunctionRevertedError);
    if (revert instanceof ContractFunctionRevertedError) {
      return `revert:${revert.data?.errorName ?? 'unknown'}`;
    }
  }

  return 'unknown';
}
```

## RPC Errors and Retries

Transient RPC failures (network timeouts, rate limits) can be retried. Don't retry on contract reverts or user rejections — those are deterministic.

```ts theme={"dark"}
async function withRetry<T>(fn: () => Promise<T>, maxAttempts = 3): Promise<T> {
  let lastError: unknown;
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (err: any) {
      // Don't retry user rejections or contract reverts
      if (
        err instanceof UserRejectedRequestError ||
        err?.code === 4001 ||
        err?.code === 'CALL_EXCEPTION'
      ) {
        throw err;
      }
      lastError = err;
      if (attempt < maxAttempts) {
        await new Promise((r) => setTimeout(r, 500 * attempt)); // backoff
      }
    }
  }
  throw lastError;
}

// Usage
const balance = await withRetry(() =>
  client.readContract({ address: TOKEN, abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] })
);
```

---

URL: https://docs.sei.io/evm/indexer-providers/envio

# Envio

> Index Sei smart contract data using Envio, a modular hyper-performant data indexing solution.

## Envio

Index Sei smart contract data using Envio, a modular hyper-performant data indexing solution. Envio offers three products you can use individually or together to fit your data needs on Sei.

1. [HyperIndex](https://docs.envio.dev/docs/HyperIndex/overview), a fully customizable blockchain indexing framework that powers GraphQL APIs over Postgres
2. [HyperSync](https://docs.envio.dev/docs/HyperSync/overview), a real-time data retrieval layer up to 2000x faster than traditional RPC
3. [HyperRPC](https://docs.envio.dev/docs/HyperRPC/overview-hyperrpc), an extremely fast RPC for data-intensive queries

> **New to Envio?** Jump straight to [How to Index Sei Smart Contract Data in Minutes using Envio](https://docs.envio.dev/blog/index-sei-smart-contracts-envio) for a step-by-step walkthrough that builds a USDC indexer on Sei in under five minutes.

| Field                  | Value                                                               |
| ---------------------- | ------------------------------------------------------------------- |
| Sei Chain ID           | 1329                                                                |
| HyperSync URL Endpoint | `https://sei.hypersync.xyz` or `https://1329.hypersync.xyz`         |
| HyperRPC URL Endpoint  | `https://sei.rpc.hypersync.xyz` or `https://1329.rpc.hypersync.xyz` |

> Sei testnet is also supported, with HyperSync at `https://sei-testnet.hypersync.xyz` and HyperRPC at `https://sei-testnet.rpc.hypersync.xyz`.

## Choosing a Product

### HyperIndex

**Best for:** projects that need a complete indexing solution with schema management, event handling, and a GraphQL API.

* A full-featured indexing framework that transforms on-chain events into structured, queryable databases with GraphQL APIs
* Configured with a YAML file, a GraphQL schema, and TypeScript, JavaScript, or ReScript event handlers
* Supports multichain indexing, real-time indexing, reorg support, and factory (dynamic) contracts
* Powered by HyperSync for historical backfill

### HyperSync

**Best for:** new projects designing their own data access layer, performance-critical workloads, advanced filtering, and full control over data formatting.

* A purpose-built, high-performance data retrieval layer, built from the ground up in Rust as an alternative to traditional JSON-RPC endpoints
* The raw blockchain data access layer that powers HyperIndex, delivering up to 2000x faster performance than traditional RPC endpoints
* Client libraries available for Python, Rust, Node.js, and Go
* Filter, select, and process exactly the data you need with powerful query options

Common use cases include custom indexers, data analytics, block explorers, monitoring tools, cross-chain applications, and ETL pipelines.

### HyperRPC

**Best for:** drop-in replacements for existing RPC-based code, projects that need standard JSON-RPC interfaces, and teams without time for a deeper integration.

* An extremely fast RPC designed specifically for data-intensive blockchain tasks
* A specialized JSON-RPC endpoint optimized for data retrieval workflows
* Drop-in compatible with existing tooling that uses standard RPC methods
* Up to 5x faster than traditional nodes for data-intensive operations; uses HyperSync to fulfill requests

Common use cases include historical data queries, log event filtering, block and transaction retrievals, and analytics applications.

## Getting Started

Make sure you have installed the [prerequisites](https://docs.envio.dev/docs/HyperIndex/quickstart#prerequisites), then initialize a new indexer.

```bash theme={"dark"} theme={"dark"}
pnpx envio init
```

You'll follow interactive prompts to customize your indexer for Sei. A minimal Sei `config.yaml` looks like this.

```yaml theme={"dark"} theme={"dark"}
name: IndexerName
description: Indexer Description
chains:
  - id: 1329 # Sei
    start_block: START_BLOCK_NUMBER
    contracts:
      - name: ContractName
        address:
          - "0xYourContractAddress1"
        events:
          - event: Event
```

For more detail on configuring chains, schemas, and event handlers, see the [HyperIndex configuration guide](https://docs.envio.dev/docs/HyperIndex/configuration-file) and [Indexing Sei on Envio](https://docs.envio.dev/docs/HyperIndex/sei).

## Built with Envio

* [Indexer Explorer](https://envio.dev/explorer), browse public real-time indexers built on Envio
* [Case studies](https://docs.envio.dev/blog/tags/case-studies), see real-world deployments and migrations
* [Showcase](https://docs.envio.dev/showcase), explore live demos built with HyperIndex and HyperSync

## More Resources

* [HyperIndex Quickstart](https://docs.envio.dev/docs/HyperIndex/quickstart)
* [Quickstart with AI](https://docs.envio.dev/docs/HyperIndex/quickstart-with-ai)
* [Envio Cloud](https://docs.envio.dev/docs/HyperIndex/hosted-service)
* [GitHub](https://github.com/enviodev/hyperindex)

## Support

Need help? Connect with the Envio team on [Discord](https://discord.gg/envio) or [Telegram](https://t.me/+kAIGElzPjApiMjI0).

---

URL: https://docs.sei.io/evm/indexer-providers/goldsky

# Goldsky

> Implement Goldsky's Subgraphs and Mirror products to efficiently index, query, and stream Sei blockchain data for your dApps with customizable data models and real-time pipelines.

## Goldsky

Wondering how to best leverage Goldsky's products? This guide explains the differences between them and how you can use them individually or together to meet your needs.

Goldsky offers two flagship products, Subgraphs and Mirror, designed to help developers interact with Sei blockchain data more efficiently. While both tools serve similar goals - retrieving, processing, and querying blockchain data - they differ significantly in how they handle data management, scalability, and customization.

Let's dive into the difference in this guide and learn more about which solution is right for you. If you're ready to get started, please visit [this page](https://docs.goldsky.com/chains/sei/?utm_source=sei\&utm_medium=docs) for a quickstart guide on how to index Sei with Goldsky.

## How to Choose Between Subgraphs and Mirror

### Subgraphs: Structured, Query-Based Data Retrieval

**Overview:**

* On-chain data is restricted to EVM-compatible chains, so it's only supported for Sei EVM.
* The data model is optimized specifically for on-chain data. The entities and data types you define in subgraphs are tailored to represent blockchain data efficiently.
* You can create relationships and aggregations between on-chain entities (e.g. track the balance of a user for specific tokens)
* You can enrich entity data with other on-chain sources using **`eth_call`**. However, integrating off-chain data is not supported.

**Examples:**

* Retrieving all transactions related to a specific wallet address.
* Querying detailed event logs from a smart contract, such as token transfers or contract interactions.
* Building dashboards or analytics tools that require periodic data retrieval.

**Key Advantages:**

* **Customizable Data Models**: Define specific data structures to match your needs.
* **Fast Query Response Times**: Queries return results quickly from pre-indexed data.
* **Developer Flexibility**: Use GraphQL to create custom queries that fit your application's needs.

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/goldsky/goldsky_img_1.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=e17eaa80855c666a9b8c3ffa2980c825" alt="Goldsky Dashboard" width="2940" height="1448" data-path="assets/ecosystem/resources/goldsky/goldsky_img_1.png" />

### Mirror: Real-Time Data Streaming Pipelines

**Overview**:

* The data model is flexible and open to any type of data. You can combine blockchain data with your own data seamlessly, offering more complex and customizable use cases.
* Using Transforms, you can also perform some pre-processing using SQL dialect as well as doing external processing on your HTTP endpoint before writing to your database.

**Examples:**

* Streaming every block's data directly into a database for real-time analysis.
* Capturing real-time price updates or liquidity changes in DeFi protocols.
* Feeding live data into machine learning models for predictive analytics.

**Key Advantages:**

* **Real-Time Data Flow**: Data is pushed directly to your database as new events occur on-chain.
* **Scalable Integration**: Supports ingestion of data from multiple blockchain networks into a centralized database.
* **Minimal Latency**: Ideal for use cases where immediate data availability is crucial.

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/goldsky/goldsky_img_2.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=acd40b89b383ba67f9a595e1aa357a94" alt="Goldsky Setup" width="2940" height="1458" data-path="assets/ecosystem/resources/goldsky/goldsky_img_2.png" />

### Mirror Data Sources Available

**Sei EVM:**

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/goldsky/goldsky_img_3.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=560feada263e5ef252d8b340c3bbde0e" alt="Goldsky Configuration" width="2186" height="1252" data-path="assets/ecosystem/resources/goldsky/goldsky_img_3.png" />

### Decision Guide: Subgraphs vs. Mirror

**Subgraphs**

* If you need to query specific Sei EVM data points or historical records, Subgraphs are the way to go.
* Best suited for applications that deal exclusively with on-chain data and don't need integration with off-chain sources.
* Ideal for predefined data models, such as dApps that need to query specific smart contract events or execute standard blockchain queries.
* Great for low to moderate traffic scenarios with relatively straightforward data structures and querying needs.

**Mirror**

* A better fit for applications that require both on-chain and off-chain data, offering the flexibility to combine data sources for advanced analytics or decision-making.
* Ideal for multi-chain applications, as it simplifies the process of managing data across different blockchains without the need for reindexing. This is specially true if your application needs non-EVM data like Sei Cosmos.
* Perfect for high-traffic applications, where low latency and real-time data access are critical to the performance and user experience.

**Example Use Case Comparison:**

* **A DeFi Analytics Dashboard**: Use Subgraphs to retrieve historical liquidity data and user interactions.
* **A Real-Time Trading Bot**: Use Mirror to stream price changes directly into your database for instant action.

By understanding the strengths of each tool, you can select the right solution to match your project's data requirements. Goldsky is designed to offer flexibility, whether you need structured, queryable data or real-time data streams. Dive deeper into Subgraphs vs Mirror [here](https://docs.goldsky.com/subgraph-vs-mirror/?utm_source=sei\&utm_medium=docs).

## Getting Started

1. Sign up for an account at [https://app.goldsky.com/signup](https://app.goldsky.com/signup).

2. Install the Goldsky CLI:

   ```bash theme={"dark"}
   curl https://goldsky.com | sh
   ```

3. Go to your [Project Settings](https://app.goldsky.com/dashboard/settings) page and create an API key.

4. Back in your Goldsky CLI, log into your Project by running the command **`goldsky login`** and paste your API key.

5. Now that you are logged in, run **`goldsky`** to get started.

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/goldsky/goldsky_img_4.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=b562d9b7f02f93c37fce769376f61e83" alt="Goldsky Results" width="2940" height="1448" data-path="assets/ecosystem/resources/goldsky/goldsky_img_4.png" />

## Deploy a Subgraph

There are three primary ways to deploy a Subgraph on Goldsky:

1. From source code
2. Migrating from The Graph or any other subgraph host
3. Via instant, no-code subgraphs

Navigate to [this page](https://docs.goldsky.com/subgraphs/deploying-subgraphs/?utm_source=sei\&utm_medium=docs) to learn more about each way of deploying a Subgraph.

## Deploy a Pipeline

You have two options to create a Goldsky Mirror pipeline:

1. **Flow**: With a guided web experience in the dashboard
2. **CLI**: interactively or by providing a pipeline configuration

Navigate to [this page](https://docs.goldsky.com/mirror/create-a-pipeline/?utm_source=sei\&utm_medium=docs) to learn more about deploying Mirror pipelines.

---

URL: https://docs.sei.io/evm/indexer-providers/the-graph

# The Graph

> Build and deploy subgraphs on The Graph to efficiently index and query data from Sei smart contracts, with step-by-step instructions from initialization to production deployment.

Getting historical data on a smart contract can be frustrating when you're
building a dapp. [The Graph](https://thegraph.com/) provides an easy way to
query smart contract data through APIs known as subgraphs. The Graph's
infrastructure relies on a decentralized network of indexers, enabling your dapp
to become truly decentralized.

## Quick Start

These subgraphs only take a few minutes to set up. To get started, follow these
three steps:

1. Initialize your subgraph project
2. Deploy & Publish
3. Query from your dapp

Pricing: **All developers receive 100K free queries per month on the
decentralized network**. After these free queries, you only pay based on usage
at \$4 for every 100K queries.

Here's a step by step walk through:

## 1. Initialize your subgraph project

### Create a subgraph on Subgraph Studio⁠

Go to the [Subgraph Studio](https://thegraph.com/studio/) and connect your
wallet. Once your wallet is connected, you can begin by clicking "Create a
Subgraph". When entering the subgraph name, it is recommended to use Title Case:
"Subgraph Name Chain Name."

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/the-graph/create_subgraph.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=59ede4b4f5516eb5a3755e07394c316b" alt="Create a Subgraph" width="854" height="765" data-path="assets/ecosystem/resources/the-graph/create_subgraph.png" />

*Create a Subgraph*

You will then land on your subgraph's page. All the CLI commands you need will
be visible on the right side of the page:

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/the-graph/cli_commands.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=cd432787bcc147fa3155364282e79827" alt="CLI commands" width="1231" height="1048" data-path="assets/ecosystem/resources/the-graph/cli_commands.png" />

*CLI Commands*

### Install the Graph CLI⁠

On your local machine run the following:

```bash theme={"dark"}
npm install -g @graphprotocol/graph-cli
```

### Initialize your Subgraph⁠

You can copy this directly from your subgraph page to include your specific
subgraph slug:

```bash theme={"dark"}
graph init --studio <SUBGRAPH_SLUG>
```

You'll be prompted to provide some info on your subgraph like this:

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/the-graph/cli_sample.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=d0a612b304515e1294e3863499bef14c" alt="CLI sample" width="1003" height="438" data-path="assets/ecosystem/resources/the-graph/cli_sample.png" />

*CLI*

Have your contract verified on the block explorer and the CLI will
automatically obtain the ABI and set up your subgraph. The default settings will
generate an entity for each event.

## 2. Deploy & Publish

### Deploy to Subgraph Studio⁠

First run these commands:

```bash theme={"dark"}
$ graph codegen
$ graph build
```

Then run these to authenticate and deploy your subgraph. You can copy these
commands directly from your subgraph's page in Studio to include your specific
deploy key and subgraph slug:

```bash theme={"dark"}
$ graph auth --studio <DEPLOY_KEY>
$ graph deploy --studio <SUBGRAPH_SLUG>
```

You will be asked for a version label. You can enter something like v0.0.1, but
you're free to choose the format.

### Test your subgraph⁠

You can test your subgraph by making a sample query in the playground section.
The Details tab will show you an API endpoint. You can use that endpoint to test
from your dapp.

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/the-graph/playground.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=d7371753338d826fc539adce3239c505" alt="Playground" width="1370" height="768" data-path="assets/ecosystem/resources/the-graph/playground.png" />

*Run your graphql query in Studio*

### Publish Your Subgraph to The Graph's Decentralized Network

Once your subgraph is ready to be put into production, you can publish it to the
decentralized network. On your subgraph's page in Subgraph Studio, click on the
Publish button:

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/the-graph/publish_button.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=0deac0ba2ebe76e1527165cf83635acc" alt="Publish button" width="2000" height="704" data-path="assets/ecosystem/resources/the-graph/publish_button.png" />

*Click Publish*

Before you can query your subgraph, Indexers need to begin serving queries on
it. In order to streamline this process, you can curate your own subgraph using
GRT.

When publishing, you'll see the option to curate your subgraph. Signaling GRT
on your own subgraph helps ensure that it is indexed and available for querying
as soon as possible. See The Graph's
[curating documentation](https://thegraph.com/docs/en/resources/roles/curating/)
for current guidance on how much GRT to signal.

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/the-graph/publish_screen.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=f46e60dbc2a736a585e583ddd1739b46" alt="Publish screen" width="1600" height="1065" data-path="assets/ecosystem/resources/the-graph/publish_screen.png" />

*Publish Screen*

<Warning>**Note:** The Graph's smart contracts are all on Arbitrum One, even though > your subgraph is indexing data from Ethereum, BSC or any other > [supported chain](https://thegraph.com/docs/en/developing/supported-networks/).</Warning>

## 3. Query your Subgraph

Congratulations! You can now query your subgraph on the decentralized network!

For any subgraph on the decentralized network, you can start querying it by
passing a GraphQL query into the subgraph's query URL which can be found at the
top of its Explorer page.

Here's an example from the
[CryptoPunks Ethereum subgraph](https://thegraph.com/explorer/subgraphs/HdVdERFUe8h61vm2fDyycHgxjsde5PbB832NHgJfZNqK)
by Messari:

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/the-graph/query_url.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=63596c4dc71ff69798a15f820bc691f9" alt="Query URL" width="1600" height="530" data-path="assets/ecosystem/resources/the-graph/query_url.png" />

*Query URL*

The query URL for this subgraph is:
`https://gateway-arbitrum.network.thegraph.com/api/`**\[api-key]**`/subgraphs/id/HdVdERFUe8h61vm2fDyycHgxjsde5PbB832NHgJfZNqK`

Now, you need to fill in your own API Key to start sending GraphQL
queries to this endpoint.

### Getting your own API Key

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/ecosystem/resources/the-graph/api_keys.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=74d80f55722dec65f389d34fe0ea6851" alt="API keys" width="1600" height="503" data-path="assets/ecosystem/resources/the-graph/api_keys.png" />

*API keys*

In Subgraph Studio, you'll see the "API Keys" menu at the top of the page. Here
you can create API Keys.

## Appendix

### Sample Query

This query shows the most expensive CryptoPunks sold.

```graphql theme={"dark"}
{
  trades(orderBy: priceETH, orderDirection: desc) {
    priceETH
    tokenId
  }
}
```

Passing this into the query URL returns this result:

```json theme={"dark"}
{
  "data": {
    "trades": [
      {
        "priceETH": "124457.067524886018255505",
        "tokenId": "9998"
      },
      {
        "priceETH": "8000",
        "tokenId": "5822"
      },
//      ...
```

<Tip>
  Trivia: Looking at the top sales on [CryptoPunks website](https://cryptopunks.app/cryptopunks/topsales) it looks like the top sale is Punk #5822, not #9998. Why? Because they censor the flash-loan sale that happened.
</Tip>

### Sample code

```jsx theme={"dark"}
const axios = require('axios');

const graphqlQuery = `{
  trades(orderBy: priceETH, orderDirection: desc) {
    priceETH
    tokenId
  }
}`;
const queryUrl = 'https://gateway-arbitrum.network.thegraph.com/api/[api-key]/subgraphs/id/HdVdERFUe8h61vm2fDyycHgxjsde5PbB832NHgJfZNqK';

const graphQLRequest = {
  method: 'post',
  url: queryUrl,
  data: {
    query: graphqlQuery
  }
};

// Send the GraphQL query
axios(graphQLRequest)
  .then((response) => {
    // Handle the response here
    const data = response.data.data;
    console.log(data);
  })
  .catch((error) => {
    // Handle any errors
    console.error(error);
  });
```

### Additional resources:

* To explore all the ways you can optimize & customize your subgraph for a
  better performance, read more about
  [creating a subgraph here](https://thegraph.com/docs/en/developing/creating-a-subgraph/).
* For more information about querying data from your subgraph, read more
  [here](https://thegraph.com/docs/en/querying/querying-the-graph/).

---

URL: https://docs.sei.io/evm/indexer-providers/goldrush

# GoldRush API Integration

> Learn how to integrate GoldRush indexing services with Sei network for blockchain data analysis and application development.

## Overview

GoldRush offers the most comprehensive Sei Data API suite for developers, analysts, and enterprises. Whether you're
building a DeFi dashboard, a wallet, a trading bot, an AI agent or a compliance platform,
our Sei Data APIs provide fast, accurate, and developer-friendly access to the essential onchain data you need.

### Supported APIs

| **Product Name**     | **Description**                                                               | **Key Data Feeds**                                                                                                                                                                                 | **Use Cases**                                                                                                                             |
| -------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| **Foundational API** | Access structured historical blockchain data across 100+ chains via REST APIs | <ul><li>Token balances (spot & historical)</li><li>Token transfers</li><li>Token holders (spot & historical)</li><li>Token prices (onchain)</li><li>Wallet transactions</li><li>Get logs</li></ul> | <ul><li>Wallets</li><li>Portfolio trackers</li><li>Crypto accounting & tax tools</li><li>DeFi dashboards</li><li>Activity feeds</li></ul> |

## Mainnet

| **Property**         | **Value**                          |
| -------------------- | ---------------------------------- |
| **Chain Name**       | `sei-mainnet`                      |
| **Chain ID**         | `1329`                             |
| **Network Type**     | Frontier Chain                     |
| **Support Level**    | frontier                           |
| **Block Explorer**   | [Explorer](https://seistream.app/) |
| **Official Website** | [Sei Website](https://www.sei.io/) |
| **Native Gas Token** | SEI                                |

## API Usage

To use this blockchain network in GoldRush API calls, use:

#### Chain Name

* `sei-mainnet` (mainnet)

#### Example API Calls (bash)

```bash theme={"dark"}
curl -X GET "https://api.covalenthq.com/v1/sei-mainnet/address/0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045/balances_v2/?key=API_KEY"
```

### SDK Usage (TypeScript)

```ts theme={"dark"}
import { GoldRushClient } from '@covalenthq/client-sdk';

const client = new GoldRushClient('API_KEY');

const resp = await client.BalanceService.getTokenBalancesForWalletAddress({
  chainName: 'sei-mainnet',
  walletAddress: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'
});
```

## Foundational API Support

This chain supports **34** GoldRush Foundational APIs:

#### Wallet API

* **[Get token balances for address](https://goldrush.dev/docs/api-reference/foundational-api/balances/get-token-balances-for-address)**
* **[Get native token balance for address](https://goldrush.dev/docs/api-reference/foundational-api/balances/get-native-token-balance)**
* **[Get historical portfolio value over time](https://goldrush.dev/docs/api-reference/foundational-api/balances/get-historical-portfolio-value-over-time)**
* **[Get ERC20 token transfers for address](https://goldrush.dev/docs/api-reference/foundational-api/balances/get-erc20-token-transfers-for-address)**

#### Pricing API

* **[Get historical token prices](https://goldrush.dev/docs/api-reference/foundational-api/utility/get-historical-token-prices)**

#### Security API

* **[Get token approvals for address](https://goldrush.dev/docs/api-reference/foundational-api/security/get-token-approvals-for-address)**

#### Activity Feed API

* **[Get a transaction](https://goldrush.dev/docs/api-reference/foundational-api/transactions/get-a-transaction)**
* **[Get transaction summary for address](https://goldrush.dev/docs/api-reference/foundational-api/transactions/get-transaction-summary-for-address)**
* **[Get earliest transactions for address (v3) ](https://goldrush.dev/docs/api-reference/foundational-api/transactions/get-earliest-transactions-for-address-v3)**
* **[Get recent transactions for address (v3)](https://goldrush.dev/docs/api-reference/foundational-api/transactions/get-recent-transactions-for-address-v3)**
* **[Get paginated transactions for address (v3)](https://goldrush.dev/docs/api-reference/foundational-api/transactions/get-paginated-transactions-for-address-v3)**
* **[Get bulk time bucket transactions for address (v3)](https://goldrush.dev/docs/api-reference/foundational-api/transactions/get-time-bucket-transactions-for-address-v3)**
* **[Get all transactions in a block (v3)](https://goldrush.dev/docs/api-reference/foundational-api/transactions/get-all-transactions-in-a-block)**
* **[Get all transactions in a block by page (v3) ](https://goldrush.dev/docs/api-reference/foundational-api/transactions/get-all-transactions-in-a-block-by-page)**

#### Block Explorer API

* **[Get a block](https://goldrush.dev/docs/api-reference/foundational-api/utility/get-a-block)**
* **[Get all chain statuses](https://goldrush.dev/docs/api-reference/foundational-api/utility/get-all-chain-statuses)**
* **[Get all chains](https://goldrush.dev/docs/api-reference/foundational-api/utility/get-all-chains)**
* **[Get block heights](https://goldrush.dev/docs/api-reference/foundational-api/utility/get-block-heights)**
* **[Get gas prices](https://goldrush.dev/docs/api-reference/foundational-api/utility/get-gas-prices)**
* **[Get log events by contract address](https://goldrush.dev/docs/api-reference/foundational-api/utility/get-log-events-by-contract-address)**
* **[Get log events by topic hash(es)](https://goldrush.dev/docs/api-reference/foundational-api/utility/get-log-events-by-topic-hash)**
* **[Get logs](https://goldrush.dev/docs/api-reference/foundational-api/utility/get-logs)**

## Additional Resources

* [Goldrush Docs](https://goldrush.dev/docs/?utm_source=sei\&utm_medium=partner-docs) -
  comprehensive knowledge base for all things GoldRush including a quickstart
* [Sei Network Details](https://goldrush.dev/chains/sei/?utm_source=sei\&utm_medium=partner-docs) -
  setup details and supported APIs for Sei
* [Guides](https://goldrush.dev/guides/?utm_source=sei\&utm_medium=partner-docs) -
  learn how to build for various use cases and expand your onchain knowledge
* [API Reference](https://goldrush.dev/docs/api-reference/)
* [API Key](https://goldrush.dev/platform/auth/register/?utm_source=sei\&utm_medium=partner-docs) -
  sign up for free

---

URL: https://docs.sei.io/evm/indexer-providers/dune-sim

# Sim by Dune

> Learn how to integrate Sim by Dune real-time multichain indexing services with Sei network for blockchain data analysis and application development.

## Overview

Sim by Dune is a real-time, multichain developer platform that provides scalable APIs and indexing infrastructure for building onchain applications. It offers the fastest way to access live blockchain data across 60+ chains, including Sei, with zero DevOps overhead. In this tutorial, you'll learn how to set up Sim, build your first data pipeline, and create powerful onchain applications on Sei.

To understand more and deep dive into how it works under the hood, please refer to the [Sim by Dune Documentation](https://docs.sim.dune.com/)

## What this guide teaches you:

This tutorial guides you through:

* **Setup**: Get your Sim API key, install dependencies, and connect to Sei
* **Core APIs**: Learn to use all 6 Sim APIs with practical examples
* **End-to-End Examples**: You'll run practical code to:
  * Fetch Sei token balances with USD values
  * Monitor wallet transactions and activity
  * Get token metadata and holder information
  * Track NFT collections and metadata
* **Production Ready**: Error handling, rate limiting, and monitoring

## Some Use Cases:

* **DeFi Analytics Platforms**: Real-time tracking of liquidity, volumes, and yields across Sei protocols
* **Portfolio Trackers**: Multi-chain portfolio management with Sei integration
* **Trading Bots**: Automated trading based on real-time onchain signals
* **Risk Management**: Monitor positions and liquidation risks across protocols
* **Governance Tools**: Track voting power and proposal activity
* **MEV Analysis**: Detect and analyze MEV opportunities on Sei

## Supported APIs

Sim by Dune provides access to comprehensive EVM blockchain data through these core APIs:

### Balances API

* **Features:** All EVM token balances for a wallet or address, ordered by USD value
* **Use cases:** Portfolio trackers, wallet applications, asset management dashboards

### Transactions API

* **Features:** Quick and accurate lookup of EVM transactions associated with any address
* **Use cases:** Transaction monitoring, compliance tools, activity tracking

### Token Info API

* **Features:** Metadata including symbol, name, decimals, supply information, logo URLs, and realtime prices
* **Use cases:** Token discovery, price tracking, market analysis

### Token Holders API

* **Features:** Holders of an ERC20 token, sorted by balance
* **Use cases:** Governance analysis, token distribution studies, whale tracking

### Activity API

* **Features:** Derived activities including swaps, transfers, and approvals within transactions for any address
* **Use cases:** DeFi analytics, trading analysis, user behavior tracking

### Collectibles API

* **Features:** All NFT (ERC721 and ERC1155) balances, including IDs and metadata
* **Use cases:** NFT marketplaces, collection analytics, digital asset management

## Quick Start

### 1. Getting Your API Key

To use Sim APIs, you'll need an API key from the Sim dashboard:

1. **Visit Sim Dashboard**: Go to [sim.dune.com](https://sim.dune.com)
2. **Sign Up/Login**: Create an account or login with your existing Dune account
3. **Navigate to Keys**: In the left sidebar, click on "Keys"
4. **Create New Key**: Click the "New" button to generate a new API key
5. **Select API Type**: Choose "Sim API" as the key's purpose
6. **Copy Your Key**: Save the generated API key securely

<Warning>
  **Security Notes:**

  * Never share your API key in public repositories

  * Keep your API keys secure and rotate them regularly

  * Use environment variables to store your keys
</Warning>

### 2. Project Setup

```bash theme={"dark"}
mkdir sei-sim-tutorial
cd sei-sim-tutorial
npm init -y
npm install axios dotenv
```

Create `.env` file:

```env theme={"dark"}
SIM_API_KEY=your_sim_api_key_here
SEI_RPC_URL=https://evm-rpc.sei-apis.com
TEST_WALLET_ADDRESS=0x...your_test_address
```

### 3. Your First API Call

Create `index.js`:

```javascript theme={"dark"}
require('dotenv').config();
const axios = require('axios');

const SIM_API_BASE = 'https://api.sim.dune.com/v1';

const headers = {
  'X-Sim-Api-Key': process.env.SIM_API_KEY,
  'Content-Type': 'application/json'
};

async function getSeiBalances() {
  try {
    console.log('🔍 Fetching Sei balances...');
    console.log(`Using wallet address: ${process.env.TEST_WALLET_ADDRESS}`);

    const response = await axios.get(`${SIM_API_BASE}/evm/balances/${process.env.TEST_WALLET_ADDRESS}?chain_ids=1329`, { headers });

    const seiBalances = response.data.balances.filter((balance) => balance.chain === 'sei');

    console.log('💰 Sei Balances:');
    seiBalances.forEach((balance) => {
      console.log(`  ${balance.symbol}: ${balance.amount} (${balance.value_usd} USD)`);
    });
  } catch (error) {
    console.error('❌ Error fetching balances:', error.response?.data || error.message);
  }
}

// Run the function
getSeiBalances();
```

Run your first query:

```bash theme={"dark"}
node index.js
```

**Expected Output:**

```
🔍 Fetching Sei balances...
💰 Sei Balances:
  SEI: 1250.5 (3125.25 USD)
  USDC: 500.0 (500.0 USD)
```

## API Examples

### Balances API - Get Token Balances

```javascript theme={"dark"}
async function getSeiBalances() {
  try {
    const response = await axios.get(`${SIM_API_BASE}/evm/balances/${process.env.TEST_WALLET_ADDRESS}?chain_ids=1329`, { headers });

    const seiBalances = response.data.balances.filter((balance) => balance.chain === 'sei');

    console.log('💰 Sei Balances:');
    seiBalances.forEach((balance) => {
      console.log(`  ${balance.symbol}: ${balance.amount} (${balance.value_usd} USD)`);
    });
  } catch (error) {
    console.error('❌ Error fetching balances:', error.response?.data || error.message);
  }
}
```

### Transactions API - Monitor Wallet Transactions

```javascript theme={"dark"}
async function monitorSeiTransactions(address) {
  try {
    console.log(`📡 Monitoring transactions for ${address}...`);

    const response = await axios.get(`${SIM_API_BASE}/evm/transactions/${address}`, {
      headers,
      params: {
        chain: 'sei',
        limit: 10
      }
    });

    const transactions = response.data.transactions;

    console.log('🔄 Recent Transactions:');
    transactions.forEach((tx) => {
      console.log(`  Hash: ${tx.hash}`);
      console.log(`  From: ${tx.from} → To: ${tx.to}`);
      console.log(`  Value: ${tx.value} SEI`);
      console.log(`  Gas Used: ${tx.gas_used}`);
      console.log(`  Status: ${tx.success}`);
      console.log('  ---');
    });
  } catch (error) {
    console.error('❌ Error monitoring transactions:', error.message);
  }
}
```

### Token Info API - Get Token Metadata

```javascript theme={"dark"}
async function getTokenInfo(tokenAddress) {
  try {
    console.log('🏷️ Fetching token information...');

    const response = await axios.get(`${SIM_API_BASE}/evm/token-info/${tokenAddress}?chain_ids=1329`, { headers });
    const tokenInfo = response.data.tokens[0];

    console.log('📝 Token Information:');
    console.log(`  Name: ${tokenInfo.name}`);
    console.log(`  Symbol: ${tokenInfo.symbol}`);
    console.log(`  Decimals: ${tokenInfo.decimals}`);
    console.log(`  Total Supply: ${tokenInfo.total_supply}`);
    console.log(`  Current Price: ${tokenInfo.price_usd}`);
    console.log(`  Logo: ${tokenInfo.logo}`);

    return tokenInfo;
  } catch (error) {
    console.error('❌ Error fetching token info:', error.message);
  }
}

// Example usage with USDC address
getTokenInfo('0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392');
```

### Token Holders API - Find Top Holders

```javascript theme={"dark"}
async function getTokenHolders(tokenAddress, limit = 20) {
  try {
    console.log('👥 Fetching token holders...');

    const response = await axios.get(`${SIM_API_BASE}/evm/token-holders/1329/${tokenAddress}`, {
      headers,
      params: { limit }
    });

    const holders = response.data.holders;
    console.log(`🏆 Top ${holders.length} holders:`);
    holders.forEach((holder, index) => {
      console.log(`${index + 1}. ${holder.wallet_address}`);
      console.log(`   Balance: ${parseFloat(holder.balance)}`);
      console.log(`   First Acquired: ${holder.first_acquired}`);
      console.log('   ---');
    });

    return holders;
  } catch (error) {
    console.error('❌ Error fetching token holders:', error.message);
  }
}
```

### Activity API - Track Swaps and Transfers

```javascript theme={"dark"}
async function getWalletActivity(walletAddress, limit = 10) {
  try {
    console.log('⚡ Fetching wallet activity on Sei...');

    const response = await axios.get(`${SIM_API_BASE}/evm/activity/${walletAddress}?chain_ids=1329`, {
      headers,
      params: { limit }
    });

    const activities = response.data.activity;

    console.log(`📊 Recent activities (${activities.length}):`);
    activities.forEach((activity, index) => {
      console.log(`${index + 1}. Type: ${activity.type.toUpperCase()}`);
      console.log(`   Hash: ${activity.tx_hash}`);
      console.log(`   Time: ${new Date(activity.block_time).toLocaleString()}`);

      if (activity.type === 'receive' && activity.asset_type === 'erc20') {
        console.log(`   Received: ${activity.value} ${activity.token_metadata?.symbol}`);
        console.log(`   From: ${activity.from}`);
      }

      console.log('   ---');
    });

    return activities;
  } catch (error) {
    console.error('❌ Error fetching activity:', error.message);
  }
}
```

### Collectibles API - Get NFT Collections

```javascript theme={"dark"}
async function getNFTCollections(walletAddress) {
  try {
    console.log('🖼️ Fetching NFT collections...');

    const response = await axios.get(`${SIM_API_BASE}/evm/collectibles/${walletAddress}?chain_ids=1329`, { headers });

    const collectibles = response.data.entries;

    console.log(`🎨 NFT Collections (${collectibles.length}):`);

    // Group by collection
    const collections = {};
    collectibles.forEach((nft) => {
      if (!collections[nft.contract_address]) {
        collections[nft.contract_address] = {
          name: nft.collection_name,
          items: []
        };
      }
      collections[nft.contract_address].items.push(nft);
    });

    Object.entries(collections).forEach(([address, collection]) => {
      console.log(`📚 ${collection.name} (${collection.items.length} items)`);
      console.log(`   Contract: ${address}`);

      collection.items.slice(0, 3).forEach((nft) => {
        console.log(`   • Token ID: ${nft.token_id}`);
        console.log(`     Name: ${nft.name || 'Unnamed'}`);
        console.log(`     Image: ${nft.image_url || 'No image'}`);
      });

      if (collection.items.length > 3) {
        console.log(`   ... and ${collection.items.length - 3} more`);
      }
      console.log('   ---');
    });

    return collectibles;
  } catch (error) {
    console.error('❌ Error fetching NFTs:', error.message);
  }
}
```

## Advanced Use Cases

### Portfolio Analytics Dashboard

```javascript theme={"dark"}
require('dotenv').config();
const axios = require('axios');

const SIM_API_BASE = 'https://api.sim.dune.com/v1';

const headers = {
  'X-Sim-Api-Key': process.env.SIM_API_KEY,
  'Content-Type': 'application/json'
};

async function buildAdvancedPortfolio(walletAddress) {
  try {
    console.log('📊 Building advanced portfolio analytics...');

    // Get all data in parallel for better performance
    const [balancesRes, transactionsRes, activityRes, nftsRes] = await Promise.all([
      axios.get(`${SIM_API_BASE}/evm/balances/${walletAddress}?chain_ids=1329`, { headers }),
      axios.get(`${SIM_API_BASE}/evm/transactions/${walletAddress}`, {
        headers,
        params: { limit: 50, chain: 'sei' }
      }),
      axios.get(`${SIM_API_BASE}/evm/activity/${walletAddress}?chain_ids=1329`, {
        headers,
        params: { limit: 50 }
      }),
      axios.get(`${SIM_API_BASE}/evm/collectibles/${walletAddress}?chain_ids=1329`, { headers })
    ]);

    const balances = balancesRes.data.balances;
    const transactions = transactionsRes.data.transactions;
    const activities = activityRes.data.activity;
    const nfts = nftsRes.data.entries;

    // Calculate comprehensive metrics
    const totalValue = balances.reduce((sum, asset) => sum + parseFloat(asset.value_usd || 0), 0);
    const seiAssets = balances.filter((b) => b.chain === 'sei');
    const seiValue = seiAssets.reduce((sum, asset) => sum + parseFloat(asset.value_usd || 0), 0);

    console.log('💼 Advanced Portfolio Analytics:');
    console.log(`  Total Portfolio Value: $${totalValue.toFixed(2)}`);
    console.log(`  Sei Network Value: $${seiValue.toFixed(2)} (${((seiValue / totalValue) * 100).toFixed(1)}%)`);
    console.log(`  Total Assets: ${balances.length} tokens`);
    console.log(`  NFT Collections: ${new Set(nfts.map((n) => n.contract_address)).size}`);
    console.log(`  Total NFTs: ${nfts.length}`);

    return { totalValue, seiValue, balances, transactions, activities, nfts };
  } catch (error) {
    console.error('❌ Portfolio analytics error:', error.message);
  }
}
```

### Token Analysis Tool

```javascript theme={"dark"}
require('dotenv').config();
const axios = require('axios');

const SIM_API_BASE = 'https://api.sim.dune.com/v1';

const headers = {
  'X-Sim-Api-Key': process.env.SIM_API_KEY,
  'Content-Type': 'application/json'
};

async function analyzeToken(tokenAddress) {
  try {
    console.log(`🔍 Analyzing token: ${tokenAddress}`);

    // Get comprehensive token data
    const [infoRes, holdersRes] = await Promise.all([
      axios.get(`${SIM_API_BASE}/evm/token-info/${tokenAddress}?chain_ids=1329`, { headers }),
      axios.get(`${SIM_API_BASE}/evm/token-holders/1329/${tokenAddress}`, {
        headers,
        params: { limit: 100 }
      })
    ]);

    const tokenInfo = infoRes.data.tokens[0];
    const holders = holdersRes.data.holders;

    // Calculate holder distribution
    const totalSupply = parseFloat(tokenInfo.total_supply);
    const holderAnalysis = {
      whales: holders.filter((h) => parseFloat(h.balance) / totalSupply > 0.01).length, // >1%
      large: holders.filter((h) => {
        const pct = parseFloat(h.balance) / totalSupply;
        return pct > 0.001 && pct <= 0.01; // 0.1% - 1%
      }).length,
      medium: holders.filter((h) => {
        const pct = parseFloat(h.balance) / totalSupply;
        return pct > 0.0001 && pct <= 0.001; // 0.01% - 0.1%
      }).length
    };

    // Top holder concentration
    const top10Concentration = holders.slice(0, 10).reduce((sum, holder) => sum + parseFloat(holder.balance) / totalSupply, 0) * 100;

    console.log('📊 Token Analysis Results:');
    console.log(`  Name: ${tokenInfo.name} (${tokenInfo.symbol})`);
    console.log(`  Price: ${tokenInfo.price_usd}`);
    console.log(`  Total Supply: ${parseFloat(tokenInfo.total_supply).toLocaleString()}`);
    console.log(`  Total Holders: ${holders.length}`);
    console.log(`  Whales (>1%): ${holderAnalysis.whales}`);
    console.log(`  Large Holders (0.1-1%): ${holderAnalysis.large}`);
    console.log(`  Medium Holders (0.01-0.1%): ${holderAnalysis.medium}`);
    console.log(`  Top 10 Concentration: ${top10Concentration.toFixed(2)}%`);

    return { tokenInfo, holders, holderAnalysis };
  } catch (error) {
    console.error('❌ Token analysis failed:', error.message);
  }
}
// Run the function with a sample token address
analyzeToken('0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392'); // USDC address
```

## Error Handling & Best Practices

### Comprehensive Error Handling

```javascript theme={"dark"}
class SimAPIClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.sim.dune.com/v1';
    this.headers = {
      'X-Sim-Api-Key': apiKey,
      'Content-Type': 'application/json'
    };
  }

  async makeRequest(endpoint, params = {}) {
    const maxRetries = 3;
    let retries = 0;

    while (retries < maxRetries) {
      try {
        const response = await axios.get(`${this.baseURL}${endpoint}`, {
          headers: this.headers,
          params,
          timeout: 10000 // 10 second timeout
        });

        return response.data;
      } catch (error) {
        retries++;

        // Handle specific error types
        if (error.response?.status === 429) {
          console.log(`⏳ Rate limit hit. Waiting ${retries * 2} seconds...`);
          await this.sleep(retries * 2000);
          continue;
        }

        if (error.response?.status === 500 && retries < maxRetries) {
          console.log(`🔄 Server error. Retrying (${retries}/${maxRetries})...`);
          await this.sleep(1000);
          continue;
        }

        console.error('❌ API Error:', {
          status: error.response?.status,
          message: error.response?.data?.message || error.message,
          endpoint: endpoint
        });

        throw error;
      }
    }
  }

  sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}
```

### Rate Limiting

```javascript theme={"dark"}
class RateLimitedClient {
  constructor(apiKey, requestsPerSecond = 10) {
    this.client = new SimAPIClient(apiKey);
    this.requestsPerSecond = requestsPerSecond;
    this.lastRequest = 0;
  }

  async throttledRequest(endpoint, params) {
    const now = Date.now();
    const timeSinceLastRequest = now - this.lastRequest;
    const minInterval = 1000 / this.requestsPerSecond;

    if (timeSinceLastRequest < minInterval) {
      await new Promise((resolve) => setTimeout(resolve, minInterval - timeSinceLastRequest));
    }

    this.lastRequest = Date.now();
    return this.client.makeRequest(endpoint, params);
  }
}
```

## Troubleshooting

| Error                    | Cause                    | Solution                      |
| ------------------------ | ------------------------ | ----------------------------- |
| `Invalid API key`        | Wrong or expired key     | Check API key in dashboard    |
| `Rate limit exceeded`    | Too many requests        | Implement exponential backoff |
| `Chain not supported`    | Using unsupported chain  | Check supported chains list   |
| `Invalid address format` | Malformed wallet address | Validate address format       |
| `Request timeout`        | Network issues           | Increase timeout, add retries |
| `Insufficient data`      | New address/contract     | Wait for indexing to complete |

## Resources

### Official Documentation

* **Sim Documentation**: [https://docs.sim.dune.com](https://docs.sim.dune.com)
* **Sim Dashboard**: [https://sim.dune.com](https://sim.dune.com)
* **Sei Explorer**: [https://seiscan.io](https://seiscan.io)

### Community Resources

* **Dune Discord**: [https://discord.gg/dune](https://discord.com/invite/ErrzwBz)
* **Sei Discord**: [https://discord.gg/sei](https://discord.gg/sei)

## Next Steps

1. **Scale Your Application**: Implement caching, database storage, and horizontal scaling
2. **Build a Frontend**: Create React/Vue.js dashboards to visualize your data
3. **Advanced Analytics**: Implement machine learning for predictive analytics
4. **Custom Indexers**: Build specialized data pipelines for specific protocols
5. **API Integration**: Connect with other services like price feeds, news APIs

---

URL: https://docs.sei.io/evm/indexer-providers/moralis

# Moralis

> Complete guide to integrating Moralis with Sei blockchain for Web3 development

Moralis is an enterprise-grade Web3 API provider that connects any tech stack to blockchain networks, offering multichain blockchain data for wallets, tokens, NFTs, DeFi protocols, and more through one fast, reliable API.

Moralis provides a comprehensive Backend-as-a-Service (BaaS) platform specifically designed for developers. By abstracting away the complexity of blockchain integration and offering a suite of APIs, SDKs, and scalable infrastructure, Moralis allows developers to focus on building the core functionality of their applications.

## What You'll Learn

By the end of this tutorial, you'll understand:

* How to set up and configure Moralis for Sei blockchain integration
* Working with different Moralis APIs (Wallet, NFT, Token, and Blockchain APIs)
* Fetching wallet transactions and balances
* Retrieving NFT holder information and metadata
* Getting transaction details and token information

## Prerequisites

Before starting with this guide, ensure you have:

1. **Moralis Account**: Create a free account at [moralis.io](https://moralis.io)
2. **Node.js**: Version 14 or higher installed
3. **Package Manager**: npm, yarn, or pnpm
4. **TypeScript**: Basic knowledge (optional but recommended)

### Sei Network Configuration

<Info>Following is the configuration details of Sei for Moralis integration:</Info>

**Mainnet:**

* Chain ID: 1329 (0x531)
* RPC URL: [https://evm-rpc.sei-apis.com](https://evm-rpc.sei-apis.com)

**Testnet:**

* Chain ID: 1328 (0x530)
* RPC URL: [https://evm-rpc-testnet.sei-apis.com](https://evm-rpc-testnet.sei-apis.com)

## Moralis APIs Overview

Moralis offers several powerful APIs that work seamlessly across multiple blockchains:

* **NFT API**: Access comprehensive NFT data including metadata, ownership details, and transaction history
* **Wallet API**: Retrieve real-time wallet data including balances, transaction history, and token holdings
* **Token API**: Get token information, prices, and transfer data
* **Blockchain API**: Fetch raw blockchain data - blocks, transactions, and logs
* **Price API**: Retrieve real-time and historical crypto token prices
* **DeFi API**: Query DeFi protocol data including pools, positions, and yields

## Setting Up Your Project

### Install Moralis SDK

First, create a new project and install the Moralis SDK:

```bash theme={"dark"}
# Create new project
mkdir moralis-sei-integration
cd moralis-sei-integration

# Initialize package.json
npm init -y

# Install Moralis SDK
npm install moralis

# For TypeScript projects, also install:
npm install @moralisweb3/common-evm-utils
npm install typescript ts-node @types/node --save-dev
```

### Get Your API Key

1. Sign up at [moralis.io](https://moralis.io)
2. Navigate to "Project Settings"
3. Copy your API key from the dashboard

### Basic Configuration

Create a `.env` file in your project root:

```env theme={"dark"}
MORALIS_API_KEY=your_api_key_here
SEI_MAINNET_CHAIN_ID=0x531
SEI_TESTNET_CHAIN_ID=0x530
```

## Initialize Moralis

Create an `index.ts` or `index.js` file:

```typescript theme={"dark"}
import Moralis from 'moralis';

// Initialize Moralis
const initMoralis = async () => {
  await Moralis.start({
    apiKey: process.env.MORALIS_API_KEY
  });
  console.log('Moralis initialized successfully');
};

// Call initialization
initMoralis();
```

## Wallet Transactions API

```typescript theme={"dark"}
// Get wallet transactions for Sei mainnet
const getWalletTransactions = async (walletAddress: string) => {
  try {
    const response = await Moralis.EvmApi.transaction.getWalletTransactions({
      address: walletAddress,
      chain: '0x531' // Sei mainnet
    });

    console.log('Wallet Transactions:', response.raw);
    return response.raw;
  } catch (error) {
    console.error('Error fetching wallet transactions:', error);
    throw error;
  }
};

// Example usage
const walletAddress = '0x742d35Cc6636C0532925a3b8D62c5bceCdB8eBc8';
getWalletTransactions(walletAddress);
```

## NFT Holders API

```typescript theme={"dark"}
// Get NFTs owned by wallet address
const getWalletNFTs = async (walletAddress: string) => {
  try {
    const response = await Moralis.EvmApi.nft.getWalletNFTs({
      address: walletAddress,
      chain: '0x531' // Sei mainnet
    });

    console.log('Wallet NFTs:', response.raw);
    return response.raw;
  } catch (error) {
    console.error('Error fetching wallet NFTs:', error);
    throw error;
  }
};

// Get NFT owners for a specific contract
const getNFTOwners = async (contractAddress: string) => {
  try {
    const response = await Moralis.EvmApi.nft.getNFTOwners({
      address: contractAddress,
      chain: '0x531' // Sei mainnet
    });

    console.log('NFT Owners:', response.raw);
    return response.raw;
  } catch (error) {
    console.error('Error fetching NFT owners:', error);
    throw error;
  }
};
```

## Transaction Details API

```typescript theme={"dark"}
// Get detailed transaction information
const getTransactionDetails = async (transactionHash: string) => {
  try {
    const response = await Moralis.EvmApi.transaction.getTransaction({
      transactionHash: transactionHash,
      chain: '0x531' // Sei mainnet
    });

    console.log('Transaction Details:', response.raw);
    return response.raw;
  } catch (error) {
    console.error('Error fetching transaction details:', error);
    throw error;
  }
};

// Get transaction verbose (with decoded logs)
const getTransactionVerbose = async (transactionHash: string) => {
  try {
    const response = await Moralis.EvmApi.transaction.getTransactionVerbose({
      transactionHash: transactionHash,
      chain: '0x531' // Sei mainnet
    });

    console.log('Transaction Verbose:', response.raw);
    return response.raw;
  } catch (error) {
    console.error('Error fetching verbose transaction:', error);
    throw error;
  }
};
```

## Token API

```typescript theme={"dark"}
// Get token balances for a wallet
const getTokenBalances = async (walletAddress: string) => {
  try {
    const response = await Moralis.EvmApi.token.getWalletTokenBalances({
      address: walletAddress,
      chain: '0x531' // Sei mainnet
    });

    console.log('Token Balances:', response.raw);
    return response.raw;
  } catch (error) {
    console.error('Error fetching token balances:', error);
    throw error;
  }
};

// Get token transfers for a wallet
const getTokenTransfers = async (walletAddress: string) => {
  try {
    const response = await Moralis.EvmApi.token.getWalletTokenTransfers({
      address: walletAddress,
      chain: '0x531' // Sei mainnet
    });

    console.log('Token Transfers:', response.raw);
    return response.raw;
  } catch (error) {
    console.error('Error fetching token transfers:', error);
    throw error;
  }
};

// Get token metadata
const getTokenMetadata = async (tokenAddress: string) => {
  try {
    const response = await Moralis.EvmApi.token.getTokenMetadata({
      addresses: [tokenAddress],
      chain: '0x531' // Sei mainnet
    });

    console.log('Token Metadata:', response.raw);
    return response.raw;
  } catch (error) {
    console.error('Error fetching token metadata:', error);
    throw error;
  }
};
```

## Complete Integration Example

Here's a comprehensive example that brings everything together:

```typescript theme={"dark"}
import Moralis from 'moralis';
import dotenv from 'dotenv';

dotenv.config();

class SeiMoralisService {
  private initialized = false;

  async initialize() {
    if (!this.initialized) {
      await Moralis.start({
        apiKey: process.env.MORALIS_API_KEY
      });
      this.initialized = true;
      console.log('Moralis initialized for Sei blockchain');
    }
  }

  async getWalletOverview(walletAddress: string) {
    await this.initialize();

    try {
      // Get all wallet data in parallel
      const [nfts, tokenBalances] = await Promise.all([this.getWalletNFTs(walletAddress), this.getTokenBalances(walletAddress)]);

      return {
        address: walletAddress,
        nfts: nfts.result,
        tokenBalances: tokenBalances,
        summary: {
          totalNFTs: nfts,
          totalTokenTypes: tokenBalances.length
        }
      };
    } catch (error) {
      console.error('Error getting wallet overview:', error);
      throw new Error('Failed to retrieve wallet overview');
    }
  }

  async getWalletNFTs(walletAddress: string) {
    return await Moralis.EvmApi.nft.getWalletNFTs({
      address: walletAddress,
      chain: '0x531'
    });
  }

  async getTokenBalances(walletAddress: string) {
    const response = await Moralis.EvmApi.token.getWalletTokenBalances({
      address: walletAddress,
      chain: '0x531'
    });
    return response.raw;
  }
}

// Usage example
const seiService = new SeiMoralisService();

async function main() {
  try {
    const walletAddress = 'your_wallet_address_here';
    const overview = await seiService.getWalletOverview(walletAddress);

    console.log('Wallet Overview:', JSON.stringify(overview, null, 2));
  } catch (error) {
    console.error('Main execution error:', error);
  }
}

main();
```

## Working with Testnet

<Warning>To switch to Sei testnet, change the chain ID in your API calls.</Warning>

```typescript theme={"dark"}
// Testnet configuration
const TESTNET_CONFIG = {
  chainId: '0x530', // Sei testnet EVM chain ID
  rpcUrl: 'https://evm-rpc-testnet.sei-apis.com',
  explorer: 'https://testnet.seiscan.io'
};

// Use testnet in your API calls
const response = await Moralis.EvmApi.transaction.getWalletTransactions({
  address: walletAddress,
  chain: TESTNET_CONFIG.chainId
});
```

<Info> For a complete API reference and additional guides visit the [Moralis Documentation](https://docs.moralis.com/) </Info>

---

URL: https://docs.sei.io/evm/wallet-integrations/particle

# Social logins with Particle Connect

> Comprehensive guide on Social logins with Particle Connect on Sei. Learn key concepts, commands, and best practices.

[Particle Network](https://particle.network) simplifies onboarding into both
EOAs and ERC-4337 smart accounts using its Wallet Abstraction stack.
Specifically, Particle enables an aggregated modal featuring both social logins
and wallet adapters (such as MetaMask) fully compatible with Sei, enabling
2-click onboarding.

The Particle Connect user flow begins with social login, either through custom
authentication or predefined options offered by the platform (like email,
Google, X). This process generates an EOA using MPC-TSS, which then can act as
the Signer for a smart account. This can include implementations like
`SimpleAccount` or Biconomy (V1/V2), depending on the application's
requirements.

This guide provides a high-level overview of the steps required to build a demo
application on Sei using the
[Particle Connect SDK](https://developers.particle.network/social-logins/connect/desktop/web),
Particle's leading onboarding solution. We'll implement the aforementioned
modal, enabling social logins and wallet connection, while also using account
abstraction to send a gasless transaction.

Thus, the demo application we'll build will:

1. Use a **SimpleAccount** instance of a smart account to onboard users via
   social login.
2. Execute a **gasless (sponsored) transaction**, showcasing the SDK's
   capability to simplify user interactions on the Sei blockchain.

## Getting started

### Dependencies

To integrate Particle Connect into your Sei application, you'll need just a few
dependencies. While Particle Connect includes built-in support for Account
Abstraction (AA), this example demonstrates using the Particle AA SDK alongside
an EIP-1193 provider, such as ethers.js.

```bash theme={"dark"}
yarn add @particle-network/connectkit viem@^2 @particle-network/aa ethers
```

### Setting up the Particle dashboard

Before jumping into the configuration process, you'll need to go to the
[Particle dashboard](https://dashboard.particle.network) to retrieve three keys
required for your project.

When using any SDK offered by Particle Network, you'll routinely need a
`projectId`, `clientKey`, and `appId`. These exist to authenticate your project
and create a connection between your instance of Particle Auth and the Particle
dashboard (which allows you to customize the application-embedded modals, track
users, fund gasless transactions, and so on).

Once you've navigated to the Particle dashboard, follow the process below:

1. Create a new project through **Add New Project**.
2. Click **Web** under **Your Apps** (if you intend to use an alternative
   platform, take a look at the
   [platform-specific guides on Particle's documentation](https://developers.particle.network/social-logins/connect/introduction))
3. Choose a name and domain for your application (if you have yet to deploy or
   decide on a domain where you intend to deploy, feel free to use any filler
   one).
4. Copy the **Project ID**, **Client Key** and **App ID**.

Given the nature of these values, it's recommended that you store them within a
`.env` file with this format:

```shell theme={"dark"}
NEXT_PUBLIC_PROJECT_ID='PROJECT_ID'
NEXT_PUBLIC_CLIENT_KEY='CLIENT_KEY'
NEXT_PUBLIC_APP_ID='APP_ID'
NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID='WALLETCONNECT_PROJECT_ID'
```

## Configuring Particle Connect

To get started, we'll configure and initialize Particle Connect. Begin by
creating a new `ConnectKit.tsx` file in your `src` directory.

This file will define the `ParticleConnectKit` component, which wraps the
configured `ConnectKitProvider` instance. This component will be the central hub
for managing and providing Particle Connect configuration across your
application.

```typescript theme={"dark"}
"use client";

import React from "react";
import { ConnectKitProvider, createConfig } from "@particle-network/connectkit";
import { authWalletConnectors } from "@particle-network/connectkit/auth";
import { evmWalletConnectors } from "@particle-network/connectkit/evm";
import { sei, seiTestnet } from "@particle-network/connectkit/chains";
import { wallet, EntryPosition } from "@particle-network/connectkit/wallet";
import { aa } from "@particle-network/connectkit/aa";

const config = createConfig({
  projectId: process.env.NEXT_PUBLIC_PROJECT_ID!,
  clientKey: process.env.NEXT_PUBLIC_CLIENT_KEY!,
  appId: process.env.NEXT_PUBLIC_APP_ID!,

  walletConnectors: [
    authWalletConnectors({}), // Social logins

    // Default Web3 logins
    evmWalletConnectors({
      walletConnectProjectId: process.env.NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID, // optional, retrieved from https://cloud.walletconnect.com
    }),
  ],

  plugins: [
    wallet({
      entryPosition: EntryPosition.BR, // Positions the modal button at the bottom right on login
      visible: true, // Determines if the wallet modal is displayed
    }),
    aa({
      name: "SIMPLE",
      version: "2.0.0",
    }),
  ],
  chains: [sei, seiTestnet],
});

export const ParticleConnectkit = ({ children }: React.PropsWithChildren) => {
  return <ConnectKitProvider config={config}>{children}</ConnectKitProvider>;
};
```

This code sets up Particle Connect with a configuration for wallet
authentication and blockchain interactions on Sei and Sei testnet. It includes
social logins and traditional Web3 options through WalletConnect and enables
Account Abstraction (AA) with a `SimpleAccount` instance version 2.0.0. The
configured `ConnectKitProvider` component then wraps the app’s content, making
this configuration available.

## Integrate Particle Connect in Your App

Once configured, wrap your application with the `ParticleConnectKit` component
to make the Particle Connect SDK accessible throughout the app. Update the
`layout.tsx` file in the `src` directory as shown below:

```tsx theme={"dark"}
import { ParticleConnectkit } from '@/components/Connectkit';
import type { Metadata } from 'next';
import { Inter } from 'next/font/google';
import './globals.css';

const inter = Inter({ subsets: ['latin'] });

export const metadata: Metadata = {
  title: 'Particle Connectkit App',
  description: 'Generated by create next app'
};

export default function RootLayout({
  children
}: Readonly<{
  children: React.ReactNode;
}>) {
  return (
    <html lang="en">
      <body className={inter.className}>
        <ParticleConnectkit>{children}</ParticleConnectkit>
      </body>
    </html>
  );
}
```

## Building the Application

With your project set up, dependencies installed, and Particle Connect
configured, you can start building in the `page.tsx` file.

In `page.tsx`, you’ll define the core features: login flow, transaction
handling, and the UI.

### Connecting the Wallet

With `layout.tsx` configured, the next step is to add a primary **Connect
Wallet** button to facilitate user login. Import `ConnectButton` from
`@particle-network/connectkit` and add it to the interface. After the user logs
in, the `ConnectButton` component will throw a unified login modal upon
clicking, an example of this modal is viewable
[here](https://demo.particle.network).

```tsx theme={"dark"}
'use client';
import { ConnectButton, useAccount } from '@particle-network/connectkit';

const HomePage = () => {
  const { address, isConnected, chainId } = useAccount();

  return (
    <div className="flex justify-center items-center h-screen">
      <div className="text-center">
        <ConnectButton />
        {isConnected && (
          <>
            <h2>Address: {address}</h2>
            <h2>Chain ID: {chainId}</h2>
          </>
        )}
      </div>
    </div>
  );
};

export default HomePage;
```

### Sending Transactions with an EIP-1193 Provider

Particle Connect includes AA features out of the box, but using it with the
Particle AA SDK allows you to work with EIP-1193 providers, like `ethers`. This
approach is especially helpful if you're already familiar with these providers
or are integrating Particle Connect into an existing app.

To implement this, wrap the smart account provided by Particle Connect in an
instance of `ethers` to create a `customProvider`. With this setup, you can use
`ethers` as usual, with the smart account handling the signing of transactions
in the background.

```tsx theme={"dark"}
import { useSmartAccount } from '@particle-network/connectkit';
import { AAWrapProvider, SendTransactionMode } from '@particle-network/aa';

const smartAccount = useSmartAccount();

// Init custom provider with gasless transaction mode
const customProvider = smartAccount ? new ethers.BrowserProvider(new AAWrapProvider(smartAccount, SendTransactionMode.Gasless) as Eip1193Provider, 'any') : null;

/**
 * Sends a transaction using the ethers.js library.
 * This transaction is gasless since the customProvider is initialized as gasless
 */
const executeTxEthers = async () => {
  if (!customProvider) return;

  const signer = await customProvider.getSigner();
  const tx = {
    to: recipientAddress,
    value: parseEther('0.01').toString()
  };

  const txResponse = await signer.sendTransaction(tx);
  const txReceipt = await txResponse.wait();
  console.log(txReceipt?.hash);
};
```

This transaction will be gasless because it meets two key conditions:

1. **Gasless Mode Configuration**: By setting `SendTransactionMode.Gasless`
   within `AAWrapProvider`, we've specified that the transaction should be
   gasless and sponsored.
2. **Funding Requirements**: On Sei testnet, all transactions are
   automatically sponsored, meaning you don't need to deposit funds to cover
   transaction fees. However, on Sei mainnet, the Paymaster (configurable
   in the [Particle dashboard](https://dashboard.particle.network)) would need
   sufficient funds to sponsor these transactions.

This example demonstrates how to use an existing EIP-1193 provider, but you can
also construct a `userOp` directly with Particle Connect. For an example, refer
to the
[starter repository](https://github.com/Particle-Network/connectkit-aa-usage/blob/2017262daf297624362d51f3d50cccd3b4606ef9/app/page.tsx#L117).

## Full app example

With the setup complete, Particle Connect can now be leveraged, as demonstrated
in the example application below.

In this example, the application creates a smart account on Sei using a social
login or a Web3 login and sends a gasless transaction of 0.001 SEI via the
`ethers` provider.

```tsx theme={"dark"}
'use client';
import React, { useEffect, useState } from 'react';

// Particle imports
import { ConnectButton, useAccount, usePublicClient, useSmartAccount } from '@particle-network/connectkit';

// Eip1193 and AA Provider
import { AAWrapProvider, SendTransactionMode } from '@particle-network/aa'; // Only needed with Eip1193 provider
import { ethers, type Eip1193Provider } from 'ethers';
import { formatEther, parseEther } from 'viem';

export default function Home() {
  const { isConnected, chain } = useAccount();
  const publicClient = usePublicClient();
  const smartAccount = useSmartAccount();

  const [userAddress, setUserAddress] = useState<string>('');
  const [balance, setBalance] = useState<string | null>(null);
  const [recipientAddress, setRecipientAddress] = useState<string>('');
  const [transactionHash, setTransactionHash] = useState<string | null>(null);

  // Init custom provider with gasless transaction mode
  const customProvider = smartAccount ? new ethers.BrowserProvider(new AAWrapProvider(smartAccount, SendTransactionMode.Gasless) as Eip1193Provider, 'any') : null;

  /**
   * Fetches the balance of a given address.
   * @param {string} address - The address to fetch the balance for.
   */
  const fetchBalance = async (address: string) => {
    try {
      const balanceResponse = await publicClient?.getBalance({
        address: address as `0x${string}`
      });
      if (balanceResponse) {
        const balanceInEther = formatEther(balanceResponse).toString();
        setBalance(balanceInEther);
      } else {
        setBalance('0.0');
      }
    } catch (error) {
      console.error('Error fetching balance:', error);
      setBalance('0.0');
    }
  };

  /**
   * Loads the user's account data, including address and balance.
   */
  useEffect(() => {
    const loadAccountData = async () => {
      if (isConnected && smartAccount) {
        try {
          const address = await smartAccount.getAddress();
          setUserAddress(address);
          await fetchBalance(address);
        } catch (error) {
          console.error('Error loading account data:', error);
        }
      }
    };
    loadAccountData();
  }, [isConnected, smartAccount]);

  /**
   * Sends a transaction using the ethers.js library.
   * This transaction is gasless since the customProvider is initialized as gasless
   */
  const executeTxEthers = async () => {
    if (!customProvider) return;

    const signer = await customProvider.getSigner();
    try {
      const tx = {
        to: recipientAddress,
        value: parseEther('0.001').toString()
      };

      const txResponse = await signer.sendTransaction(tx);
      const txReceipt = await txResponse.wait();

      setTransactionHash(txReceipt?.hash || null);
    } catch (error) {
      console.error('Failed to send transaction using ethers.js:', error);
    }
  };

  return (
    <div className="container min-h-screen flex flex-col justify-center items-center mx-auto gap-4 px-4 md:px-8">
      <div className="w-full flex justify-center mt-4">
        <ConnectButton label="Click to login" />
      </div>
      {isConnected && (
        <>
          <div className="border border-purple-500 p-6  w-full">
            <h2 className="text-lg font-semibold mb-2 text-white">
              Address: <code>{userAddress || 'Loading...'}</code>
            </h2>
            <h2 className="text-lg font-semibold mb-2 text-white">
              Balance: {balance || 'Loading...'} {chain?.nativeCurrency.symbol}
            </h2>
            <input type="text" placeholder="Recipient Address" value={recipientAddress} onChange={(e) => setRecipientAddress(e.target.value)} className="mt-4 p-3 w-full rounded border border-gray-700 bg-gray-900 text-white focus:outline-none" />
            <button className="bg-purple-600 hover:bg-purple-700 text-white font-bold py-2 px-4 rounded mt-4" onClick={executeTxEthers} disabled={!recipientAddress}>
              Send 0.001 {chain?.nativeCurrency.name}
            </button>
            {transactionHash && <p className="text-green-500 mt-4">Transaction Hash: {transactionHash}</p>}
          </div>
        </>
      )}
    </div>
  );
}
```

### Available Particle Connect Hooks

This example illustrates a basic use of Particle Connect. For a complete list of
available hooks, refer to the
[Particle Connect documentation](https://developers.particle.network/social-logins/connect/desktop/web#key-react-hooks-for-particle-connect).

## Conclusion

Building an application on Sei that takes advantage of social logins and smart
accounts simultaneously only takes a few lines of code, and is even more
succinct if you're already using Ethers, Web3.js, or any other standard library
that supports EIP-1193 providers.

To view the complete demo application leveraging the code snippets covered
throughout this document, take a look at the
[GitHub repository](https://github.com/Particle-Network/sei-aa-connect).

Additionally, to learn more about Particle Network, explore the following
resources:

* [Website](https://particle.network)
* [Blog](https://blog.particle.network)
* [Documentation](https://developers.particle.network)

---

URL: https://docs.sei.io/evm/wallet-integrations/pimlico

# Pimlico Account Abstraction Integration

> Learn how to integrate Pimlico's account abstraction services with Sei network for gasless transactions and smart account functionality.

[Pimlico](https://pimlico.io) is an Account Abstraction infrastructure provider that enables developers to easily integrate smart accounts and gasless transactions into their Sei applications. This guide will walk you through creating a smart account and sending your first gasless transaction on Sei Testnet using Pimlico's infrastructure.

## Getting Started

### Dependencies

To integrate Pimlico into your Sei application, you'll need to install the following dependencies:

```bash theme={"dark"}
pnpm install permissionless viem dotenv
```

<Info>permissionless.js is an AA SDK that works with any account, paymaster, or bundler implementation - no vendor lock-in.</Info>

### Setting up Pimlico Dashboard

Before starting the integration:

1. Visit the [Pimlico dashboard](https://dashboard.pimlico.io)
2. Create an account and generate an API key
3. Store your API key in a `.env` file:

```shell theme={"dark"}
PIMLICO_API_KEY='pim_xxxxxxxxxxxxxxxxxxxxxx'
```

## Configuring Pimlico Client

First, let's set up the necessary clients and configurations.

```typescript theme={"dark"}
import { createSmartAccountClient } from 'permissionless';
import { createPimlicoClient } from 'permissionless/clients/pimlico';
import { createPublicClient, http, Hex } from 'viem';
import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
import { seiTestnet } from 'viem/chains';
import { toSimpleSmartAccount } from 'permissionless/accounts';
import { writeFileSync } from 'fs';
import 'dotenv/config';

const apiKey = process.env.PIMLICO_API_KEY;
if (!apiKey) throw new Error('Missing PIMLICO_API_KEY');

// Generate or load private key
const privateKey =
  process.env.PRIVATE_KEY ??
  (() => {
    const pk = generatePrivateKey();
    writeFileSync('.env', `PRIVATE_KEY=${pk}`);
    return pk;
  })();

// Create public client
export const publicClient = createPublicClient({
  chain: seiTestnet,
  transport: http('https://evm-rpc-testnet.sei-apis.com')
});

// Create Pimlico client
const pimlicoUrl = `https://api.pimlico.io/v2/${seiTestnet.id}/rpc?apikey=${apiKey}`;

export const pimlicoClient = createPimlicoClient({
  chain: seiTestnet,
  transport: http(pimlicoUrl)
});
```

## Creating a Smart Account

Now let's create a simple smart account instance. This account will be controlled by a single EOA signer:

```typescript theme={"dark"}
import { toSimpleSmartAccount } from 'permissionless/accounts';

const account = await toSimpleSmartAccount({
  client: publicClient,
  owner: privateKeyToAccount(privateKey as Hex)
});

console.log(`Smart account address: ${account.address}`);
```

<Info>For a full list of all supported smart account types in permissionless.js see [here](https://docs.pimlico.io/permissionless/how-to/accounts/comparison)</Info>

## Setting up the Smart Account Client

To interact with the smart account, we need to create a SmartAccountClient:

```typescript theme={"dark"}
import { createSmartAccountClient } from 'permissionless';

const smartAccountClient = createSmartAccountClient({
  account,
  chain: seiTestnet,
  bundlerTransport: http(pimlicoUrl),
  paymaster: pimlicoClient,
  userOperation: {
    estimateFeesPerGas: async () => {
      return (await pimlicoClient.getUserOperationGasPrice()).fast;
    }
  }
});
```

## Sending a Gasless Transaction

With everything set up, we can now send a gasless transaction from our smart account:

```typescript theme={"dark"}
const txHash = await smartAccountClient.sendTransaction({
  to: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
  value: 0n,
  data: '0x1234'
});

console.log(`Transaction included: ${txHash}`);
return txHash;
```

## Complete Example

Here's a complete example that puts everything together:

```typescript theme={"dark"}
import { createSmartAccountClient } from 'permissionless';
import { createPimlicoClient } from 'permissionless/clients/pimlico';
import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
import { createPublicClient, http, Hex } from 'viem';
import { seiTestnet } from 'viem/chains';
import { toSimpleSmartAccount } from 'permissionless/accounts';
import { writeFileSync } from 'fs';
import 'dotenv/config';

async function main() {
  // Initialize clients and account
  const apiKey = process.env.PIMLICO_API_KEY;
  if (!apiKey) throw new Error('Missing PIMLICO_API_KEY');

  // Generate or load private key
  const privateKey =
    process.env.PRIVATE_KEY ??
    (() => {
      const pk = generatePrivateKey();
      writeFileSync('.env', `PRIVATE_KEY=${pk}`);
      return pk;
    })();

  // Create public client
  const publicClient = createPublicClient({
    chain: seiTestnet,
    transport: http('https://evm-rpc-testnet.sei-apis.com')
  });

  // Create Pimlico client
  const pimlicoUrl = `https://api.pimlico.io/v2/${seiTestnet.id}/rpc?apikey=${apiKey}`;

  const pimlicoClient = createPimlicoClient({
    chain: seiTestnet,
    transport: http(pimlicoUrl)
  });

  // Create smart account
  const account = await toSimpleSmartAccount({
    client: publicClient,
    owner: privateKeyToAccount(privateKey as Hex)
  });

  console.log(`Smart account address: ${account.address}`);

  // Create smart account client
  const smartAccountClient = createSmartAccountClient({
    account,
    chain: seiTestnet,
    bundlerTransport: http(pimlicoUrl),
    paymaster: pimlicoClient,
    userOperation: {
      estimateFeesPerGas: async () => {
        return (await pimlicoClient.getUserOperationGasPrice()).fast;
      }
    }
  });

  // Send transaction
  const txHash = await smartAccountClient.sendTransaction({
    to: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
    value: 0n,
    data: '0x1234'
  });

  console.log(`Transaction included: ${txHash}`);
}

main().catch(console.error);
```

## What's Happening Under the Hood?

When you send a transaction using the smart account client:

1. The client builds a user operation (a transaction format for smart accounts)
2. Requests sponsorship from Pimlico's paymaster
3. Signs the operation with the smart account owners's private key
4. Submits it to Pimlico's bundler
5. The bundler monitors the chain until the operation is included in a block

The first transaction will also deploy your smart account contract if it hasn't been deployed yet.

## Conclusion

You've now learned how to:

* Set up Pimlico's infrastructure
* Create a smart account
* Send gasless transactions

This implementation enables a seamless user experience where end users don't need to worry about gas or managing native tokens to interact with your dApp.

For more information about Pimlico and its features, check out:

* [Pimlico Documentation](https://docs.pimlico.io)
* [Pimlico Dashboard](https://dashboard.pimlico.io)
* [Pimlico GitHub](https://github.com/pimlicolabs)

Join the [Pimlico Telegram](https://t.me/pimlicoHQ) community to get help and share what you're building!

---

URL: https://docs.sei.io/evm/wallet-integrations/thirdweb

# Thirdweb

> Learn how to integrate thirdweb's Account Abstraction SDK with Sei network to build decentralized applications with seamless wallet connectivity.

## Overview

This guide provides a comprehensive, step-by-step tutorial for integrating thirdweb's Account Abstraction SDK on Sei. By the end of this guide, you will understand how to create seamless wallet connectivity with social logins and build decentralized applications with sponsored gas transactions.

## What This Guide Covers

* Core concepts and benefits for user experience
* Creating a React application with thirdweb SDK and Vite
* Setting up social logins and gasless transactions
* Interacting with smart contracts

## Prerequisites

Before starting, ensure you have:

* Node.js v18+ installed
* Basic knowledge of React and TypeScript
* A thirdweb account with API key from [thirdweb Dashboard](https://thirdweb.com/dashboard)
* A deployed smart contract on SEI (we'll use a simple Storage contract)

<Warning>**For Mainnet**: An active thirdweb Pay As You Go subscription (\$5/month minimum) is required for gas sponsorship on mainnet.</Warning>

## What is Account Abstraction?

Account Abstraction (AA) is a paradigm that transforms how users interact with blockchain applications. Instead of traditional externally-owned accounts (EOAs), users get smart contract wallets that enable advanced features.

### Core Concepts

* **Smart Wallets**: Contract-based accounts with programmable logic
* **Gas Sponsorship**: Dapps pay transaction fees on behalf of users
* **Social Recovery**: Alternative authentication methods beyond private keys
* **Batch Transactions**: Multiple operations in a single transaction

## Network Information

### SEI Mainnet Configuration

* **Network Name**: SEI EVM
* **Chain ID**: 1329
* **Public RPC URL**: `https://evm-rpc.sei-apis.com`
* **Explorer**: [https://seiscan.io/](https://seiscan.io/)
* **Currency**: SEI
* **thirdweb RPC**: `https://1329.rpc.thirdweb.com/{YOUR_CLIENT_ID}`

### Step 1: Deploy a Storage Contract

Before integrating the SDK, deploy a simple Storage contract on SEI. This contract will store and retrieve a number.

#### Storage Contract (Solidity)

```solidity title="Storage.sol" theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Storage {
    uint256 private value;

    function store(uint256 num) public {
        value = num;
    }

    function retrieve() public view returns (uint256) {
        return value;
    }
}
```

Deploy this contract using [Remix](https://remix.ethereum.org/) on Sei. Note down the contract address - you'll need it in the code.

### Step 2: Project Setup

#### Create a New Project

```bash theme={"dark"}
npm create vite@latest sei-thirdweb-app -- --template react-ts
cd sei-thirdweb-app
npm install
```

#### Install Dependencies

```bash theme={"dark"}
npm install thirdweb@^5
```

#### Configure Environment Variables

Create a `.env` file in your project root:

```env title=".env" theme={"dark"}
VITE_TEMPLATE_CLIENT_ID=your_thirdweb_client_id_here
```

Get your Client ID from [thirdweb Dashboard](https://thirdweb.com/dashboard) → Settings → API Keys.

#### Enable Gas Sponsorship

If you want to sponsor gas on mainnet:

1. Go to [thirdweb Dashboard Billing](https://thirdweb.com/dashboard/settings/billing)
2. Subscribe to the **Pay As You Go** plan (\$5/month)
3. Without this, sponsored transactions will fail on mainnet

### Step 3: Configure thirdweb Client

Create `src/client.ts`:

```typescript title="src/client.ts" theme={"dark"}
import { createThirdwebClient } from 'thirdweb';

export const client = createThirdwebClient({
  clientId: import.meta.env.VITE_TEMPLATE_CLIENT_ID
});
```

### Step 4: Smart Contract Integration

Replace `src/App.tsx`:

```typescript title="src/App.tsx" lines theme={"dark"}
import {
  ConnectButton,
  TransactionButton,
  useActiveAccount,
  useReadContract,
} from "thirdweb/react";
import { inAppWallet } from "thirdweb/wallets";
import { client } from "./client";
import { getContract } from "thirdweb";
import { defineChain } from "thirdweb/chains";
import { prepareContractCall, sendAndConfirmTransaction } from "thirdweb";

const THIRDWEB_API_KEY = import.meta.env.VITE_TEMPLATE_CLIENT_ID;

// Configure Sei network
const rpc = `https://1329.rpc.thirdweb.com/${THIRDWEB_API_KEY}`;
const seiChain = defineChain({
  id: 1329,
  rpc,
});

// Your deployed Storage contract address
const storageContract = getContract({
  client,
  chain: seiChain,
  address: "0xYourContractAddressHere", // Replace with your contract address
});

// Configure wallet options
const wallets = [
  inAppWallet({
    auth: {
      options: [
        "google",
        "x",
        "apple",
        "discord",
        "facebook",
        "farcaster",
        "telegram",
        "email",
        "phone",
        "passkey",
        "guest",
      ],
    },
  }),
];

// Store custom value function
async function handleStore(account: any, value: string) {
  if (!account) return;

  const transaction = prepareContractCall({
    contract: storageContract,
    method: "function store(uint256 num)",
    params: [BigInt(value)],
  });

  try {
    const txResult = await sendAndConfirmTransaction({
      transaction,
      account,
    });
    console.log("Transaction successful:", txResult.transactionHash);
    alert(`Stored ${value} successfully!`);
    return txResult.transactionHash;
  } catch (error) {
    console.error("Transaction failed:", error);
    alert("Transaction failed. Check console for details.");
  }
}

function App() {
  const account = useActiveAccount();

  // Read the stored value (free RPC call — no transaction needed)
  const { data: storedValue, refetch: refetchStoredValue } = useReadContract({
    contract: storageContract,
    method: "function retrieve() view returns (uint256)",
  });

  return (
    <div className="min-h-screen bg-gray-100 py-8">
      <div className="max-w-4xl mx-auto px-4">
        <h1 className="text-3xl font-bold text-center mb-8">
          Sei x thirdweb Account Abstraction
        </h1>

        <div className="bg-white  shadow-md p-6 mb-6">
          <h2 className="text-xl font-semibold mb-4">Connect Wallet</h2>
          <ConnectButton
            client={client}
            wallets={wallets}
            accountAbstraction={{
              chain: seiChain,
              sponsorGas: true,
            }}
            connectButton={{
              label: "Connect to Sei Network",
            }}
          />
        </div>

        {account && (
          <div className="bg-white  shadow-md p-6">
            <h3 className="text-xl font-semibold mb-4">
              Storage Contract Interactions
            </h3>
            <p className="text-gray-600 mb-6">
              Connected: {account.address}
            </p>

            <div className="space-y-4">
              <div>
                <h4 className="font-medium mb-2">Store Number 37</h4>
                <TransactionButton
                  transaction={() =>
                    prepareContractCall({
                      contract: storageContract,
                      method: "function store(uint256 num)",
                      params: [BigInt(37)],
                    })
                  }
                  onTransactionConfirmed={(result) => {
                    console.log("Confirmed:", result);
                    alert("Number 37 stored!");
                  }}
                  onError={(error) => {
                    console.error("Error:", error);
                    alert("Transaction failed.");
                  }}
                >
                  Store Number 37
                </TransactionButton>
              </div>

              <div>
                <h4 className="font-medium mb-2">Store Custom Number</h4>
                <button
                  onClick={() => {
                    const value = prompt("Enter a number:");
                    if (value && !isNaN(Number(value))) {
                      handleStore(account, value);
                    } else if (value) {
                      alert("Please enter a valid number");
                    }
                  }}
                  className="bg-green-500 text-white px-4 py-2 rounded hover:bg-green-600"
                >
                  Store Custom Number
                </button>
              </div>

              <div>
                <h4 className="font-medium mb-2">Retrieve Stored Number</h4>
                <p className="text-gray-600 mb-2">
                  Stored value:{" "}
                  {storedValue !== undefined ? storedValue.toString() : "—"}
                </p>
                <button
                  onClick={() => refetchStoredValue()}
                  className="bg-purple-500 text-white px-4 py-2 rounded hover:bg-purple-600"
                >
                  Refresh Number
                </button>
              </div>
            </div>
          </div>
        )}
      </div>
    </div>
  );
}

export default App;
```

#### Understanding Key Components

| Component             | Description                                          |
| --------------------- | ---------------------------------------------------- |
| `ConnectButton`       | Pre-built UI component for wallet connection         |
| `TransactionButton`   | Simplified transaction execution with loading states |
| `useActiveAccount`    | Hook to get currently connected account              |
| `prepareContractCall` | Prepares transaction for contract interaction        |
| `inAppWallet`         | Smart wallet with social login capabilities          |

### Step 5: Package Configuration

Ensure your `package.json` includes:

```json title="package.json" theme={"dark"}
{
  "name": "sei-thirdweb-app",
  "private": true,
  "version": "0.0.0",
  "scripts": {
    "dev": "vite",
    "build": "tsc && vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "react": "^18.3",
    "react-dom": "^18.3",
    "thirdweb": "^5"
  },
  "devDependencies": {
    "@types/react": "^18.2.56",
    "@types/react-dom": "^18.2.19",
    "@vitejs/plugin-react": "^4.2.1",
    "typescript": "^5.2.2",
    "vite": "^4"
  }
}
```

### Step 6: Run the Application

#### Start Development Server

```bash theme={"dark"}
npm run dev
```

#### Test the Application

1. Open your browser and navigate to `http://localhost:5173`
2. Click "Connect to Sei Network"
3. Choose your preferred login method (Google, email, etc.)
4. A smart wallet is automatically created for you (no gas!)
5. After connecting, you'll see three interaction buttons
6. Try storing number 37 or a custom number
7. Retrieve the stored value - all transactions are gasless!
8. Monitor the browser console for: - Transaction hashes - Error messages - Connection status - Smart contract interactions

<Info>Gas fees are automatically sponsored when using Account Abstraction, so users don't need SEI tokens to interact with the contract.</Info>

### Step 7: Done!

You've successfully integrated thirdweb's Account Abstraction SDK with Sei! Users can now connect with social logins and interact with your contracts without needing to hold SEI tokens for gas.

## What You've Accomplished

* Created a React application with thirdweb SDK v5
* Configured Account Abstraction for SEI network
* Implemented social login authentication
* Deployed gasless transaction capabilities
* Built contract interaction interfaces
* Learned error handling for web3 applications

## Troubleshooting

### Common Issues and Solutions

| Error                            | Problem                          | Solution                                                                           |
| -------------------------------- | -------------------------------- | ---------------------------------------------------------------------------------- |
| `Client ID not found`            | Environment variable not loading | Check `.env` file and restart dev server                                           |
| `Sponsored transactions failing` | No active subscription           | Subscribe to [Pay As You Go plan](https://thirdweb.com/dashboard/settings/billing) |
| `Transaction reverted`           | Invalid contract address         | Verify contract on [Sei Explorer](https://seiscan.io/)                             |
| `Cannot connect wallet`          | Network configuration issue      | Check Client ID and RPC URL format                                                 |
| `Gas estimation failed`          | Contract method issue            | Verify contract ABI and function signature                                         |

### Network Connection Issues

<Danger>
  If the RPC endpoint is not responding:

  1. Verify your Client ID is active
  2. Check internet connectivity
  3. Try using the public RPC: `https://evm-rpc.sei-apis.com`
</Danger>

## Resources

* **thirdweb Documentation**: [https://portal.thirdweb.com/](https://portal.thirdweb.com/)
* **thirdweb Dashboard**: [https://thirdweb.com/dashboard](https://thirdweb.com/dashboard)
* **SEI Explorer**: [https://seiscan.io/](https://seiscan.io/)
* **Remix IDE**: [https://remix.ethereum.org/](https://remix.ethereum.org/)

---

URL: https://docs.sei.io/evm/wallet-integrations/thirdweb-7702

# Thirdweb EIP-7702 Integration Guide

> Learn how to integrate thirdweb's Account Abstraction SDK with Sei network to build decentralized applications with seamless wallet connectivity.

## Overview

This comprehensive guide demonstrates how to integrate thirdweb's EIP-7702 Account Abstraction SDK into your application. EIP-7702 represents the next generation of account abstraction, allowing Externally Owned Accounts (EOAs) to temporarily function as smart contracts, enabling gasless transactions and advanced wallet features without requiring users to migrate to new wallet addresses.

## What This Guide Covers

* Understanding EIP-7702
* Setting up a React application with thirdweb's EIP-7702 implementation
* Implementing social logins with smart account features
* Creating gasless transaction experiences on Sei Network

## Prerequisites

Before starting, ensure you have:

* Node.js v18+ installed
* Basic knowledge of React and TypeScript
* A thirdweb account with API key from [thirdweb Dashboard](https://thirdweb.com/dashboard)
* **For Mainnet**: An active thirdweb Pay As You Go subscription (\$5/month minimum) for gas sponsorship

## What is EIP-7702?

EIP-7702 is an Ethereum Improvement Proposal that introduces native account abstraction by allowing EOAs to temporarily delegate execution to smart contracts. This approach offers several advantages over traditional ERC-4337 implementations:

* **Same Address**: Users keep their existing EOA address—no migration to a new smart contract wallet required
* **Native Protocol Support**: Built into the protocol layer, not requiring external bundler infrastructure
* **Lower Gas Costs**: More efficient than ERC-4337 since it doesn't need separate UserOperation bundling
* **Temporary Delegation**: EOAs can temporarily act as smart contracts for a single transaction, then revert to normal behavior
* **Backward Compatible**: Works with existing wallets and infrastructure without breaking changes

## Sei Network Configuration

**Testnet:**

* **RPC URL**: `https://evm-rpc-testnet.sei-apis.com`
* **Chain ID**: 1328
* **Block Explorer**: [Seiscan Testnet](https://testnet.seiscan.io)

**Mainnet:**

* **RPC URL**: `https://evm-rpc.sei-apis.com`
* **Chain ID**: 1329
* **Block Explorer**: [Seiscan](https://seiscan.io)

## Step 1: Deploy a Storage Contract

For this example, we'll deploy a simple Storage contract that stores and retrieves numbers. This will demonstrate gasless transactions and smart account features with EIP-7702.

### Storage Contract (Solidity)

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Storage {
    uint256 private value;

    function store(uint256 num) public {
        value = num;
    }

    function retrieve() public view returns (uint256) {
        return value;
    }
}
```

Deploy this contract using [Remix](https://remix.ethereum.org/) or your preferred deployment tool. Note the contract address for later use.

## Step 2: Project Setup

### Create a New Project

```bash theme={"dark"}
npm create vite@latest eip7702-demo -- --template react-ts
cd eip7702-demo
npm install
```

### Install Dependencies

```bash theme={"dark"}
npm install thirdweb@^5
```

### Install and Configure Tailwind CSS

Install Tailwind CSS and its dependencies:

```bash theme={"dark"}
npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p
```

Update `tailwind.config.js`:

```javascript theme={"dark"}
/** @type {import('tailwindcss').Config} */
export default {
  content: ['./index.html', './src/**/*.{js,ts,jsx,tsx}'],
  theme: {
    extend: {}
  },
  plugins: []
};
```

Replace the contents of `src/index.css` with:

```css theme={"dark"}
@tailwind base;
@tailwind components;
@tailwind utilities;
```

### Configure Environment Variables

Create a `.env` file in your project root:

```env theme={"dark"}
VITE_TEMPLATE_CLIENT_ID=your_thirdweb_client_id_here
VITE_STORAGE_CONTRACT_ADDRESS=your_deployed_contract_address_here
```

Get your Client ID from [thirdweb Dashboard](https://thirdweb.com/dashboard) → Project → Overview

### Enable Gas Sponsorship (Production)

For mainnet gas sponsorship:

1. Visit [thirdweb Dashboard Billing](https://thirdweb.com/dashboard/settings/billing)
2. Subscribe to the **Pay As You Go** plan (\$5/month minimum)
3. Enable gas sponsorship in your project settings

## Step 3: Configure Vite

Create or update `vite.config.ts`:

```typescript theme={"dark"}
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';

export default defineConfig({
  plugins: [react()]
});
```

## Step 4: Configure thirdweb Client

Create `src/client.ts`:

```typescript theme={"dark"}
import { createThirdwebClient } from 'thirdweb';

export const client = createThirdwebClient({
  clientId: import.meta.env.VITE_TEMPLATE_CLIENT_ID
});
```

## Step 5: Setup ThirdwebProvider

First, update `src/main.tsx` to include the ThirdwebProvider:

```typescript theme={"dark"}
import React from 'react'
import ReactDOM from 'react-dom/client'
import { ThirdwebProvider } from "thirdweb/react"
import App from './App.tsx'
import './index.css'

ReactDOM.createRoot(document.getElementById('root')!).render(
  <React.StrictMode>
    <ThirdwebProvider>
      <App />
    </ThirdwebProvider>
  </React.StrictMode>,
)
```

## Step 6: EIP-7702 Smart Account Implementation

Now replace `src/App.tsx` with the complete EIP-7702 implementation.

**Key Configuration:**
The `executionMode` configuration enables EIP-7702 features:

* `mode: "EIP7702"` - Enables EIP-7702 account abstraction (EOA acts as smart contract temporarily)
* `sponsorGas: true` - Enables gasless transactions (thirdweb pays gas on behalf of users)

```typescript theme={"dark"}
import React, { useState } from "react";
import {
  ConnectButton,
  TransactionButton,
  useActiveAccount,
  useWalletBalance,
  useReadContract,
} from "thirdweb/react";
import { inAppWallet } from "thirdweb/wallets";
import { client } from "./client";
import {
  getContract,
  prepareContractCall,
  sendAndConfirmTransaction,
} from "thirdweb";
import { defineChain } from "thirdweb/chains";

const { VITE_TEMPLATE_CLIENT_ID: THIRDWEB_API_KEY } = import.meta.env;
// Configure Sei network
const rpc = `https://1329.rpc.thirdweb.com/${THIRDWEB_API_KEY}`;
const seiChain = defineChain({
  id: 1329,
  rpc,
});

// Choose your target chain - EIP-7702 enabled chains
const targetChain = seiChain;

// Get contract address from environment
const CONTRACT_ADDRESS = import.meta.env.VITE_STORAGE_CONTRACT_ADDRESS;

// Configure the Storage contract
const storageContract = getContract({
  client,
  chain: targetChain,
  address: CONTRACT_ADDRESS,
});

// Configure EIP-7702 enabled wallet
const wallets = [
  inAppWallet({
    auth: {
      options: [
        "google",
        "email",
        "passkey",
        "apple",
        "facebook",
        "discord",
        "x",
        "telegram",
        "phone",
        "guest",
      ],
    },
    // Enable EIP-7702 smart account features
    executionMode: {
      mode: "EIP7702",
      sponsorGas: true, // Enable gasless transactions
    },
  }),
];

function App() {
  const account = useActiveAccount();
  const [transactionStatus, setTransactionStatus] = useState<string>("");

  // Get wallet balance
  const { data: balance } = useWalletBalance({
    client,
    chain: targetChain,
    address: account?.address,
  });

  const { data: storeValue } = useReadContract({
    contract: storageContract,
    method: "function retrieve() view returns (uint256)",
  });

  // Custom store function with status updates
  const handleCustomStore = async (storeNumber: number) => {
    if (!account) return;

    setTransactionStatus("Preparing transaction...");

    try {
      const transaction = prepareContractCall({
        contract: storageContract,
        method: "function store(uint256 num)",
        params: [BigInt(storeNumber)],
      });

      setTransactionStatus("Sending transaction...");

      const result = await sendAndConfirmTransaction({
        transaction,
        account,
      });

      setTransactionStatus(`Success! Transaction: ${result.transactionHash}`);

      // Reset status after 5 seconds
      setTimeout(() => setTransactionStatus(""), 5000);
    } catch (error) {
      console.error("Store failed:", error);
      setTransactionStatus(
        `Error: ${
          error instanceof Error ? error.message : "Transaction failed"
        }`
      );

      // Reset status after 5 seconds
      setTimeout(() => setTransactionStatus(""), 5000);
    }
  };

  return (
    <div className="min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100 py-8">
      <div className="max-w-4xl mx-auto px-4">
        <div className="text-center mb-8">
          <h1 className="text-4xl font-bold text-gray-900 mb-2">
            EIP-7702 Account Abstraction Demo
          </h1>
        </div>

        {/* Connection Section */}
        <div className="bg-white  shadow-lg p-6 mb-6">
          <h2 className="text-2xl font-semibold mb-4 text-gray-800">
            Connect Your Smart Account
          </h2>
          <p className="text-gray-600 mb-4">
            Connect with social login and get instant smart account features -
            no wallet setup required!
          </p>
          <ConnectButton
            client={client}
            wallets={wallets}
            chain={targetChain}
            connectButton={{
              label: "Connect with EIP-7702 Smart Account",
              className:
                "!bg-indigo-600 !hover:bg-indigo-700 !text-white !py-3 !px-6 ! !font-medium",
            }}
          />

          {/* Display account info */}
          {account && (
            <div className="mt-4 p-4 bg-green-50 ">
              <h3 className="font-semibold text-green-800 mb-2">
                ✅ Smart Account Connected
              </h3>
              <p className="text-sm text-gray-700">
                <strong>Address:</strong> {account.address}
              </p>
              <p className="text-sm text-gray-700">
                <strong>Balance:</strong> {balance?.displayValue}{" "}
                {balance?.symbol}
              </p>
            </div>
          )}
        </div>

        {account && (
          <>
            {/* Contract Information */}
            <div className="bg-white  shadow-lg p-6 mb-6">
              <div className="flex items-center justify-center gap-4">
                <div className="text-center p-4 bg-blue-50 ">
                  <p className="text-sm text-gray-600 mb-1">Current Stored Value</p>
                  <p className="text-2xl font-bold text-purple-600">
                    {storeValue?.toString() || "0"}
                  </p>
                </div>
              </div>
            </div>

            {/* Transaction Section */}
            <div className="bg-white  shadow-lg p-6 mb-6">
              <div className="space-y-6">
                <div className="border-l-4 border-blue-500 pl-4">
                  <h4 className="font-semibold text-gray-800 mb-2">Store</h4>
                  <TransactionButton
                    transaction={() =>
                      prepareContractCall({
                        contract: storageContract,
                        method: "function store(uint256 num)",
                        params: [BigInt(37)],
                      })
                    }
                    onTransactionSent={(result) => {
                      console.log("Transaction sent:", result.transactionHash);
                      setTransactionStatus(
                        "Transaction sent, waiting for confirmation..."
                      );
                    }}
                    onTransactionConfirmed={(result) => {
                      console.log(
                        "Transaction confirmed:",
                        result.transactionHash
                      );
                      setTransactionStatus(
                        `Stored successfully! TX: ${result.transactionHash}`
                      );
                      setTimeout(() => setTransactionStatus(""), 5000);
                    }}
                    onError={(error) => {
                      console.error("Transaction error:", error);
                      setTransactionStatus(`❌ Error: ${error.message}`);
                      setTimeout(() => setTransactionStatus(""), 5000);
                    }}
                  >
                    Store 37
                  </TransactionButton>
                </div>
              </div>
            </div>

            {/* Custom Store Button */}
            <div className="bg-white  shadow-lg p-6 mb-6">
              <div className="border-l-4 border-green-500 pl-4">
                <h4 className="font-semibold text-gray-800 mb-2">
                  Custom Implementation
                </h4>
                <button
                  onClick={() => {
                    const amount = prompt("Enter number to store");
                    const num = Number(amount);
                    if (!isNaN(num)) {
                      handleCustomStore(num);
                    }
                  }}
                  className="bg-green-600 hover:bg-green-700 text-white px-4 py-2  font-medium transition-colors"
                >
                  Store Custom Number
                </button>
              </div>
            </div>

            {/* Status Display */}
            {transactionStatus && (
              <div className="bg-white  shadow-lg p-6 mb-6">
                <h4 className="font-semibold mb-2">Transaction Status</h4>
                <p className="text-sm text-gray-700 font-mono bg-gray-100 p-3 rounded">
                  {transactionStatus}
                </p>
              </div>
            )}
          </>
        )}
      </div>
    </div>
  );
}

export default App;

```

## Step 7: Package Configuration

Update your `package.json`:

```json theme={"dark"}
{
  "name": "eip7702-storage-abstraction-demo",
  "private": true,
  "version": "0.0.0",
  "scripts": {
    "dev": "vite",
    "build": "tsc && vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "react": "^18.3.1",
    "react-dom": "^18.3.1",
    "thirdweb": "^5"
  },
  "devDependencies": {
    "@types/react": "^18.2.56",
    "@types/react-dom": "^18.2.19",
    "@vitejs/plugin-react": "^4.2.1",
    "autoprefixer": "^10.4.18",
    "postcss": "^8.4.35",
    "tailwindcss": "^3.4.1",
    "typescript": "^5.2.2",
    "vite": "^5.0.8"
  }
}
```

## Step 8: Run the Application

### Start Development Server

```bash theme={"dark"}
npm run dev
```

### Test EIP-7702 Features

1. **Open** `http://localhost:5173` in your browser
2. **Connect** using any social login (Google, email, etc.)
3. **Observe** the automatic smart account creation (no gas required!)
4. **Test** gasless storage operations:
   * Store the predefined value (37) using the "Store 37" button
   * Store custom numbers using the "Store Custom Number" button
   * Read stored values displayed in the interface
5. **Monitor** console for transaction hashes and status updates
6. **Thirdweb Dashboard**: View more details in your thirdweb dashboard

## Troubleshooting

### Network Issues

If experiencing connectivity problems:

1. Check the [thirdweb status page](https://status.thirdweb.com)
2. Verify your API key is active and has sufficient credits
3. Ensure you're connected to the correct network (Chain ID 1329 for mainnet, 1328 for testnet)

### Transaction Verification

After a successful transaction, you can verify it on the block explorer:

* **Mainnet**: [Seiscan](https://seiscan.io)
* **Testnet**: [Seiscan Testnet](https://testnet.seiscan.io)

Search for your transaction hash to see full details including gas used, status, and event logs.

## Resources

### thirdweb Documentation & Tools

* **[thirdweb Portal](https://portal.thirdweb.com/)**: Comprehensive SDK documentation
* **[EIP-7702 Documentation](https://portal.thirdweb.com/connect/account-abstraction/eip-7702)**: Official thirdweb EIP-7702 guide
* **[thirdweb Dashboard](https://thirdweb.com/dashboard)**: Manage projects and API keys
* **[GitHub Repository](https://github.com/thirdweb-dev)**: Source code and examples
* **[Developer Blog](https://blog.thirdweb.com/)**: Latest updates and tutorials
* **[EIP-7702 Specification](https://eips.ethereum.org/EIPS/eip-7702)**: Official Ethereum Improvement Proposal

---

URL: https://docs.sei.io/evm/bridging/thirdweb

# Enable Onramps, Swapping & Bridging on Any EVM Chain

> Comprehensive guide on enabling onramps, swapping & bridging on Any EVM Chain on Sei. Learn key concepts, commands, and best practices.

[**Payments**](https://thirdweb.com/payments?utm_source=sei\&utm_medium=documentation\&utm_campaign=chain_docs) is a comprehensive Web3 payment solution to help you monetize any app or game.

With Payments, your users can **onramp, bridge, and swap** on any EVM chain — with any EVM token or fiat — thanks to its **automatic cross-chain routing**.

Plus, developers can **earn from day one** using the **fee-sharing mechanism** and **easy implementation**.

## Payments Features

* Let users pay for assets in any EVM token on any EVM chain
* Automatic cross-chain routing for seamless transactions
* Earn from day one with fee-sharing mechanism
* Access ready-made UI component for easy implementation

[Learn more in the full documentation on thirdweb’s Payments](https://portal.thirdweb.com/payments?utm_source=sei\&utm_medium=documentation\&utm_campaign=chain_docs)

## Get Started

[How to get started with Payments](https://portal.thirdweb.com/payments?utm_source=sei\&utm_medium=documentation\&utm_campaign=chain_docs)

## See Payments in Action

Want to see how Payments works? Check it out under the hood

```jsx theme={"dark"}
import { createThirdwebClient } from 'thirdweb';
import { PayEmbed } from 'thirdweb/react';

import { createWallet } from 'thirdweb/wallets';
import { sei } from 'thirdweb/chains';

const client = createThirdwebClient({
  clientId: '....'
});

function Example() {
  return (
    <PayEmbed
      client={client}
      payOptions={{
        mode: 'fund_wallet',
        prefillBuy: {
          chain: sei,
          amount: '0.01'
        }
      }}
    />
  );
}
```

[**See how Payments works in the playground**](https://playground.thirdweb.com/payments?utm_source=sei\&utm_medium=documentation\&utm_campaign=chain_docs)

---

URL: https://docs.sei.io/evm/bridging/layerzero

# LayerZero V2 on SEI - Complete Integration Guide

> Step-by-step guide to building cross-chain applications on SEI using LayerZero V2

## Overview

This guide provides a comprehensive, step-by-step tutorial for integrating LayerZero V2 with the SEI blockchain. By the end of this guide, you will understand how to create, deploy, and manage omnichain tokens that can seamlessly move between SEI and any other LayerZero-supported blockchain.

### What This Guide Covers

* **Understanding LayerZero**: Core concepts and architecture
* **Project Setup**: Creating a LayerZero-enabled project from scratch
* **Smart Contracts**: Building an Omnichain Fungible Token (OFT) with detailed explanations
* **Deployment & Configuration**: Step-by-step deployment to SEI and other chains
* **Cross-Chain Transfers**: Creating tasks and scripts for token transfers

### Prerequisites

* Basic knowledge of Solidity and smart contracts
* Node.js and npm installed
* A wallet with SEI and other chain tokens for gas
* Familiarity with Hardhat or Foundry

## What is LayerZero?

LayerZero is an **omnichain interoperability protocol** that enables secure, permissionless communication between different blockchains. Think of it as a universal translator that allows blockchains to talk to each other.

### Core Concepts

* **Endpoints**: Immutable smart contracts deployed on each blockchain that serve as entry/exit points for messages
* **Messages**: Data packets sent between blockchains containing instructions or information
* **Security Stack**: Customizable verification system ensuring message authenticity
* **Omnichain Applications**: Smart contracts that can operate across multiple blockchains

### Key Applications

* **Omnichain Fungible Tokens (OFT)**: Tokens that exist across multiple chains with unified supply
* **Omnichain NFTs (ONFT)**: NFTs that can move between blockchains
* **Cross-chain DeFi**: Protocols that operate across multiple networks
* **Unified Governance**: DAOs that function across chains
* **Message Passing**: Send arbitrary data between blockchains

## SEI Network Information

<Info>
  **SEI Mainnet Configuration**

  * Network Name: SEI EVM
  * Chain ID: 1329
  * RPC URL: [https://evm-rpc.sei-apis.com](https://evm-rpc.sei-apis.com)
  * Explorer: [https://seiscan.io](https://seiscan.io)
  * Currency: SEI
  * LayerZero Endpoint ID: 30280
</Info>

### Contract Deployments

The following are the official LayerZero V2 protocol contract addresses deployed on Sei networks.

<Accordion title="Sei Mainnet (EID: 30280) — Protocol Contracts">
  | Contract          | Address                                                                                                               |
  | ----------------- | --------------------------------------------------------------------------------------------------------------------- |
  | EndpointV2        | [`0x1a44076050125825900e736c501f859c50fE728c`](https://seiscan.io/address/0x1a44076050125825900e736c501f859c50fE728c) |
  | SendUln302        | [`0xC39161c743D0307EB9BCc9FEF03eeb9Dc4802de7`](https://seiscan.io/address/0xC39161c743D0307EB9BCc9FEF03eeb9Dc4802de7) |
  | ReceiveUln302     | [`0xe1844c5D63a9543023008D332Bd3d2e6f1FE1043`](https://seiscan.io/address/0xe1844c5D63a9543023008D332Bd3d2e6f1FE1043) |
  | SendUln301        | [`0x37aaaf95887624a363effB7762D489E3C05c2a02`](https://seiscan.io/address/0x37aaaf95887624a363effB7762D489E3C05c2a02) |
  | ReceiveUln301     | [`0x15e51701F245F6D5bd0FEE87bCAf55B0841451B3`](https://seiscan.io/address/0x15e51701F245F6D5bd0FEE87bCAf55B0841451B3) |
  | Executor          | [`0xc097ab8CD7b053326DFe9fB3E3a31a0CCe3B526f`](https://seiscan.io/address/0xc097ab8CD7b053326DFe9fB3E3a31a0CCe3B526f) |
  | LZ Executor       | [`0x4208D6E27538189bB48E603D6123A94b8Abe0A0b`](https://seiscan.io/address/0x4208D6E27538189bB48E603D6123A94b8Abe0A0b) |
  | EndpointV2View    | [`0xAaB5A48CFC03Efa9cC34A2C1aAcCCB84b4b770e4`](https://seiscan.io/address/0xAaB5A48CFC03Efa9cC34A2C1aAcCCB84b4b770e4) |
  | ReadLib1002       | [`0x6A6C548058094e6dFaF95Bb0b5d04e1dd8ec0870`](https://seiscan.io/address/0x6A6C548058094e6dFaF95Bb0b5d04e1dd8ec0870) |
  | BlockedMessageLib | [`0x1ccbf0db9c192d969de57e25b3ff09a25bb1d862`](https://seiscan.io/address/0x1ccbf0db9c192d969de57e25b3ff09a25bb1d862) |
</Accordion>

<Accordion title="Sei Mainnet — DVNs (Decentralized Verifier Networks)">
  | DVN            | Address                                                                                                               |
  | -------------- | --------------------------------------------------------------------------------------------------------------------- |
  | LayerZero Labs | [`0x6788f52439aca6bff597d3eec2dc9a44b8fee842`](https://seiscan.io/address/0x6788f52439aca6bff597d3eec2dc9a44b8fee842) |
  | Nethermind     | [`0xa93d4490444eba60839742859cfde53bf0967dc9`](https://seiscan.io/address/0xa93d4490444eba60839742859cfde53bf0967dc9) |
  | Horizen        | [`0x96ca3420bedd887cabdaba29c7dce6bad57af98b`](https://seiscan.io/address/0x96ca3420bedd887cabdaba29c7dce6bad57af98b) |
  | BitGo          | [`0x26cd5abadf7ec3f0f02b48314bfca6b2342cddd4`](https://seiscan.io/address/0x26cd5abadf7ec3f0f02b48314bfca6b2342cddd4) |
  | StakingCabin   | [`0x93d2d7aadc9f2cf5ebc88e9703e06db09b8fd85b`](https://seiscan.io/address/0x93d2d7aadc9f2cf5ebc88e9703e06db09b8fd85b) |
  | Luganodes      | [`0x6e01aa282f058873d28055e07d85f4197e8db261`](https://seiscan.io/address/0x6e01aa282f058873d28055e07d85f4197e8db261) |
  | P2P            | [`0xa83a87a0bdce466edfbb6794404e1d7f556b8f20`](https://seiscan.io/address/0xa83a87a0bdce466edfbb6794404e1d7f556b8f20) |
  | BCW Group      | [`0x1feb08b1a53a9710afce82d380b8c2833c69a37e`](https://seiscan.io/address/0x1feb08b1a53a9710afce82d380b8c2833c69a37e) |
  | Nansen         | [`0xf85f51c1d5b4de2446d99b104acfca7ff63bd3ad`](https://seiscan.io/address/0xf85f51c1d5b4de2446d99b104acfca7ff63bd3ad) |
  | Stargate       | [`0xbd00c87850416db0995ef8030b104f875e1bdd15`](https://seiscan.io/address/0xbd00c87850416db0995ef8030b104f875e1bdd15) |
  | Frax           | [`0xe016f0f39fb7dcf14e9412d92f2049668d4d2612`](https://seiscan.io/address/0xe016f0f39fb7dcf14e9412d92f2049668d4d2612) |
</Accordion>

<Accordion title="Sei Testnet (EID: 40455) — Protocol Contracts">
  | Contract          | Address                                                                                                                       |
  | ----------------- | ----------------------------------------------------------------------------------------------------------------------------- |
  | EndpointV2        | [`0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff`](https://testnet.seiscan.io/address/0x6C7Ab2202C98C4227C5c46f1417D81144DA716Ff) |
  | SendUln302        | [`0xd682ECF100f6F4284138AA925348633B0611Ae21`](https://testnet.seiscan.io/address/0xd682ECF100f6F4284138AA925348633B0611Ae21) |
  | ReceiveUln302     | [`0xcF1B0F4106B0324F96fEfcC31bA9498caa80701C`](https://testnet.seiscan.io/address/0xcF1B0F4106B0324F96fEfcC31bA9498caa80701C) |
  | BlockedMessageLib | [`0x926984a57b10a3a5c4cfdbac04daaa0309e78932`](https://testnet.seiscan.io/address/0x926984a57b10a3a5c4cfdbac04daaa0309e78932) |
  | Executor          | [`0x9dB9Ca3305B48F196D18082e91cB64663b13d014`](https://testnet.seiscan.io/address/0x9dB9Ca3305B48F196D18082e91cB64663b13d014) |
  | DeadDVN           | [`0xF49d162484290EAeAd7bb8C2c7E3a6f8f52e32d6`](https://testnet.seiscan.io/address/0xF49d162484290EAeAd7bb8C2c7E3a6f8f52e32d6) |
</Accordion>

## Step 1: Project Setup

### Project scaffold

LayerZero's CLI lets you spin up an OFT workspace in seconds:

```bash theme={"dark"}
npx create-lz-oapp@latest # choose → "OFT example"
```

The wizard creates a repo with Hardhat + Foundry, sample contracts, tests and LayerZero helper scripts.

### Add private keys

Rename `.env.example` file to `.env` and update it with needed configurations:

```bash title=".env" theme={"dark"}
PRIVATE_KEY=your_private_key
```

At a minimum, you need to have the `PRIVATE_KEY`. RPC URLs are optional, but strongly recommended. If you don't provide them, public RPCs will be used, but public RPCs can be unreliable or slow, leading to long waiting times for transactions to be confirmed or, at worst, cause your transactions to fail.

## Step 2: Configure Networks

### Hardhat network config

Update your `hardhat.config.ts` file to include the networks you want to deploy your contracts to:

```typescript title="hardhat.config.ts" theme={"dark"}
networks: {
  // the network you are deploying to or are already on
  // Sei Mainnet (EID=30280)
  'sei-mainnet': {
    eid: EndpointId.SEI_V2_MAINNET,
    url: process.env.RPC_URL_SEI || 'https://evm-rpc.sei-apis.com',
    accounts,
  },
  // another network you want to connect to
  'optimism-mainnet': {
    eid: EndpointId.OPTIMISM_V2_MAINNET,
    url: process.env.RPC_URL_OPTIMISM || 'https://mainnet.optimism.io',
    accounts,
  },
}
```

### LayerZero wiring config

Modify your `layerzero.config.ts` file to include the chains and channel security settings you want for each connection:

```typescript title="layerzero.config.ts" theme={"dark"}
import { EndpointId } from '@layerzerolabs/lz-definitions';
import type { OmniPointHardhat } from '@layerzerolabs/toolbox-hardhat';
import { OAppEnforcedOption } from '@layerzerolabs/toolbox-hardhat';
import { ExecutorOptionType } from '@layerzerolabs/lz-v2-utilities';
import { TwoWayConfig, generateConnectionsConfig } from '@layerzerolabs/metadata-tools';

const seiContract: OmniPointHardhat = {
  eid: EndpointId.SEI_V2_MAINNET,
  contractName: 'MyOFT'
};

const optimismContract: OmniPointHardhat = {
  eid: EndpointId.OPTIMISM_V2_MAINNET,
  contractName: 'MyOFT'
};

// To connect all the above chains to each other, we need the following pathways:
// Optimism <-> sei
// sei <-> Optimism

// For this example's simplicity, we will use the same enforced options values for sending to all chains
// To learn more, read https://docs.layerzero.network/v2/concepts/applications/oapp-standard#execution-options-and-enforced-settings
const EVM_ENFORCED_OPTIONS: OAppEnforcedOption[] = [
  {
    msgType: 1,
    optionType: ExecutorOptionType.LZ_RECEIVE,
    gas: 80000,
    value: 0
  }
];

const pathways: TwoWayConfig[] = [
  [
    // 1) Chain B's contract (e.g. Optimism)
    optimismContract,
    // 2) Chain A's contract (e.g. sei)
    seiContract,
    // 3) Channel security settings:
    // • first array = "required" DVN names
    // • second array = "optional" DVN names array + threshold
    // • third value = threshold (i.e., number of optionalDVNs that must sign)
    // [ requiredDVN[], [ optionalDVN[], threshold ] ]
    [['LayerZero Labs' /* ← add more DVN names here */], []],
    // 4) Block confirmations:
    // [confirmations for Optimism → sei, confirmations for sei → Optimism]
    [1, 1],
    // 5) Enforced execution options:
    // [options for Optimism → sei, options for sei → Optimism]
    [EVM_ENFORCED_OPTIONS, EVM_ENFORCED_OPTIONS]
  ]
];

export default async function () {
  // Generate the connections config based on the pathways
  const connections = await generateConnectionsConfig(pathways);
  return {
    contracts: [{ contract: optimismContract }, { contract: seiContract }],
    connections
  };
}
```

<Info>
  It is strongly recommended to review [LayerZero's Channel Security Model](https://docs.layerzero.network/v2/concepts/protocol/message-security#layerzero's-channel-security-model) and understand the impact of each of these configuration settings.

  See [Next Steps](#next-steps) to review the available providers and security settings.
</Info>

## Step 3: Create Utility Tasks

Before deployment, let's create a utility task for minting tokens that we'll need later.

### Create Minting Task

Create `tasks/mint.ts`:

```typescript title="tasks/mint.ts" theme={"dark"}
import { task } from 'hardhat/config';
import { types } from '@layerzerolabs/devtools-evm-hardhat';

task('mint', 'Mint tokens to an address')
  .addParam('to', 'Address to mint tokens to', undefined, types.string)
  .addParam('amount', 'Amount to mint (without decimals)', undefined, types.string)
  .setAction(async ({ to, amount }, { ethers, deployments }) => {
    // Get the deployed contract
    const deployment = await deployments.get('MyOFT');
    const [signer] = await ethers.getSigners();

    // Create contract instance
    const oft = new ethers.Contract(deployment.address, deployment.abi, signer);

    // Get decimals
    const decimals = await oft.decimals();

    // Convert amount to proper decimals
    const amountWithDecimals = ethers.utils.parseUnits(amount, decimals);

    // Mint tokens
    console.log(`Minting ${amount} tokens to ${to}...`);
    const tx = await oft.mint(to, amountWithDecimals);
    await tx.wait();

    console.log(`✅ Minted ${amount} tokens to ${to}`);
    console.log(`Transaction hash: ${tx.hash}`);
  });
```

### Update Hardhat Configuration

Now update your `hardhat.config.ts` to import the mint task:

```typescript title="hardhat.config.ts" theme={"dark"}
// Get the environment configuration from .env file
//
// To make use of automatic environment setup:
// - Duplicate .env.example file and name it .env
// - Fill in the environment variables
import 'dotenv/config';

import 'hardhat-deploy';
import 'hardhat-contract-sizer';
import '@nomiclabs/hardhat-ethers';
import '@layerzerolabs/toolbox-hardhat';
import { HardhatUserConfig, HttpNetworkAccountsUserConfig } from 'hardhat/types';

import { EndpointId } from '@layerzerolabs/lz-definitions';

import './tasks/sendOFT';
import './tasks/mint';

// Set your preferred authentication method
//
// If you prefer using a mnemonic, set a MNEMONIC environment variable
// to a valid mnemonic
const MNEMONIC = process.env.MNEMONIC;

// If you prefer to be authenticated using a private key, set a PRIVATE_KEY environment variable
const PRIVATE_KEY = process.env.PRIVATE_KEY;

const accounts: HttpNetworkAccountsUserConfig | undefined = MNEMONIC ? { mnemonic: MNEMONIC } : PRIVATE_KEY ? [PRIVATE_KEY] : undefined;

if (accounts == null) {
  console.warn('Could not find MNEMONIC or PRIVATE_KEY environment variables. It will not be possible to execute transactions in your example.');
}

const config: HardhatUserConfig = {
  paths: {
    cache: 'cache/hardhat'
  },
  solidity: {
    compilers: [
      {
        version: '0.8.22',
        settings: {
          optimizer: {
            enabled: true,
            runs: 200
          }
        }
      }
    ]
  },
  networks: {
    // the network you are deploying to or are already on
    // Sei Mainnet (EID=30280)
    'sei-mainnet': {
      eid: EndpointId.SEI_V2_MAINNET,
      url: process.env.RPC_URL_SEI || 'https://evm-rpc.sei-apis.com',
      accounts
    },
    // another network you want to connect to
    'optimism-mainnet': {
      eid: EndpointId.OPTIMISM_V2_MAINNET,
      url: process.env.RPC_URL_OPTIMISM || 'https://mainnet.optimism.io',
      accounts
    }
  },
  namedAccounts: {
    deployer: {
      default: 0 // wallet address of index[0], of the mnemonic in .env
    }
  }
};

export default config;
```

<Warning>**Important**: You must create and import the mint task before deployment, otherwise Hardhat will throw an error when trying to resolve the task dependencies during compilation.</Warning>

## Step 4: Smart Contract Development

### The token contract

<Info>
  The OFT contract handles all cross-chain logic automatically. When tokens are sent:

  1. **Source Chain**: Burns tokens from sender's balance
  2. **LayerZero Protocol**: Verifies and relays the message
  3. **Destination Chain**: Mints equivalent tokens to recipient
</Info>

```solidity title="contracts/MyOFT.sol" theme={"dark"}
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { OFT } from "@layerzerolabs/oft-evm/contracts/OFT.sol";

contract MyOFT is OFT {
    constructor(string memory name, string memory symbol, address endpoint, address owner)
        OFT(name, symbol, endpoint, owner) Ownable(owner) {}

    /**
     * @notice Mint new tokens (only owner)
     * @param to Address to receive the minted tokens
     * @param amount Amount of tokens to mint (with decimals)
     */
    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
}
```

<Warning>
  The OFT contract uses the ERC20 token standard. You may want to add a `mint(...)` function in the `constructor(...)` or contract body if this is your first time deploying an OFT. If you have an existing ERC20 token, you will want to use an OFT Adapter contract.

  You can read the general [OFT Quickstart](https://docs.layerzero.network/v2/developers/evm/oft/quickstart) for a better understanding of how OFTs work and what contracts to use.
</Warning>

### Understanding OFT Functions

Key inherited functions from the OFT contract:

| Function       | Description                              |
| -------------- | ---------------------------------------- |
| `send()`       | Initiates cross-chain token transfer     |
| `quoteSend()`  | Estimates fees for transfer              |
| `_lzSend()`    | Internal function that sends the message |
| `_lzReceive()` | Internal function that receives messages |

## Step 5: Deployment Process

### Deploy

```bash theme={"dark"}
npx hardhat lz:deploy # choose sei
```

You will be presented with a list of networks to deploy to.

<Warning>Fund your deployer with native gas tokens beforehand.</Warning>

## Step 6: Wire the Contracts

After deployment, contracts need to be connected:

### Connect the chains

```bash theme={"dark"}
npx hardhat lz:oapp:wire --oapp-config layerzero.config.ts
```

### Verify Configuration

Verify peers:

```bash theme={"dark"}
npx hardhat lz:oapp:peers:get --oapp-config layerzero.config.ts
```

This command will show you the current LayerZero wiring configuration, including the connected chains and their peer addresses.

## Step 7: Mint Initial Tokens

Before transferring, you need tokens to send. Let's mint some tokens on SEI:

```bash theme={"dark"}
# Mint 10,000 tokens to your address on SEI
npx hardhat mint --to 0xYourAddress --amount 10000 --network sei-mainnet
```

## Step 8: Transfer Tokens Cross-Chain

### Calling send

Since the `send` logic has already been defined, we'll instead view how the function should be called.

#### Option 1: Hardhat Task

Create `tasks/sendOFT.ts`:

```typescript title="tasks/sendOFT.ts" theme={"dark"}
import { task } from 'hardhat/config';
import { getNetworkNameForEid, types } from '@layerzerolabs/devtools-evm-hardhat';
import { EndpointId } from '@layerzerolabs/lz-definitions';
import { addressToBytes32 } from '@layerzerolabs/lz-v2-utilities';
import { Options } from '@layerzerolabs/lz-v2-utilities';
import { BigNumberish, BytesLike } from 'ethers';

interface Args {
  amount: string;
  to: string;
  toEid: EndpointId;
}

interface SendParam {
  dstEid: EndpointId; // Destination endpoint ID, represented as a number.
  to: BytesLike; // Recipient address, represented as bytes.
  amountLD: BigNumberish; // Amount to send in local decimals.
  minAmountLD: BigNumberish; // Minimum amount to send in local decimals.
  extraOptions: BytesLike; // Additional options supplied by the caller to be used in the LayerZero message.
  composeMsg: BytesLike; // The composed message for the send() operation.
  oftCmd: BytesLike; // The OFT command to be executed, unused in default OFT implementations.
}

// send tokens from a contract on one network to another
task('lz:oft:send', 'Sends tokens from either OFT or OFTAdapter')
  .addParam('to', 'contract address on network B', undefined, types.string)
  .addParam('toEid', 'destination endpoint ID', undefined, types.eid)
  .addParam('amount', 'amount to transfer in token decimals', undefined, types.string)
  .setAction(async (taskArgs: Args, { ethers, deployments }) => {
    const toAddress = taskArgs.to;
    const eidB = taskArgs.toEid;

    // Get the contract factories
    const oftDeployment = await deployments.get('MyOFT');

    const [signer] = await ethers.getSigners();

    // Create contract instances
    const oftContract = new ethers.Contract(oftDeployment.address, oftDeployment.abi, signer);

    const decimals = await oftContract.decimals();
    const amount = ethers.utils.parseUnits(taskArgs.amount, decimals);
    let options = Options.newOptions().addExecutorLzReceiveOption(65000, 0).toBytes();

    // Now you can interact with the correct contract
    const oft = oftContract;

    const sendParam: SendParam = {
      dstEid: eidB,
      to: addressToBytes32(toAddress),
      amountLD: amount,
      minAmountLD: amount,
      extraOptions: options,
      composeMsg: ethers.utils.arrayify('0x'), // Assuming no composed message
      oftCmd: ethers.utils.arrayify('0x') // Assuming no OFT command is needed
    };
    // Get the quote for the send operation
    const feeQuote = await oft.quoteSend(sendParam, false);
    const nativeFee = feeQuote.nativeFee;

    console.log(`sending ${taskArgs.amount} token(s) to network ${getNetworkNameForEid(eidB)} (${eidB})`);

    const ERC20Factory = await ethers.getContractFactory('ERC20');
    const innerTokenAddress = await oft.token();

    // // If the token address !== address(this), then this is an OFT Adapter
    // if (innerTokenAddress !== oft.address) {
    //     // If the contract is OFT Adapter, get decimals from the inner token
    //     const innerToken = ERC20Factory.attach(innerTokenAddress);

    //     // Approve the amount to be spent by the oft contract
    //     await innerToken.approve(oftDeployment.address, amount);
    // }

    const r = await oft.send(sendParam, { nativeFee: nativeFee, lzTokenFee: 0 }, signer.address, {
      value: nativeFee
    });
    console.log(`Send tx initiated. See: https://layerzeroscan.com/tx/${r.hash}`);
  });
```

Don't forget to import the task in your `hardhat.config.ts` (if not already added):

```typescript theme={"dark"}
// Add this import to hardhat.config.ts (should already be there from Step 3)
import './tasks/sendOFT';
```

**Execute the transfer:**

```bash theme={"dark"}
# Send 100 tokens from SEI to Optimism (EID: 30111)
npx hardhat lz:oft:send \
  --to 0xRecipientAddress \
  --toEid 30111 \
  --amount 100 \
  --network sei-mainnet
```

#### Option 2: Foundry Script

Create `script/SendOFT.s.sol`:

```solidity title="script/SendOFT.s.sol" theme={"dark"}
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import {Script, console} from "forge-std/Script.sol";
import { IOAppCore } from "@layerzerolabs/oapp-evm/contracts/oapp/interfaces/IOAppCore.sol";
import { SendParam, OFTReceipt } from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
import { OptionsBuilder } from "@layerzerolabs/oapp-evm/contracts/oapp/libs/OptionsBuilder.sol";
import { MessagingFee } from "@layerzerolabs/oapp-evm/contracts/oapp/OApp.sol";
import { MyOFT } from "../contracts/MyOFT.sol";

contract SendOFT is Script {
    using OptionsBuilder for bytes;

    /**
     * @dev Converts an address to bytes32.
     * @param _addr The address to convert.
     * @return The bytes32 representation of the address.
     */
    function addressToBytes32(address _addr) internal pure returns (bytes32) {
        return bytes32(uint256(uint160(_addr)));
    }

    function run() public {
        // Fetching environment variables
        address oftAddress = vm.envAddress("OFT_ADDRESS");
        address toAddress = vm.envAddress("TO_ADDRESS");
        uint256 _tokensToSend = vm.envUint("TOKENS_TO_SEND");

        // Fetch the private key from environment variable
        uint256 privateKey = vm.envUint("PRIVATE_KEY");

        // Start broadcasting with the private key
        vm.startBroadcast(privateKey);

        MyOFT sourceOFT = MyOFT(oftAddress);

        bytes memory _extraOptions = OptionsBuilder.newOptions().addExecutorLzReceiveOption(65000, 0);

        SendParam memory sendParam = SendParam(
            30111, // You can also make this dynamic if needed
            addressToBytes32(toAddress),
            _tokensToSend,
            _tokensToSend * 9 / 10,
            _extraOptions,
            "",
            ""
        );

        MessagingFee memory fee = sourceOFT.quoteSend(sendParam, false);
        console.log("Fee amount: ", fee.nativeFee);

        sourceOFT.send{value: fee.nativeFee}(sendParam, fee, msg.sender);

        // Stop broadcasting
        vm.stopBroadcast();
    }
}
```

**Environment Setup:**

```bash theme={"dark"}
# Set environment variables
export OFT_ADDRESS=0xYourOFTAddress
export TO_ADDRESS=0xRecipientAddress
export TOKENS_TO_SEND=100000000000000000000  # 100 tokens with 18 decimals

# Run the script
forge script script/SendOFT.s.sol:SendOFT --rpc-url $RPC_URL_SEI --broadcast
```

## Step 9: Done!

You've issued an omnichain token and bridged it from Sei Mainnet to Optimism. Customize supply logic, fees, or add more chains by applying changes to the core contract, redeploying, and repeating the wiring step.

### Track Your Transaction

1. Visit [https://layerzeroscan.com/tx/YOUR\_TX\_HASH](https://layerzeroscan.com/tx/YOUR_TX_HASH)
2. You'll see:
   * Source transaction
   * Message status
   * Destination transaction
   * Time elapsed
3. Check balances on both chains to confirm the transfer

## Troubleshooting

### Common Issues and Solutions

<Danger>
  **Quote Send Reverts**

  If your `quoteSend` call reverts, it usually means that your LayerZero wiring hasn't been fully configured or there's no default pathway for the chains you're trying to bridge. Here's how to diagnose and fix it:

  **1. Wiring Didn't Succeed:**

  Run the following to inspect your on‑chain wiring configuration:

  ```bash theme={"dark"}
  npx hardhat lz:oapp:config:get --oapp-config layerzero.config.ts
  ```

  See that your source configuration has a valid send library, DVN address, and target eid.

  **2. No Default Pathway:**

  LayerZero default settings should be considered placeholders. Sometimes the LayerZero defaults will contain a `LzDeadDVN`. Those entries indicate that a default pathway setting does not exist.

  * **Check**: You can see if your configuration contains a LzDeadDVN by viewing the [Default Config Checker](https://layerzeroscan.com/tools/defaults?srcChainKey%5B0%5D=sei\&version=V2\&dstChainKey%5B0%5D=optimism) on LayerZero Scan.

  * **Fix**: Open your `layerzero.config.ts` and under the relevant `pathways` entry, add working DVN providers (in the `[ requiredDVN[], [ optionalDVN[], threshold ] ]` section).

  * Re-run your wiring command for the connections so that the wiring on both chains is live.

  ```typescript theme={"dark"}
  [
    optimismContract,
    currentContract,
    [['LayerZero Labs'], []], // required & optional DVNs
    [1, 1], // required block confirmations
    [EVM_ENFORCED_OPTIONS, EVM_ENFORCED_OPTIONS],
  ],
  ```

  Once you've updated your config, retry your `quoteSend` flow. It should now return a fee estimate instead of reverting.
</Danger>

<Tip>
  **Insufficient Gas**

  If the transaction fails on the destination chain, try to increase the gas like this:

  ```typescript theme={"dark"}
  // Increase gas in options
  let options = Options.newOptions().addExecutorLzReceiveOption(150000, 0).toBytes(); // Increase from 65000 to 150000
  ```
</Tip>

## Next Steps

* **Add More Chains**: Expand to Arbitrum, Base, Polygon, etc.
* **Advanced Features**: Implement rate limiting, pausable transfers, fee collection
* **Composed Messages**: Execute actions after token arrival
* **Build a UI**: Create a frontend for easy transfers

### Learn More

* See the [Configuring Pathways](https://docs.layerzero.network/v2/get-started/create-lz-oapp/configuring-pathways) section to learn more about managing your OFTs across the entire network mesh.
* See the [Available DVNs](https://docs.layerzero.network/v2/deployments/dvn-addresses?chains=sei) and [Executor](https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=sei) to configure between.
* Learn how the protocol works by reading the [Core Concepts](https://docs.layerzero.network/v2/concepts/getting-started/what-is-layerzero) section.
* Learn more about how the OFT contract works on the EVM by reading the [OFT Quickstart](https://docs.layerzero.network/v2/developers/evm/oft/quickstart) in the EVM section.

## Resources

* **LayerZero Documentation**: [https://docs.layerzero.network/v2](https://docs.layerzero.network/v2)
* **LayerZero Scan**: [https://layerzeroscan.com/](https://layerzeroscan.com/)
* **SEI Explorer**: [https://seiscan.io](https://seiscan.io)

## Summary

You've successfully:

* ✅ Created an Omnichain Fungible Token project
* ✅ Configured networks and LayerZero pathways
* ✅ Deployed contracts to multiple chains
* ✅ Connected the deployments via LayerZero wiring
* ✅ Created tasks for cross-chain token transfers
* ✅ Learned how LayerZero enables omnichain applications

Your tokens can now move freely between SEI and any connected chain, maintaining a unified supply and enabling true cross-chain functionality!

---

URL: https://docs.sei.io/evm/usdc-on-sei

# USDC on Sei

> Guide to integrating USDC stablecoin on Sei using Viem and Node.js for transfers and balance checks.

## Addresses and Decimals

* Testnet (atlantic-2) USDC: [`0x4fCF1784B31630811181f670Aea7A7bEF803eaED`](https://testnet.seiscan.io/address/0x4fCF1784B31630811181f670Aea7A7bEF803eaED)
* Mainnet (pacific-1) USDC: [`0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392`](https://seiscan.io/address/0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392)
* Decimals: `6`

## Overview

USDC is a digital dollar issued by [Circle](http://developers.circle.com), also known as a stablecoin, running on many of the world's leading blockchains. Designed to represent US dollars on the internet, USDC is backed 100% by highly liquid cash and cash-equivalent assets so that it's always redeemable 1:1 for USD. It is commonly used for payments, trading, and on/off-ramps in web3 apps.

On the **Sei**, USDC can be transferred like any standard ERC-20 token — enabling fast, secure, and programmable digital dollar transactions.

This guide walks you through building a standalone index.js script using **Viem** and **Node.js** to check your USDC balance and send a test transfer to another address. The sample is a minimal, generic ERC‑20 flow using USDC as the example token.

### Prerequisites

* Node.js v18+ with "type": "module" in package.json
* viem and dotenv installed
* Sei wallet with USDC and SEI for gas on your selected network (default: testnet).
* To get testnet USDC on Sei, use the [Circle Faucet](https://faucet.circle.com) or use [Circle’s CCTP v2](https://github.com/circlefin/circle-cctp-crosschain-transfer) Sample application to transfer USDC cross-chain to your Sei wallet.
* Private key and recipient address stored in a .env file
* Optional: set `SEI_NETWORK=testnet|mainnet` (defaults to `testnet`)

## Project Setup

Follow these steps to set up your project and environment:

* Initialize a Node.js project and install dependencies: create a project folder and run:

```shell theme={"dark"}
npm init -y
npm install viem dotenv
```

* **Prepare environment variables**: In the project root, create a file named .env and add your private key and recipient address:

```
PRIVATE_KEY=<YOUR_PRIVATE_KEY>       # 0x-prefixed 64-hex-character key
RECIPIENT_ADDRESS=0x<RECIPIENT_ADDRESS>
# Optional (defaults to testnet): testnet | mainnet
SEI_NETWORK=testnet
```

* **Create the script file**: Create an index.js file in the project directory. We will build this script step by step in the next section. Ensure that your Node environment can handle ES module imports (the code uses import syntax).

## Script Breakdown

Open index.js in your editor and add the following sections. Each part of the script is explained below:

1\. Import Modules and Define Chain/Token Constants: First, import required functions from Viem and set up constants for Sei networks (testnet and mainnet) and the USDC token contract.

This includes chain ID, RPC URL, token address, decimals, and a minimal ABI for the USDC contract’s balanceOf and transfer functions (just the function signatures we need):

```ts theme={"dark"}
import 'dotenv/config';
import { createPublicClient, createWalletClient, http, formatUnits, parseUnits } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

// --- Chain and Contract Config ---
const seiTestnet = {
	id: 1328,
	name: 'Sei Atlantic-2 Testnet',
	network: 'sei-atlantic-2',
	nativeCurrency: { name: 'Sei', symbol: 'SEI', decimals: 18 },
	rpcUrls: { default: { http: ['https://evm-rpc-testnet.sei-apis.com'] } },
	blockExplorers: { default: { url: 'https://testnet.seiscan.io' } },
	testnet: true
};

const seiMainnet = {
	id: 1329,
	name: 'Sei Mainnet (pacific-1)',
	network: 'sei-pacific-1',
	nativeCurrency: { name: 'Sei', symbol: 'SEI', decimals: 18 },
	rpcUrls: { default: { http: ['https://evm-rpc.sei-apis.com'] } },
	blockExplorers: { default: { url: 'https://seiscan.io' } },
	testnet: false
};

// --- Network selection (default: testnet) ---
const NETWORK = (process.env.SEI_NETWORK || 'testnet').toLowerCase();
const chain = NETWORK === 'mainnet' ? seiMainnet : seiTestnet;

// --- USDC Addresses and ABI ---
const USDC_ADDRESSES = {
	testnet: '0x4fCF1784B31630811181f670Aea7A7bEF803eaED',
	mainnet: '0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392'
};
const USDC_ADDRESS = NETWORK === 'mainnet' ? USDC_ADDRESSES.mainnet : USDC_ADDRESSES.testnet;
const USDC_DECIMALS = 6;
const USDC_ABI = [
	{
		name: 'balanceOf',
		type: 'function',
		stateMutability: 'view',
		inputs: [{ name: 'account', type: 'address' }],
		outputs: [{ name: '', type: 'uint256' }]
	},
	{
		name: 'transfer',
		type: 'function',
		stateMutability: 'nonpayable',
		inputs: [
			{ name: 'to', type: 'address' },
			{ name: 'amount', type: 'uint256' }
		],
		outputs: [{ name: '', type: 'bool' }]
	}
];
```

2\. **Load Environment Variables and Validate Input:**

Next, load the private key and recipient from the environment and validate them. The script checks that the variables exist and that the recipient address looks valid, then normalizes the private key string:

```ts theme={"dark"}
// --- Environment Variables ---
const PRIVATE_KEY_RAW = process.env.PRIVATE_KEY;
const RECIPIENT = process.env.RECIPIENT_ADDRESS || process.env.RECIPIENT;

if (!PRIVATE_KEY_RAW) {
	console.error('Error: Set PRIVATE_KEY in your .env file');
	process.exit(1);
}
if (!RECIPIENT) {
	console.error('Error: Set RECIPIENT_ADDRESS (or RECIPIENT) in your .env file');
	process.exit(1);
}
if (!/^0x[a-fA-F0-9]{40}$/.test(RECIPIENT)) {
	console.error('Error: Recipient address is not a valid Ethereum address');
	process.exit(1);
}

// --- Private Key Normalization ---
const PRIVATE_KEY = PRIVATE_KEY_RAW.startsWith('0x') ? PRIVATE_KEY_RAW : '0x' + PRIVATE_KEY_RAW;
```

This ensures we have the necessary inputs. If the private key or recipient address is missing or malformed, the script logs an error and exits. The private key is prefixed with "0x" if not already present (Viem expects a 0x-prefixed key).

After this, PRIVATE\_KEY is a clean hex string and RECIPIENT is a validated address.

3\. Initialize Viem Clients:

Using the chain config and credentials, we create a public client for reading blockchain data and a wallet client for writing (signing transactions). We also derive an account object from the private key:

```ts theme={"dark"}
// --- Client Setup ---
const account = privateKeyToAccount(PRIVATE_KEY);
const publicClient = createPublicClient({ chain, transport: http() });
const walletClient = createWalletClient({ account, chain, transport: http() });
```

* privateKeyToAccount converts the hex private key into an account object (with the corresponding address, etc.).
* createPublicClient connects to the selected Sei network RPC for read-only calls (no private key needed).
* createWalletClient uses our account and the RPC to allow sending transactions.

At this point, we’re set up to interact with the selected Sei network: publicClient will call eth\_call for contract reads, and walletClient will handle signing and sending transactions from our account.

4\. Main Transfer Logic:

Finally, we write an asynchronous function to perform the USDC transfer. It will check the sender’s USDC balance, ensure it’s sufficient, then invoke the USDC contract’s transfer function.

We also log key info and handle errors:

```ts theme={"dark"}
// --- Main Transfer Logic ---
(async () => {
	try {
		// Check sender's USDC balance
		const balance = await publicClient.readContract({
			address: USDC_ADDRESS,
			abi: USDC_ABI,
			functionName: 'balanceOf',
			args: [account.address]
		});
		const balanceFormatted = Number(formatUnits(balance, USDC_DECIMALS));
		const amount = 10; // amount of USDC to send (in whole units)
		console.log('Sender:', account.address);
		console.log('Recipient:', RECIPIENT);
		console.log('USDC balance:', balanceFormatted);
		if (amount > balanceFormatted) {
			console.error('Error: Insufficient USDC balance');
			process.exit(1);
		}

		// Convert amount to token decimals and send transfer
		const amountInDecimals = parseUnits(amount.toString(), USDC_DECIMALS);
		const hash = await walletClient.writeContract({
			address: USDC_ADDRESS,
			abi: USDC_ABI,
			functionName: 'transfer',
			args: [RECIPIENT, amountInDecimals]
		});
		console.log('Transfer successful!');
		console.log('Tx hash:', hash);
		const explorerBase =
			chain.blockExplorers && chain.blockExplorers.default && chain.blockExplorers.default.url ? chain.blockExplorers.default.url : 'https://seiscan.io';
		console.log('Explorer:', `${explorerBase}/tx/${hash}`);
	} catch (err) {
		console.error('Transfer failed:', err.message || err);
		process.exit(1);
	}
	process.exit(0);
})();
```

* The script uses publicClient.readContract to call the USDC contract’s balanceOf(address) and get the sender’s token balance.

* We format the balance from smallest units (6 decimals for USDC) into a human-readable number with formatUnits. The amount is set to 10 USDC in this example – you can adjust this value. We compare the desired amount to the current balance; if insufficient, it logs an error and exits.

* If the balance is adequate, we use parseUnits to convert 10 USDC into the raw token amount (10 \* 10^6, since USDC has 6 decimals).\
  Then walletClient.writeContract calls the USDC contract’s transfer(to, amount) function. This sends a transaction from our account to transfer the tokens. On success, it returns a transaction hash, which we log alongside a URL to view the transaction on the Sei block explorer.

* Errors in the try/catch (for example, RPC issues or a transaction failure) will log “Transfer failed” with the error message. The script ends with process.exit(0) to terminate after completing the async function.

## Run the Script

With index.js completed, you can run the script from your terminal:

```shell theme={"dark"}
# Default: testnet
node index.js

# Mainnet
SEI_NETWORK=mainnet node index.js
```

The expected output will look like the following if the transfer succeeds (your addresses and values will differ):

```
Sender: 0x1A2b...7890      # your sender address
Recipient: 0x9F8f...1234   # recipient address
USDC balance: 250.0        # current USDC balance of sender
Transfer successful!
Tx hash: 0xabc123...def456 # transaction hash of the transfer
Explorer: https://testnet.seiscan.io/tx/0xabc123...def456
```

You should see “Transfer successful!” and a transaction hash. You can copy the explorer URL into a browser to view the transaction details on Seiscan.

Continue building by checking for more information in the [Circle Developer Docs.](https://developers.circle.com/)

### Important Notes

* Testnet Only: Sei testnet USDC has no real value. Don’t use mainnet keys or expect real funds.
* Security: Store private keys in `.env`; never commit secrets. Use best practices for key management.
* Gas Fees: You’ll need a small amount of testnet SEI to cover gas.
* Lightweight ABI: Only `balanceOf` and `transfer` are used — enough for simple transfers.
* Viem Behavior: `readContract` and `writeContract` handle reads/writes. The private key is auto-prefixed with `0x`.

---

URL: https://docs.sei.io/evm/dune

# Dune Analytics

> Complete guide to working with Dune Analytics on Sei Network

## What is Dune Analytics?

Dune Analytics is a powerful blockchain analytics platform that allows you to query, visualize, and share blockchain data using SQL. For game developers, it's an invaluable tool for:

* **Player Analytics**: Track user acquisition, retention, and engagement
* **Transaction Analysis**: Monitor game economy and player behavior
* **Performance Metrics**: Measure daily/weekly active users, transaction volumes
* **Cohort Analysis**: Understand player lifecycle and retention patterns
* **Custom Dashboards**: Create visual reports for stakeholders

### Key Features:

* SQL-based querying interface
* Pre-indexed blockchain data from multiple networks
* Visualization tools for charts and dashboards
* Real-time data updates

## Prerequisites

Before you begin, make sure you have:

1. **Dune Account**: Sign up at [dune.com](https://dune.com)
2. **Basic SQL Knowledge**: Understanding of SELECT, JOIN, WHERE, GROUP BY clauses
3. **Contract Addresses**: Know your game's smart contract addresses
4. **Understanding of Your Game Logic**: Know what transactions represent in your game context

### SQL Knowledge Requirements:

* Basic `SELECT` statements
* JOINs (`INNER`, `LEFT`)
* Aggregate functions (`COUNT`, `SUM`, `AVG`)
* Date functions (`DATE_TRUNC`, `DATE_DIFF`)
* Common Table Expressions (`WITH` clauses)

## Getting Started

### Step 1: Access the Template Dashboard

Visit the Sei Games Query Templates: [Game Query Templates](https://dune.com/sei/sei-games-query-templates)

### Step 2: Understanding the Dashboard Structure

The template dashboard contains several key metrics:

* Total unique users
* Cohort retention analysis
* User acquisition trends
* Transaction volume analysis
* Daily/Weekly active users

Below are the SQL queries powering these metrics.

## How to Fork and Use Query Templates

### Forking a Query

1. **Navigate to the Query**: Click on any visualization in the dashboard
2. **Access Query Editor**: Click "Edit Query" or the query title
3. **Fork the Query**: Click the "Fork" button in the top right
4. **Rename Your Fork**: Give it a descriptive name like "MyGame - Daily Active Users"
5. **Customize**: Replace placeholder values with your actual contract addresses

### Making Queries Private/Public

* **Private Queries**: Only visible to you
* **Public Queries**: Visible to all Dune users
* **Unlisted**: Not searchable but accessible via direct link

## Query Templates for Game Analytics

### 1. Total Unique Users

**Purpose**: Get the total number of unique players who have ever interacted with your game.

```sql theme={"dark"}
WITH my_game_contracts AS (
  SELECT
    address
  FROM UNNEST(ARRAY[
    0xYOUR_CONTRACT_ADDRESS_1,
    0xYOUR_CONTRACT_ADDRESS_2
  ]) AS _u(address)
)

SELECT
  COUNT(DISTINCT t."from") AS total_unique_users
FROM sei.transactions AS t
JOIN my_game_contracts AS c
  ON t."to" = c.address
WHERE
  t.success = TRUE
```

**How to Use**:

* Replace `0xYOUR_CONTRACT_ADDRESS_1` with your actual contract addresses
* Add or remove addresses as needed

***

### 2. Cohort Retention Analysis

**Purpose**: Analyze how well you retain players over time by tracking weekly cohorts.

```sql theme={"dark"}
WITH my_game_contracts AS (
    SELECT array[
        0xYOUR_CONTRACT_ADDRESS_1,
        0xYOUR_CONTRACT_ADDRESS_2
    ] AS addresses
),

-- Find the first time every user was ever seen (Define the Cohort)
user_cohorts AS (
    SELECT
        t."from" AS user_address,
        MIN(DATE_TRUNC('week', t.block_date)) AS cohort_week
    FROM sei.transactions t
    CROSS JOIN UNNEST(
        (SELECT addresses FROM my_game_contracts)
    ) AS c (address)
    WHERE t."to" = c.address
        AND t.success = true
    GROUP BY 1
),

-- Find all weeks where users were active (Activity Log)
user_activity AS (
    SELECT DISTINCT
        t."from" AS user_address,
        DATE_TRUNC('week', t.block_date) AS activity_week
    FROM sei.transactions t
    CROSS JOIN UNNEST(
        (SELECT addresses FROM my_game_contracts)
    ) AS c (address)
    WHERE t."to" = c.address
        AND t.success = true
),

-- Calculate Cohort Size
cohort_size AS (
    SELECT cohort_week, COUNT(user_address) AS total_users
    FROM user_cohorts
    GROUP BY 1
),

-- Calculate the time difference (offset) and retained users
retention_data AS (
    SELECT
        c.cohort_week,
        DATE_DIFF('week', c.cohort_week, a.activity_week) AS week_offset,
        COUNT(DISTINCT c.user_address) AS retained_users
    FROM user_cohorts c
    JOIN user_activity a ON c.user_address = a.user_address
    WHERE a.activity_week >= c.cohort_week
    GROUP BY 1, 2
)

-- Final Output: Dynamic List Format for Heatmap Visualization
SELECT
    d.cohort_week,
    s.total_users AS cohort_size,
    d.week_offset,
    ROUND(d.retained_users * 100.0 / s.total_users, 2) AS retention_percentage
FROM retention_data d
JOIN cohort_size s ON d.cohort_week = s.cohort_week
ORDER BY 1 ASC, 3 ASC;
```

**Key Metrics**:

* `cohort_week`: When users first joined
* `week_offset`: Weeks since first interaction (0 = first week, 1 = second week, etc.)
* `retention_percentage`: Percentage of cohort still active

***

### 3. Weekly User Acquisition

**Purpose**: Track how many new users you're acquiring each week.

```sql theme={"dark"}
WITH my_game_contracts AS (
  SELECT
    address
  FROM UNNEST(ARRAY[
    0xYOUR_CONTRACT_ADDRESS_1,
    0xYOUR_CONTRACT_ADDRESS_2
  ]) AS _u(address)
),

user_first_seen AS (
  SELECT
    t."from" AS user_address,
    MIN(t.block_date) AS first_interaction_date
  FROM sei.transactions AS t
  JOIN my_game_contracts AS c
    ON t."to" = c.address
  WHERE
    t.success = TRUE
  GROUP BY 1
)

SELECT
  DATE_TRUNC('week', first_interaction_date) AS acquisition_week,
  COUNT(user_address) AS new_users
FROM user_first_seen
GROUP BY 1
ORDER BY 1 DESC
```

***

### 4. Daily Transaction Volume

**Purpose**: Monitor daily transaction activity in your game.

```sql theme={"dark"}
WITH my_game_contracts AS (
  SELECT
    address
  FROM UNNEST(ARRAY[
    0xYOUR_CONTRACT_ADDRESS_1,
    0xYOUR_CONTRACT_ADDRESS_2
  ]) AS _u(address)
)

SELECT
  t.block_date,
  COUNT(*) AS tx_count
FROM sei.transactions AS t
JOIN my_game_contracts AS c
  ON t."to" = c.address
WHERE
  t.success = TRUE
GROUP BY 1
ORDER BY 1 DESC
```

***

### 5. Daily Active Users (DAU)

**Purpose**: Track unique daily active users.

```sql theme={"dark"}
WITH my_game_contracts AS (
  SELECT
    address
  FROM UNNEST(ARRAY[
    0xYOUR_CONTRACT_ADDRESS_1,
    0xYOUR_CONTRACT_ADDRESS_2
  ]) AS _u(address)
)

SELECT
  t.block_date,
  COUNT(DISTINCT t."from") AS daily_active_users
FROM sei.transactions AS t
JOIN my_game_contracts AS c
  ON t."to" = c.address
WHERE
  t.success = TRUE
GROUP BY 1
ORDER BY 1 DESC
```

***

### 6. Weekly Transaction Volume

**Purpose**: Analyze weekly transaction patterns.

```sql theme={"dark"}
WITH my_game_contracts AS (
  SELECT
    address
  FROM UNNEST(ARRAY[
    0xYOUR_CONTRACT_ADDRESS_1,
    0xYOUR_CONTRACT_ADDRESS_2
  ]) AS _u(address)
)

SELECT
  DATE_TRUNC('week', t.block_date) AS week_start,
  COUNT(*) AS tx_count
FROM sei.transactions AS t
JOIN my_game_contracts AS c
  ON t."to" = c.address
WHERE
  t.success = TRUE
GROUP BY 1
ORDER BY 1 DESC
```

***

### 7. Weekly Active Users (WAU)

**Purpose**: Track unique weekly active users.

```sql theme={"dark"}
WITH my_game_contracts AS (
  SELECT
    address
  FROM UNNEST(ARRAY[
    0xYOUR_CONTRACT_ADDRESS_1,
    0xYOUR_CONTRACT_ADDRESS_2
  ]) AS _u(address)
)

SELECT
  DATE_TRUNC('week', t.block_date) AS week_start,
  COUNT(DISTINCT t."from") AS weekly_active_users
FROM sei.transactions AS t
JOIN my_game_contracts AS c
  ON t."to" = c.address
WHERE
  t.success = TRUE
GROUP BY 1
ORDER BY 1 DESC
```

***

### 8. Daily User Acquisition

**Purpose**: Track new user acquisition on a daily basis.

```sql theme={"dark"}
WITH my_game_contracts AS (
  SELECT
    address
  FROM UNNEST(ARRAY[
    0xYOUR_CONTRACT_ADDRESS_1,
    0xYOUR_CONTRACT_ADDRESS_2
  ]) AS _u(address)
),

user_first_seen AS (
  SELECT
    t."from" AS user_address,
    MIN(t.block_date) AS first_interaction_date
  FROM sei.transactions AS t
  JOIN my_game_contracts AS c
    ON t."to" = c.address
  WHERE
    t.success = TRUE
  GROUP BY 1
)

SELECT
  first_interaction_date,
  COUNT(user_address) AS new_users
FROM user_first_seen
GROUP BY 1
ORDER BY 1 DESC
```

## Customizing Queries for Your Game

### 1. Replace Contract Addresses

**Find this section in each query**:

```sql theme={"dark"}
FROM UNNEST(ARRAY[
  0xYOUR_CONTRACT_ADDRESS_1,
  0xYOUR_CONTRACT_ADDRESS_2
]) AS _u(address)
```

**Replace with your actual addresses**:

```sql theme={"dark"}
FROM UNNEST(ARRAY[
  0xa1b2c3d4e5f6789012345678901234567890abcd,
  0x1234567890abcdef1234567890abcdef12345678,
  0xfedcba0987654321fedcba0987654321fedcba09
]) AS _u(address)
```

### 2. Filter by Specific Functions

To track specific game actions, add function signature filtering:

```sql theme={"dark"}
WHERE
  t.success = TRUE
  AND t.data LIKE '0x12345678%'  -- Replace with your function signature
```

### 3. Add Time Filters

To analyze specific periods:

```sql theme={"dark"}
WHERE
  t.success = TRUE
  AND t.block_date >= '2024-01-01'
  AND t.block_date <= '2024-12-31'
```

## Best Practices

### Performance Optimization

1. **Use Date Filters**: Always include date ranges to limit data scope
2. **Index Awareness**: Filter on indexed columns (block\_date, address) first
3. **Limit Results**: Use `LIMIT` for testing large queries

***

## Resources

* [Dune Analytics Documentation](https://docs.dune.com)

---

URL: https://docs.sei.io/evm/oracles/chainlink

# Chainlink Data Streams

> Complete guide to integrating Chainlink Data Streams with Sei Network

## What is Chainlink?

Chainlink is the world's most widely adopted decentralized oracle network, enabling smart contracts to securely access off-chain data, APIs, and traditional payment systems. Chainlink Data Streams is a pull-based oracle solution that delivers high-frequency, low-latency market data directly to smart contracts.

## What This Guide Teaches You

This tutorial will walk you through integrating Chainlink Data Streams on Sei Network to:

1. **Fetch real-time price data** using the Chainlink Data Streams SDK
2. **Deploy a smart contract** that can verify and decode price reports on-chain
3. **Combine off-chain and on-chain components** to create a complete oracle solution
4. **Verify SEI/USDT price feeds** as a practical example

By the end of this guide, you'll have a working implementation that fetches price data off-chain and verifies it on-chain using Chainlink's data streams SDK.

## Prerequisites

Before starting this tutorial, ensure you have:

### Technical Requirements

* **Node.js** (v18 or higher) and npm installed
* **Basic knowledge** of TypeScript/JavaScript
* **Solidity development experience** (basic to intermediate)
* **Familiarity with smart contract deployment** tools like Remix or Hardhat

### Sei Network Setup

**Testnet** :

* **Sei testnet RPC**: `https://evm-rpc-testnet.sei-apis.com`
* **Chain ID**: 1328

**Mainnet** :

* **SEI mainnet RPC**: `https://evm-rpc.sei-apis.com`
* **Chain ID**: 1329

### Chainlink Data Streams Access

<Info>You need to contact Chainlink for getting access to API credentials of Data Streams.</Info>

* **API credentials**: Contact Chainlink to get access to Data Streams on Sei Mainnet/testnet
* **API Key** and **User Secret** for testnet access
* **Feed IDs**: We'll use [SEI/USDT](https://docs.chain.link/data-streams/crypto-streams?page=1\&testnetPage=1\&testnetSearch=SEI#testnet-crypto-streams) feed ID `0x0003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117`
* **VerifierProxy contract address**: `0x60fAa7faC949aF392DFc858F5d97E3EEfa07E9EB` — the same address is used on [Sei mainnet](https://seiscan.io/address/0x60fAa7faC949aF392DFc858F5d97E3EEfa07E9EB) and [Sei testnet](https://testnet.seiscan.io/address/0x60fAa7faC949aF392DFc858F5d97E3EEfa07E9EB). See Chainlink's [Stream Addresses](https://docs.chain.link/data-streams/crypto-streams) page for the current list.

## Step-by-Step Tutorial

### Step 1: Project Setup

Create a new directory and initialize your project:

```bash theme={"dark"}
mkdir chainlink-data-streams-sei
cd chainlink-data-streams-sei
npm init -y
```

Install the required dependencies:

```bash theme={"dark"}
npm install @chainlink/data-streams-sdk dotenv tsx ethers
npm install -D typescript @types/node
```

Create a `.env` file in your project root:

```env theme={"dark"}
API_KEY=your_chainlink_api_key_here
USER_SECRET=your_chainlink_user_secret_here
```

### Step 2: Fetching Price Data with TypeScript

Create a file called `singleStream.ts` with the following code:

```typescript theme={"dark"}
import { createClient, decodeReport, LogLevel, getReportVersion, formatReport } from '@chainlink/data-streams-sdk';
import 'dotenv/config';

async function main() {
  if (process.argv.length < 3) {
    console.error('Please provide a feed ID as an argument');
    console.error('Example: npx tsx singleStream.ts 0x0003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117');
    process.exit(1);
  }

  const feedId = process.argv[2];
  const version = getReportVersion(feedId);

  try {
    const config = {
      apiKey: process.env.API_KEY || 'YOUR_API_KEY',
      userSecret: process.env.USER_SECRET || 'YOUR_USER_SECRET',
      endpoint: 'https://api.testnet-dataengine.chain.link',
      wsEndpoint: 'wss://ws.testnet-dataengine.chain.link',
      // Comment to disable SDK logging:
      logging: {
        logger: console,
        logLevel: LogLevel.INFO
      }
    };

    const client = createClient(config);
    console.log(`\nFetching latest report for feed ${feedId} (${version})...\n`);

    // Get raw report data
    const report = await client.getLatestReport(feedId);
    console.log(`Raw Report Blob: ${report.fullReport}`);

    // Decode the report
    const decodedData = decodeReport(report.fullReport, report.feedID);

    // Combine decoded data with report metadata
    const decodedReport = {
      ...decodedData,
      feedID: report.feedID,
      validFromTimestamp: report.validFromTimestamp,
      observationsTimestamp: report.observationsTimestamp
    };
    console.log(formatReport(decodedReport, version));
  } catch (error) {
    if (error instanceof Error) {
      console.error('Error:', error.message);
    } else {
      console.error('Unknown error:', error);
    }
    process.exit(1);
  }
}

main();
```

This script:

* **Creates a Data Streams client** with your API credentials
* **Fetches the latest report** for a given feed ID
* **Decodes the raw report** into readable price data
* **Displays both raw and formatted data** for debugging

### Step 3: Smart Contract Deployment

Create and deploy the verification contract on Sei Network. Copy this Solidity code into Remix IDE:

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {Common} from "@chainlink/contracts@1.5.0/src/v0.8/llo-feeds/libraries/Common.sol";
import {IVerifierFeeManager} from "@chainlink/contracts@1.5.0/src/v0.8/llo-feeds/v0.3.0/interfaces/IVerifierFeeManager.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

using SafeERC20 for IERC20;

/**
 * THIS IS AN EXAMPLE CONTRACT FOR DEMONSTRATION PURPOSES.
 * This contract verifies Chainlink Data Streams reports onchain
 * and handles fee payments automatically.
 */

interface IVerifierProxy {
  function verify(
    bytes calldata payload,
    bytes calldata parameterPayload
  ) external payable returns (bytes memory verifierResponse);

  function s_feeManager() external view returns (IVerifierFeeManager);
}

interface IFeeManager {
  function getFeeAndReward(
    address subscriber,
    bytes memory unverifiedReport,
    address quoteAddress
  ) external returns (Common.Asset memory, Common.Asset memory, uint256);

  function i_linkAddress() external view returns (address);
  function i_rewardManager() external view returns (address);
}

contract ClientReportsVerifier {
  // Errors
  error NothingToWithdraw();
  error NotOwner(address caller);
  error InvalidReportVersion(uint16 version);

  // Report schema v3 (crypto streams)
  struct ReportV3 {
    bytes32 feedId;
    uint32 validFromTimestamp;
    uint32 observationsTimestamp;
    uint192 nativeFee;
    uint192 linkFee;
    uint32 expiresAt;
    int192 price;
    int192 bid;
    int192 ask;
  }

  // Storage
  IVerifierProxy public immutable i_verifierProxy;
  address private immutable i_owner;
  int192 public lastDecodedPrice;

  // Events
  event DecodedPrice(int192 price);

  constructor(address _verifierProxy) {
    i_owner = msg.sender;
    i_verifierProxy = IVerifierProxy(_verifierProxy);
  }

  modifier onlyOwner() {
    if (msg.sender != i_owner) revert NotOwner(msg.sender);
    _;
  }

  /**
   * @notice Verify a Data Streams report and extract price
   * @param unverifiedReport Full payload from Data Streams API
   */
  function verifyReport(bytes memory unverifiedReport) external {
    // Extract report data and version
    (, bytes memory reportData) = abi.decode(unverifiedReport, (bytes32[3], bytes));

    uint16 reportVersion = (uint16(uint8(reportData[0])) << 8) | uint16(uint8(reportData[1]));
    if (reportVersion != 3) {
      revert InvalidReportVersion(reportVersion);
    }

    // Handle fees
    IFeeManager feeManager = IFeeManager(address(i_verifierProxy.s_feeManager()));
    bytes memory parameterPayload;

    if (address(feeManager) != address(0)) {
      address feeToken = feeManager.i_linkAddress();
      (Common.Asset memory fee,,) = feeManager.getFeeAndReward(
        address(this),
        reportData,
        feeToken
      );

      IERC20(feeToken).approve(feeManager.i_rewardManager(), fee.amount);
      parameterPayload = abi.encode(feeToken);
    } else {
      parameterPayload = bytes("");
    }

    // Verify through proxy
    bytes memory verified = i_verifierProxy.verify(unverifiedReport, parameterPayload);

    // Decode and store price
    ReportV3 memory report = abi.decode(verified, (ReportV3));
    lastDecodedPrice = report.price;
    emit DecodedPrice(report.price);
  }

  /**
   * @notice Withdraw ERC-20 tokens from contract
   */
  function withdrawToken(address _beneficiary, address _token) external onlyOwner {
    uint256 amount = IERC20(_token).balanceOf(address(this));
    if (amount == 0) revert NothingToWithdraw();
    IERC20(_token).safeTransfer(_beneficiary, amount);
  }

  /**
   * @notice Get the last decoded price
   */
  function getLastPrice() external view returns (int192) {
    return lastDecodedPrice;
  }
}
```

**Deployment steps in Remix:**

1. Switch to Sei Testnet in MetaMask
2. Deploy with Sei testnet VerifierProxy address: `0x60fAa7faC949aF392DFc858F5d97E3EEfa07E9EB`
3. Save the contract address for testing

### Step 4: Complete Integration Script

Create `verifyOnChain.ts` to combine off-chain fetching with on-chain verification:

```typescript theme={"dark"}
import { createClient, LogLevel } from '@chainlink/data-streams-sdk';
import 'dotenv/config';

// You'll need to install ethers: npm install ethers
import { ethers } from 'ethers';

async function main() {
  const feedId = '0x0003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117';

  // 1. Fetch the latest report
  const config = {
    apiKey: process.env.API_KEY!,
    userSecret: process.env.USER_SECRET!,
    endpoint: 'https://api.testnet-dataengine.chain.link',
    wsEndpoint: 'wss://ws.testnet-dataengine.chain.link',
    logging: {
      logger: console,
      logLevel: LogLevel.INFO
    }
  };

  const client = createClient(config);
  console.log('Fetching latest report...');

  const report = await client.getLatestReport(feedId);
  console.log(`Got report: ${report.fullReport}`);

  // 2. Connect to Sei testnet and your deployed contract
  const provider = new ethers.JsonRpcProvider('https://evm-rpc-testnet.sei-apis.com');
  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);

  const contractAddress = 'YOUR_DEPLOYED_CONTRACT_ADDRESS';
  const abi = ['function verifyReport(bytes memory unverifiedReport) external', 'function getLastPrice() external view returns (int192)', 'event DecodedPrice(int192 price)'];

  const contract = new ethers.Contract(contractAddress, abi, wallet);

  // 3. Verify the report on-chain
  console.log('Verifying report on-chain...');
  const tx = await contract.verifyReport(report.fullReport);
  await tx.wait();

  // 4. Get the decoded price
  const price = await contract.getLastPrice();
  console.log(`Price verified on-chain: ${ethers.formatUnits(price.toString(), 18)} SEI/USDT`);
}

main().catch(console.error);
```

## How to Run and Test

### 1. Test Off-chain Data Fetching

Run the single stream script to verify off-chain fetching and decoding:

```bash theme={"dark"}
npx tsx singleStream.ts 0x0003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117
```

**Expected output:**

```bash theme={"dark"}
npx tsx singleStream.ts 0x0003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117
[DataStreams] Data Streams client initialized

Fetching latest report for feed 0x0003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117 (V3)...

[DataStreams] Request successful: GET https://api.testnet-dataengine.chain.link/api/v1/reports/latest?feedID=0x0003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117 - 200
Raw Report Blob: 0x00090d9e8d96765a0c49e03a6ae05c82e8f8de70cf179baa632f18313e54bd690000000000000000000000000000000000000000000000000000000002ad82fe000000000000000000000000000000000000000000000000000000030000000100000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000280010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001200003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117000000000000000000000000000000000000000000000000000000006911a843000000000000000000000000000000000000000000000000000000006911a843000000000000000000000000000000000000000000000000000050fde585ef340000000000000000000000000000000000000000000000000045e76ab072da670000000000000000000000000000000000000000000000000000000069393543000000000000000000000000000000000000000000000000027f85b14842c1b4000000000000000000000000000000000000000000000000027f47776cef65d0000000000000000000000000000000000000000000000000027fb6ed8fc487e400000000000000000000000000000000000000000000000000000000000000027d2c18d803d4e1818fff6521a21a336a03e334ae5af3dccee1ee241239c1661d8a3d0384d5ae6159d4ac1151ffbc9d717304359ce7a904faeb1c5f23375c1e69000000000000000000000000000000000000000000000000000000000000000218da9942080bfb1d679e0185216226c52fd6eaf34fb4c9ee139dd1c87f235a3e18d4822b9454d61d010584f27ccdc6812df13dfe50409252d6cbc774f26b53d2

Report Metadata:
Feed ID: 0x0003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117
Valid From: 1762764867
Observations: 1762764867

Decoded Data:
Native Fee: 89051407707956
LINK Fee: 19676218805901927
Expires At: 1765356867
Price: 180009506586149300
Bid Price: 179941088372418000
Ask Price: 180063641553635300
```

### 2. Test Smart Contract Deployment

1. Copy the raw report blob from Step 1 output (the long hex string starting with `0x00090d9e...`)
2. Call `verifyReport()` and paste the entire blob as the `unverifiedReport` parameter
3. Call `getLastPrice()` - you should see the decoded price (e.g., `180009506586149300`)

### 3. Test Complete Integration

**Step 3a: Setup Integration Script**

Add your private key to `.env`:

```env theme={"dark"}
API_KEY=your_chainlink_api_key_here
USER_SECRET=your_chainlink_user_secret_here
PRIVATE_KEY=your_sei_testnet_private_key_here
```

Update `verifyOnChain.ts` with your deployed contract address:

Replace `YOUR_DEPLOYED_CONTRACT_ADDRESS` in the script with your actual contract address.

**Step 3b: Run Integration Test**

```bash theme={"dark"}
npx tsx verifyOnChain.ts
```

**Expected Output:**

```bash theme={"dark"}
npx tsx verifyOnChain.ts
[DataStreams] Data Streams client initialized
Fetching latest report...
[DataStreams] Request successful: GET https://api.testnet-dataengine.chain.link/api/v1/reports/latest?feedID=0x0003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117 - 200
Got report: 0x00090d9e8d96765a0c49e03a6ae05c82e8f8de70cf179baa632f18313e54bd690000000000000000000000000000000000000000000000000000000002ad80fd000000000000000000000000000000000000000000000000000000030000000100000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000280000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001200003dba2d8553dfd7afe35c2bfe217ef5106d7805e5272c04a08940ddb868117000000000000000000000000000000000000000000000000000000006911a794000000000000000000000000000000000000000000000000000000006911a794000000000000000000000000000000000000000000000000000051070460a3df0000000000000000000000000000000000000000000000000045e8f0bff5bcd30000000000000000000000000000000000000000000000000000000069393494000000000000000000000000000000000000000000000000027fe207ce1890f4000000000000000000000000000000000000000000000000027fb2bbee1e2038000000000000000000000000000000000000000000000000028013671aa35a0400000000000000000000000000000000000000000000000000000000000000024ef8f65551057e6a89745ffd306a5202162d6b280fc9754360175b54a95f11598da55d6d7d965384479c9d4ff248cd00ffd89078d05de048299c61c48d0361c8000000000000000000000000000000000000000000000000000000000000000278bc17f79bf5d6483310b28fe004e884a64e603cbc212044492098af36b4d50047bf5dc8af1e50abfc5f38060fb7f4b6dc9089589915144211fa6e6ff049dd1e
Verifying report on-chain...
Price verified on-chain: 0.180009506586149300 SEI/USDT
```

## Resources

* [Chainlink Data Streams Documentation](https://docs.chain.link/data-streams/)

---

URL: https://docs.sei.io/evm/oracles/redstone

# RedStone

> Complete guide to integrating RedStone oracles with Sei

RedStone is a modular oracle network that provides real-time data feeds to smart contracts through a unique approach called "data-on-demand". Instead of constantly pushing data to the blockchain, RedStone delivers signed data packages directly to smart contracts at the time of transaction execution. This architecture significantly reduces gas costs while maintaining high data freshness and reliability.

## What You'll Be Doing in This Guide

In this tutorial, you'll learn how to:

1. Integrate RedStone's data feeds into your application on the SEI network
2. Retrieve real-time SEI token price data using RedStone's SDK and data packages
3. Understand RedStone's unique "data-on-demand" architecture
4. Implement fetching and data verification

By the end of this guide, you'll have a working demo that can fetch SEI price data from RedStone's oracle network using their data package system.

## Prerequisites

Before starting this tutorial, ensure you have:

### Technical Requirements

* **Solidity Knowledge**: Basic understanding of Solidity smart contract development
* **JavaScript/Node.js**: For off-chain data fetching using RedStone SDK
* **Development Environment**: Remix IDE, Hardhat, or similar Solidity development setup
* **SEI Network Access**: RPC endpoint and mainnet access for SEI

### Required Dependencies

* RedStone SDK (`@redstone-finance/sdk`)
* RedStone EVM Connector (`@redstone-finance/evm-connector`)

#### Install

```bash theme={"dark"}
# npm
npm install @redstone-finance/sdk @redstone-finance/evm-connector

# yarn
yarn add @redstone-finance/sdk @redstone-finance/evm-connector

# pnpm
pnpm add @redstone-finance/sdk @redstone-finance/evm-connector
```

### SEI Network Configuration

Make sure your development environment is configured for SEI:

* **Mainnet RPC**: `https://evm-rpc.sei-apis.com`
* **Chain ID**: 1329 (mainnet)

## RedStone Architecture Overview

RedStone uses a unique "data-on-demand" model:

1. **Data Providers**: Collect data from multiple sources and sign data packages
2. **Data Packages**: Signed data structures containing price information and metadata
3. **Gateway Network**: Distributes data packages to consumers
4. **Smart Contracts**: Verify signatures and extract data on-chain

## Steps to Fetch SEI Price Data

Let's implement the JavaScript code to fetch SEI price data using RedStone's SDK:

```javascript theme={"dark"}
import { requestDataPackages, getSignersForDataServiceId } from '@redstone-finance/sdk';

async function fetchSEIPrice() {
  try {
    // Fetch data packages from RedStone DDL based on provided configuration
    const dataPackages = await requestDataPackages({
      // For production environment, "redstone-primary-prod" is the standard service
      dataServiceId: 'redstone-primary-prod',

      // Array of tokens to fetch - we're requesting SEI price data
      dataPackagesIds: ['SEI'],

      // Ensure minimum number of signers for each token
      // 'uniqueSignersCount' packages closest to median are returned
      // Throws error if there are fewer signers available
      uniqueSignersCount: 3,

      // (Optional) Wait time for gateway responses in milliseconds
      // Default: 500ms, here we set it to 1000ms for better reliability
      waitForAllGatewaysTimeMs: 1000,

      // (Optional) Filter out packages older than specified time
      // Here we accept packages up to 60 seconds old
      maxTimestampDeviationMS: 60 * 1000,

      // (Optional) Accept packages only from authorized signers
      // This provides additional security against man-in-the-middle attacks
      authorizedSigners: getSignersForDataServiceId('redstone-primary-prod'),

      // (Optional) Don't throw error for missing feeds
      // Useful when requesting multiple tokens where some might be unavailable
      ignoreMissingFeed: true
    });

    // Extract SEI price from the data package
    const seiPrice = dataPackages['SEI'][0].dataPackage.dataPoints[0]?.numericDataPointArgs.value;

    console.log('SEI price:', seiPrice);
    console.log('Full data package:', dataPackages['SEI'][0]);

    return {
      price: seiPrice,
      timestamp: dataPackages['SEI'][0].dataPackage.timestampMilliseconds,
      dataPackage: dataPackages['SEI'][0]
    };
  } catch (error) {
    console.error('Error fetching SEI price:', error);
    throw error;
  }
}

// Usage example
fetchSEIPrice()
  .then((result) => {
    console.log(`SEI Price: $${result.price}`);
    console.log(`Last Updated: ${new Date(result.timestamp)}`);
  })
  .catch((error) => {
    console.error('Failed to fetch price:', error);
  });
```

### Data Package Structure

A RedStone data package contains:

* **dataPoints**: Array of price data points
* **timestampMilliseconds**: When the data was signed
* **signature**: Cryptographic signature from the data provider
* **dataPackageId**: Identifier for the specific data feed (e.g., "SEI")

## Resources

* [RedStone Documentation](https://docs.redstone.finance/)
* [RedStone GitHub Repository](https://github.com/redstone-finance)

---

URL: https://docs.sei.io/evm/oracles/api3

# API3

> Complete guide to integrating API3 with Sei

API3 is a decentralized oracle network that provides real-time data feeds to smart contracts. Unlike traditional oracles that rely on third-party intermediaries, API3 connects APIs directly to the blockchain through first-party oracles operated by the API providers themselves. This approach reduces trust assumptions and potential points of failure.

## What You'll Be Doing in This Guide

In this tutorial, you'll learn how to:

1. Integrate API3's data feeds into your smart contract on the SEI network
2. Retrieve real-time SEI token price data using API3's proxy contract
3. Understand the structure of API3's reader proxy interface
4. Deploy and test your integration on SEI

By the end of this guide, you'll have a working smart contract that can fetch SEI price data from API3's decentralized oracle network.

## Prerequisites

Before starting this tutorial, ensure you have:

### Technical Requirements

* **Solidity Knowledge**: Basic understanding of Solidity smart contract development
* **Development Environment**: Remix IDE, Hardhat, or similar Solidity development setup
* **SEI Network Access**: RPC endpoint and mainnet access for SEI

### Required Dependencies

* OpenZeppelin Contracts library (`@openzeppelin/contracts`)
* API3 Contracts library (`@api3/contracts`)

#### Install

```bash theme={"dark"}
# npm
npm install @openzeppelin/contracts @api3/contracts

# yarn
yarn add @openzeppelin/contracts @api3/contracts

# pnpm
pnpm add @openzeppelin/contracts @api3/contracts
```

### SEI Network Configuration

Make sure your development environment is configured for SEI:

* **Mainnet RPC**: `https://evm-rpc.sei-apis.com`
* **Chain ID**: 1329 (mainnet)

## Contract Code

Here's the complete smart contract code for integrating with API3 to read SEI price data:

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@api3/contracts/interfaces/IApi3ReaderProxy.sol";

contract DataFeedReaderExample is Ownable {
    // This contract reads from a single proxy. Your contract can read from
    // multiple proxies.
    address public proxy;

    constructor(address proxy_) Ownable(msg.sender) {
        setProxy(proxy_);

    }

    // Updating the proxy address is a security-critical action. In this
    // example, only the owner is allowed to do so.
    // You may want to update your proxy to switch to another data feed, enable
    // OEV support, or even switch to another oracle solution. Implementing a
    // method to update proxies is highly recommended.
    function setProxy(address proxy_) public onlyOwner {
        proxy = proxy_;
    }

    function readDataFeed()
        public
        view
        returns (int224 value, uint256 timestamp)
    {
        (value, timestamp) = IApi3ReaderProxy(proxy).read();
        // If you have any assumptions about `value` and `timestamp`, make sure
        // to validate them right after reading from the proxy. For example,
        // if the value you are reading is the spot price of an asset, you may
        // want to reject non-positive values...
        require(value > 0, "Value not positive");
        // ...and if the data feed is being updated with a one day-heartbeat
        // interval, you may want to check for that.
        require(
            timestamp + 1 days > block.timestamp,
            "Timestamp older than one day"
        );
        // After validation, you can implement your contract logic here.

        // Refer to https://docs.api3.org/dapps/integration/contract-integration.html
        // for more information about how to integrate your contract securely.
    }
}
```

### Contract Breakdown

**Key Components:**

1. **Proxy Address**: The contract stores the API3 proxy address that provides SEI price data
2. **Data Validation**: The contract validates that price values are positive and timestamps are recent
3. **IApi3ReaderProxy Interface**: This interface provides the `read()` function to fetch price data

**The `readDataFeed()` Function:**

* Returns `int224 value`: The SEI price (likely in USD with 18 decimal places)
* Returns `uint256 timestamp`: When the price was last updated
* Validates data freshness (within 1 day)
* Ensures price is positive

## Proxy Address

For this tutorial, we'll be using the following API3 proxy address on SEI:

[`0x09c6e594DE2EB633902f00B87A43b27F80a31a60`](https://seiscan.io/address/0x09c6e594DE2EB633902f00B87A43b27F80a31a60)

This proxy provides real-time [SEI/USD](https://market.api3.org/sei/sei-usd/integrate) price data from API3's decentralized oracle network.

## How to Test

### 1. Deploy the Contract

**Using Remix IDE:**

1. Open [Remix IDE](https://remix.ethereum.org/)
2. Create a new file called `DataFeedReaderExample.sol`
3. Paste the contract code above
4. Compile the contract using Solidity compiler ^0.8.0
5. Deploy with constructor parameter: `0x09c6e594DE2EB633902f00B87A43b27F80a31a60`

**Using Hardhat:**

```javascript theme={"dark"}
const proxy = '0x09c6e594DE2EB633902f00B87A43b27F80a31a60';
const DataFeedReader = await ethers.getContractFactory('DataFeedReaderExample');
const reader = await DataFeedReader.deploy(proxy);
await reader.deployed();
```

### 2. Read Price Data

After deployment, call the `readDataFeed()` function to retrieve the current SEI price:

```javascript theme={"dark"}
// Using ethers.js
const result = await reader.readDataFeed();
console.log('SEI Price:', ethers.utils.formatUnits(result.value, 18));
console.log('Last Updated:', new Date(result.timestamp * 1000));
```

**Expected Output Format:**

* `value`: SEI price in USD (with 18 decimals, e.g., `300000000000000000` = \$0.3)
* `timestamp`: Unix timestamp of the last price update

### 3. Integration Examples

**Basic Price Display:**

```solidity theme={"dark"}
function getSEIPrice() external view returns (int224 value) {
    (value, ) = readDataFeed();
    // `value` has 18 decimals, e.g. 300000000000000000 = $0.30.
    // Divide by 1e18 off-chain (or scale on-chain) to get the dollar price.
}
```

---

URL: https://docs.sei.io/evm/oracles/pyth-network

# Pyth Network

> Complete guide to integrating Pyth Network with Sei

Pyth Network is a first-party oracle solution that provides high-fidelity, low-latency financial market data on-chain. Unlike traditional push-based oracles, Pyth uses a unique "pull" model where applications retrieve signed price updates on-demand, significantly reducing gas costs while maintaining data freshness. With over 400+ price feeds across cryptocurrencies, equities, FX, and commodities, Pyth aggregates data directly from 120+ institutional data publishers including major exchanges and trading firms.

## What You'll Be Doing in This Guide

In this tutorial, you'll learn how to:

1. Integrate Pyth Network's pull-based oracle system into your Sei EVM application
2. Fetch real-time SEI token price data using Pyth's JavaScript SDK
3. Create a smart contract that consumes Pyth price feeds with proper price update mechanisms
4. Understand Pyth's on-demand architecture and implement efficient price fetching strategies

By the end of this guide, you'll have a working demo that can fetch and utilize Sei price data from Pyth Network's oracle system with proper on-chain verification.

## Prerequisites

Before starting this tutorial, ensure you have:

### Technical Requirements

* **Solidity Knowledge**: Basic understanding of Solidity smart contract development
* **JavaScript/Node.js**: For off-chain price data fetching using Pyth EVM SDK
* **Development Environment**: Remix IDE, Hardhat, Foundry, or similar Solidity development setup
* **Sei Network Access**: RPC endpoint and familiarity with Sei's EVM environment

### Required Dependencies

* Pyth EVM JavaScript SDK (`@pythnetwork/pyth-evm-js`)
* Pyth Solidity SDK (`@pythnetwork/pyth-sdk-solidity`)

#### Install

```bash theme={"dark"}
# npm
npm install @pythnetwork/pyth-evm-js @pythnetwork/pyth-sdk-solidity

# yarn
yarn add @pythnetwork/pyth-evm-js @pythnetwork/pyth-sdk-solidity

# pnpm
pnpm add @pythnetwork/pyth-evm-js @pythnetwork/pyth-sdk-solidity
```

### Sei Network Configuration

Make sure your development environment is configured for Sei:

* **Mainnet RPC**: `https://evm-rpc.sei-apis.com`
* **Chain ID**: 1329 (mainnet)
* **Testnet RPC**: `https://evm-rpc-testnet.sei-apis.com`
* **Testnet Chain ID**: 1328 (testnet)

## Pyth Architecture Overview

Pyth's pull-based oracle model consists of:

1. **Publishers**: 120+ institutional data providers that sign and submit price data to Pythnet
2. **Pythnet**: Dedicated blockchain that aggregates publisher data using a stake-weighted algorithm
3. **Hermes**: Off-chain price service that provides signed price update messages
4. **Target Chains**: EVM networks (like Sei) where applications consume price data on-demand
5. **Price Update Mechanism**: Users submit price update data alongside their transactions

## Steps to Integrate Pyth Price Feeds

### Step 1: Smart Contract Integration

Create a smart contract that integrates with Pyth's on-chain price feeds:

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@pythnetwork/pyth-sdk-solidity/IPyth.sol";
import "@pythnetwork/pyth-sdk-solidity/PythStructs.sol";

contract SeiPythPriceDemo {
    IPyth pyth;

    // SEI/USD price feed ID
    bytes32 constant SEI_USD_PRICE_FEED_ID = 0x53614f1cb0c031d4af66c04cb9c756234adad0e1cee85303795091499a4084eb;

    constructor(address pythContract) {
        pyth = IPyth(pythContract);
    }

    /**
     * @notice Get the latest SEI/USD price with required price update
     * @param priceUpdateData Price update data from Pyth Hermes API
     * @return price The current SEI price with confidence interval
     */
    function getSeiPrice(bytes[] calldata priceUpdateData)
        external
        payable
        returns (PythStructs.Price memory)
    {
        // Get the required fee for updating the price feeds
        uint fee = pyth.getUpdateFee(priceUpdateData);

        // Update the price feeds with the provided data (requires fee payment)
        pyth.updatePriceFeeds{value: fee}(priceUpdateData);

        // Fetch and return the updated SEI price
        return pyth.getPriceNoOlderThan(SEI_USD_PRICE_FEED_ID, 60);
    }

    /**
     * @notice Get SEI price without updating (uses last known price)
     * @return price The last known SEI price
     */
    function getLatestSeiPrice() external view returns (PythStructs.Price memory) {
        return pyth.getPriceNoOlderThan(SEI_USD_PRICE_FEED_ID, 60);
    }

    /**
     * @notice Check if the price data is fresh enough for usage
     * @param maxAge Maximum age of price data in seconds
     * @return bool True if price is fresh enough
     */
    function isPriceFresh(uint maxAge) external view returns (bool) {
        PythStructs.Price memory price = pyth.getPriceNoOlderThan(SEI_USD_PRICE_FEED_ID, 1000);

        return (block.timestamp - price.publishTime) <= maxAge;
    }

    /**
     * @notice Get the fee required for price update
     * @param priceUpdateData Price update data
     * @return fee The required fee amount
     */
    function getUpdateFee(bytes[] calldata priceUpdateData) external view returns (uint fee) {
        return pyth.getUpdateFee(priceUpdateData);
    }

    receive() external payable { }
}
```

You can fetch Price Feeds at [docs](https://docs.pyth.network/price-feeds/core/price-feeds/price-feed-ids?search=sei\&pageSize=50).

Deploy the contract using [Remix](https://remix.ethereum.org/) with the constructor arguments set to the Pyth contract address on Sei:

* **Sei Mainnet/Testnet Pyth Contract**: [0x2880aB155794e7179c9eE2e38200202908C17B43](https://docs.pyth.network/price-feeds/core/contract-addresses/evm)

### Step 2: JavaScript Integration for Price Updates

Create a module to fetch price updates directly from Pyth's Hermes API and interact with your deployed contract:

```javascript theme={"dark"}
const ethers = require('ethers');
const dotenv = require('dotenv');
dotenv.config();

/**
 * Fetch SEI price update data from Pyth Hermes API
 * @returns {Object} Price update data from Hermes
 */
async function fetchSeiPriceUpdateData() {
  const seiPriceId = '0x53614f1cb0c031d4af66c04cb9c756234adad0e1cee85303795091499a4084eb'; // SEI/USD Price Feed ID
  const hermesUrl = `https://hermes.pyth.network/v2/updates/price/latest?ids%5B%5D=${seiPriceId}`;

  try {
    console.log('Fetching SEI price data from Hermes...');
    const response = await fetch(hermesUrl, {
      method: 'GET',
      headers: {
        accept: 'application/json'
      }
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    console.log('Hermes API Response:', JSON.stringify(data, null, 2));

    // Extract the binary data array for contract submission
    const binaryData = data.binary.data;
    console.log('Binary data for contract:', binaryData);

    // Extract parsed price info for logging
    const priceInfo = data.parsed[0];
    console.log('Current SEI Price Info:');
    console.log(`- Price: ${priceInfo.price.price} (expo: ${priceInfo.price.expo})`);
    console.log(`- Formatted Price: ${(priceInfo.price.price * Math.pow(10, priceInfo.price.expo)).toFixed(6)}`);
    console.log(`- Confidence: ${priceInfo.price.conf}`);
    console.log(`- Publish Time: ${new Date(priceInfo.price.publish_time * 1000)}`);

    return {
      binaryData,
      priceInfo
    };
  } catch (error) {
    console.error('Error fetching SEI price data:', error);
    throw error;
  }
}

/**
 * Update SEI price on smart contract and query the result
 * @param {string} contractAddress Deployed contract address
 * @param {string} privateKey Wallet private key
 * @param {string} rpcUrl RPC endpoint URL
 */
async function updateAndQuerySeiPrice(contractAddress, privateKey, rpcUrl = 'https://evm-rpc.sei-apis.com') {
  try {
    // Setup provider and wallet
    const provider = new ethers.JsonRpcProvider(rpcUrl);
    const wallet = new ethers.Wallet(privateKey, provider);

    // Contract ABI
    const contractAbi = ['function getSeiPrice(bytes[] calldata priceUpdateData) external payable returns (tuple(int64 price, uint64 conf, int32 expo, uint256 publishTime))', 'function getLatestSeiPrice() external view returns (tuple(int64 price, uint64 conf, int32 expo, uint256 publishTime))', 'function isPriceFresh(uint256 maxAge) external view returns (bool)', 'function getUpdateFee(bytes[] calldata priceUpdateData) external view returns (uint256)', 'receive() external payable'];

    const contract = new ethers.Contract(contractAddress, contractAbi, wallet);
    const seiPriceId = '0x53614f1cb0c031d4af66c04cb9c756234adad0e1cee85303795091499a4084eb';

    // Step 1: Fetch price update data from Hermes
    const { binaryData, priceInfo } = await fetchSeiPriceUpdateData();

    // Step 2: Convert binary data to bytes array format
    const priceUpdateData = binaryData.map((hexData) => `0x${hexData}`);

    console.log('Sending Fee Data', priceUpdateData);

    // Step 3: Get update fee (should be small)
    console.log('\nGetting update fee...');
    const updateFee = await contract.getUpdateFee(priceUpdateData);
    console.log(`Update fee: ${ethers.formatEther(updateFee)} SEI`);

    // Step 4: Update price on contract with 1 SEI (as requested)
    console.log('\nUpdating price on smart contract...');
    const tx = await contract.getSeiPrice(priceUpdateData, {
      value: updateFee
    });

    console.log(`Transaction submitted: ${tx.hash}`);
    const receipt = await tx.wait();
    console.log(`✅ Transaction confirmed in block: ${receipt.blockNumber}`);

    // Reads the last known price (the contract enforces a 60-second freshness window)
    const onChainPrice = await contract.getLatestSeiPrice();

    console.log('Onchain Query Raw', onChainPrice);

    // Step 5: Log the results
    console.log('\n📊 On-Chain SEI Price Data:');
    console.log(`- Raw Price: ${onChainPrice.price.toString()}`);
    console.log(`- Confidence: ${onChainPrice.conf.toString()}`);
    console.log(`- Exponent: ${onChainPrice.expo.toString()}`);
    console.log(`- Publish Time: ${new Date(parseInt(onChainPrice.publishTime.toString()) * 1000)}`);

    // Format the price properly
    const formattedPrice = (parseInt(onChainPrice.price.toString()) * Math.pow(10, parseInt(onChainPrice.expo.toString()))).toFixed(6);
    console.log(`- Formatted Price: ${formattedPrice}`);

    return {
      txHash: receipt.hash,
      blockNumber: receipt.blockNumber,
      price: formattedPrice,
      rawPrice: onChainPrice
    };
  } catch (error) {
    console.error('❌ Error in price update process:', error);
    throw error;
  }
}

/**
 * Complete demonstration function
 */
async function demonstrateSeiPriceIntegration() {
  // Configuration
  const contractAddress = process.env.CONTRACT_ADDRESS;
  const privateKey = process.env.PRIVATE_KEY;
  const rpcUrl = 'https://evm-rpc.sei-apis.com';

  console.log('🚀 Starting SEI-Pyth integration demo...');
  console.log(`📍 Contract Address: ${contractAddress}`);
  console.log(`🌐 RPC URL: ${rpcUrl}\n`);

  try {
    const result = await updateAndQuerySeiPrice(contractAddress, privateKey, rpcUrl);

    console.log('\n🎉 Demo completed successfully!');
    console.log(`📋 Summary:`);
    console.log(`   - Transaction: ${result.txHash}`);
    console.log(`   - Block: ${result.blockNumber}`);
    console.log(`   - Final SEI Price: ${result.price}`);
  } catch (error) {
    console.error('❌ Demo failed:', error.message);
  }
}

// Export functions for use in other modules
module.exports = {
  fetchSeiPriceUpdateData,
  updateAndQuerySeiPrice,
  demonstrateSeiPriceIntegration
};

// Run demo if this file is executed directly
if (require.main === module) {
  demonstrateSeiPriceIntegration();
}
```

### Step 3: Complete Integration Example

Here's a simple usage example that puts it all together:

```javascript theme={"dark"}
// demo.js - Simple demonstration script
import { demonstrateSeiPriceIntegration } from './SeiPythIntegration.js';

// Set your environment variables or update these values
process.env.PRIVATE_KEY = 'your_private_key_here';
process.env.CONTRACT_ADDRESS = 'your_deployed_contract_address';

// Run the complete demo
demonstrateSeiPriceIntegration()
  .then(() => {
    console.log('🎯 Integration demo completed successfully!');
  })
  .catch((error) => {
    console.error('❌ Demo failed:', error);
  });
```

### Expected Output

When you run the integration, you should see output similar to:

```
🚀 Starting SEI-Pyth integration demo...
📍 Contract Address: 0x1234...
🌐 RPC URL: https://evm-rpc.sei-apis.com

Fetching SEI price data from Hermes...
Hermes API Response: {
  "binary": {
    "encoding": "hex",
    "data": [
      "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"
    ]
  },
  "parsed": [
    {
      "id": "53614f1cb0c031d4af66c04cb9c756234adad0e1cee85303795091499a4084eb",
      "price": {
        "price": "13286938",
        "conf": "16077",
        "expo": -8,
        "publish_time": 1765544775
      },
      "ema_price": {
        "price": "13222042",
        "conf": "17178",
        "expo": -8,
        "publish_time": 1765544775
      }
    }
  ]
}

Current SEI Price Info:
- Price: 13286938 (expo: -8)
- Formatted Price: $0.132869
- Confidence: 16077
- Publish Time: Thu Dec 12 2024 10:52:55 GMT+0000

Getting update fee...
Update fee: 0.000000000000001 SEI

Updating price on smart contract...
Transaction submitted: 0xabc123...
✅ Transaction confirmed in block: 12345678

Querying updated price with 120 second time limit...

📊 On-Chain SEI Price Data:
- Raw Price: 13286938
- Confidence: 16077
- Exponent: -8
- Publish Time: Thu Dec 12 2024 10:52:55 GMT+0000
- Formatted Price: $0.132869

🎉 Demo completed successfully!
📋 Summary:
   - Transaction: 0xabc123...
   - Block: 12345678
   - Final SEI Price: $0.132869
```

### Data Structure Details

Pyth price data includes several important fields:

* **price**: The asset price (scaled by `expo`)
* **conf**: Confidence interval (±range around the price)
* **expo**: The exponent for scaling the price (e.g., -6 means divide by 1,000,000)
* **publishTime**: Unix timestamp when the price was last updated

### Fee Structure

* **Update Fee**: Small fee paid in native token (SEI) to submit price update data
* **Variable Cost**: Fee depends on the number of price feeds being updated
* **Gas Efficiency**: Pull model is more gas-efficient than traditional push oracles

## Best Practices

1. **Price Freshness**: Always check price age before using in critical applications
2. **Confidence Intervals**: Consider the confidence interval for risk management
3. **Fee Management**: Monitor update fees and optimize update frequency
4. **Error Handling**: Implement robust error handling for price update failures

## Resources

* [Pyth Network Documentation](https://docs.pyth.network/)
* [Pyth Price Feed IDs](https://docs.pyth.network/price-feeds/core/price-feeds/price-feed-ids?search=sei\&pageSize=50)
* [Pyth EVM SDK GitHub](https://github.com/pyth-network/pyth-crosschain)
* [Hermes Price Service API](https://api-reference.pyth.network/price-feeds/evm)

---

URL: https://docs.sei.io/evm/vrf/pyth-network-vrf

# Pyth Network VRF Integration

> Complete guide to integrating Pyth Network VRF with Sei Network

Pyth Entropy is an on-chain random number generator (RNG) that provides cryptographically secure, verifiable randomness for blockchain applications. Entropy uses a two-party commit-reveal protocol, a well-known protocol in the cryptography space for generating a random number, offering lower fees, direct integration with Pyth Network, scalability, and faster response times compared to traditional VRF solutions. Entropy delivers randomness that is trustless, low-latency, cost-efficient, and requires no registration.

## What You'll Be Doing in This Guide

In this tutorial, you'll learn how to:

1. Integrate Pyth Entropy's commit-reveal randomness system into your Sei EVM application
2. Create smart contracts that request and consume verifiable random numbers using the Entropy protocol
3. Implement a complete gaming application with fair, transparent randomness
4. Handle fees, callbacks, and error management for production-ready randomness

By the end of this guide, you'll have a working demo that can request cryptographically secure random numbers on the Sei network with proper verification mechanisms using Pyth Entropy.

## Prerequisites

Before starting this tutorial, ensure you have:

### Technical Requirements

* **Solidity Knowledge**: Basic understanding of Solidity smart contract development
* **JavaScript/Node.js**: For off-chain interaction and frontend integration
* **Development Environment**: Remix IDE, Hardhat, Foundry, or similar Solidity development setup
* **Sei Network Access**: RPC endpoint and familiarity with Sei's EVM environment
* **Native Tokens**: SEI tokens required for paying Entropy request fees

### Required Dependencies

* Pyth Entropy Solidity SDK (`@pythnetwork/entropy-sdk-solidity`)

#### Install

```bash theme={"dark"}
# npm
npm install @pythnetwork/entropy-sdk-solidity

# yarn
yarn add @pythnetwork/entropy-sdk-solidity

# pnpm
pnpm add @pythnetwork/entropy-sdk-solidity
```

### Sei Network Configuration

Make sure your development environment is configured for Sei:

* **Mainnet RPC**: `https://evm-rpc.sei-apis.com`
* **Chain ID**: 1329 (mainnet)
* **Testnet RPC**: `https://evm-rpc-testnet.sei-apis.com`
* **Testnet Chain ID**: 1328 (testnet)

## Pyth Entropy Architecture Overview

Entropy uses a two-party commit-reveal protocol consisting of:

1. **Entropy Provider**: Off-chain service that commits to a sequence of random numbers using hash chains
2. **User Commitment**: Users contribute their own random input to ensure unpredictability
3. **Commit-Reveal Protocol**: Two-party system where both parties contribute to final randomness
4. **On-Chain Verification**: Smart contracts verify the randomness proofs and execute callbacks
5. **Keeper Network**: Decentralized bots that fulfill randomness requests by revealing provider commitments

## Key Concepts

Before implementing, it's important to understand the key aspects of working with Pyth Entropy:

### Two-Phase Process

Entropy uses a two-phase approach:

* **Request Phase**: Your contract calls `entropy.requestV2()` and receives a `sequenceNumber`
* **Fulfillment Phase**: Off-chain keepers fulfill the request by calling your contract's `entropyCallback()` method

### Asynchronous Nature

Unlike synchronous random number generation, Entropy requests are asynchronous:

* The random number is not available immediately after the request
* Your application must handle the waiting period (typically 1-3 blocks)
* Use events and polling to know when randomness is fulfilled

### Fee Management

Entropy requires payment for each randomness request:

* Always call `getFeeV2()` to get the current fee before making requests
* Fees are paid in the native token (SEI) as `msg.value`
* Fees are dynamic and may change based on network conditions

### Callback Implementation

Your contract must implement the `entropyCallback` function:

* This method is called automatically when randomness is fulfilled
* It receives the `sequenceNumber`, `providerAddress`, and `randomNumber`
* All your game logic should be handled in this callback

### Sequence Number Tracking

Each request has a unique `sequenceNumber`:

* Use this to map requests to your application state
* Store game/request data using the sequence number as the key
* Multiple requests can be pending simultaneously

### Error Handling

Always implement proper error handling:

* Requests can fail or timeout
* Network issues may prevent fulfillment
* Have fallback mechanisms for failed requests

### Gas Considerations

The callback execution has gas limits:

* Keep callback logic simple to avoid out-of-gas errors
* For complex logic, consider using custom gas limits with `requestV2` variants
* Store expensive computations for later execution

## Steps to Integrate Pyth Entropy into Sei

### Step 1: Smart Contract Integration

Create a consumer contract that integrates with Pyth Entropy:

```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import "@pythnetwork/entropy-sdk-solidity/IEntropyV2.sol";
import "@pythnetwork/entropy-sdk-solidity/IEntropyConsumer.sol";

contract SeiEntropyDemo is IEntropyConsumer {
    // Entropy configuration
    IEntropyV2 entropy;

    // Game state
    struct DiceGame {
        address player;
        uint256 betAmount;
        uint256 targetNumber;
        bool fulfilled;
        bool won;
        uint256 diceRoll;
        uint256 timestamp;
    }

    mapping(uint64 => DiceGame) public games;
    mapping(address => uint256) public playerBalances;
    uint256 public gameCounter;

    // Events
    event GameRequested(uint64 indexed sequenceNumber, address indexed player, uint256 betAmount, uint256 targetNumber);
    event GameResolved(uint64 indexed sequenceNumber, address indexed player, bool won, uint256 diceRoll);
    event RandomnessRequested(uint64 indexed sequenceNumber);
    event RandomnessFulfilled(uint64 indexed sequenceNumber, bytes32 randomNumber);

    constructor(address _entropy) {
        entropy = IEntropyV2(_entropy);
    }

    // This method is required by the IEntropyConsumer interface
    function getEntropy() internal view override returns (address) {
        return address(entropy);
    }

    /**
     * @notice Start a new dice game with Entropy randomness
     * @param targetNumber The number to roll (1-6) to win
     */
    function playDiceGame(uint256 targetNumber) external payable returns (uint64 sequenceNumber) {
        require(targetNumber >= 1 && targetNumber <= 6, "Target must be 1-6");

        // Get fee for entropy request
        uint128 requestFee = entropy.getFeeV2();
        require(msg.value >= requestFee, "Insufficient fee for randomness");

        // Calculate bet amount (total payment minus entropy fee)
        uint256 betAmount = msg.value - requestFee;
        require(betAmount > 0, "Must send more than just the entropy fee");

        // Store player balance
        playerBalances[msg.sender] += betAmount;

        // Request randomness from Entropy (V2 doesn't require user random number)
        sequenceNumber = entropy.requestV2{value: requestFee}();

        // Store game session
        games[sequenceNumber] = DiceGame({
            player: msg.sender,
            betAmount: betAmount,
            targetNumber: targetNumber,
            fulfilled: false,
            won: false,
            diceRoll: 0,
            timestamp: block.timestamp
        });

        gameCounter++;

        emit GameRequested(sequenceNumber, msg.sender, betAmount, targetNumber);
        emit RandomnessRequested(sequenceNumber);

        return sequenceNumber;
    }

    /**
     * @notice Callback function used by Entropy when randomness is fulfilled
     * @param sequenceNumber The sequence number of the request
     * @param providerAddress The randomness provider address
     * @param randomNumber The generated random number
     */
    function entropyCallback(
        uint64 sequenceNumber,
        address providerAddress,
        bytes32 randomNumber
    ) internal override {
        DiceGame storage game = games[sequenceNumber];
        require(game.player != address(0), "Game not found");
        require(!game.fulfilled, "Game already fulfilled");

        game.fulfilled = true;

        // Convert random number to dice roll (1-6)
        uint256 diceRoll = (uint256(randomNumber) % 6) + 1;
        game.diceRoll = diceRoll;

        // Determine if player won
        bool won = diceRoll == game.targetNumber;
        game.won = won;

        if (won) {
            // Player wins 5x their bet
            uint256 winnings = game.betAmount * 5;
            playerBalances[game.player] += winnings;
        }

        emit RandomnessFulfilled(sequenceNumber, randomNumber);
        emit GameResolved(sequenceNumber, game.player, won, diceRoll);
    }

    /**
     * @notice Get game details by sequence number
     * @param sequenceNumber The Entropy sequence number
     * @return Game session details
     */
    function getGameDetails(uint64 sequenceNumber) external view returns (DiceGame memory) {
        return games[sequenceNumber];
    }

    /**
     * @notice Check if randomness has been fulfilled for a request
     * @param sequenceNumber The Entropy sequence number
     * @return True if randomness has been fulfilled
     */
    function isRequestFulfilled(uint64 sequenceNumber) external view returns (bool) {
        return games[sequenceNumber].fulfilled;
    }

    /**
     * @notice Get player's current balance
     * @param player Player address
     * @return Current balance
     */
    function getPlayerBalance(address player) external view returns (uint256) {
        return playerBalances[player];
    }

    /**
     * @notice Withdraw player balance
     */
    function withdraw() external {
        uint256 balance = playerBalances[msg.sender];
        require(balance > 0, "No balance to withdraw");

        playerBalances[msg.sender] = 0;
        payable(msg.sender).transfer(balance);
    }

    /**
     * @notice Get the current fee for entropy requests
     * @return fee The current fee amount in wei
     */
    function getEntropyFee() external view returns (uint128) {
        return entropy.getFeeV2();
    }

    /**
     * @notice Play multiple dice games in batch
     * @param targetNumbers Array of target numbers
     */
    function playMultipleDiceGames(
        uint256[] calldata targetNumbers
    ) external payable returns (uint64[] memory sequenceNumbers) {
        require(targetNumbers.length > 0 && targetNumbers.length <= 10, "Invalid array length");

        uint128 requestFee = entropy.getFeeV2();
        uint256 totalFee = uint256(requestFee) * targetNumbers.length;
        require(msg.value >= totalFee, "Insufficient fee for batch randomness");

        uint256 betPerGame = (msg.value - totalFee) / targetNumbers.length;
        require(betPerGame > 0, "Insufficient funds for bets");

        sequenceNumbers = new uint64[](targetNumbers.length);

        for (uint i = 0; i < targetNumbers.length; i++) {
            require(targetNumbers[i] >= 1 && targetNumbers[i] <= 6, "Target must be 1-6");

            playerBalances[msg.sender] += betPerGame;

            uint64 sequenceNumber = entropy.requestV2{value: requestFee}();

            games[sequenceNumber] = DiceGame({
                player: msg.sender,
                betAmount: betPerGame,
                targetNumber: targetNumbers[i],
                fulfilled: false,
                won: false,
                diceRoll: 0,
                timestamp: block.timestamp
            });

            sequenceNumbers[i] = sequenceNumber;
            gameCounter++;

            emit GameRequested(sequenceNumber, msg.sender, betPerGame, targetNumbers[i]);
            emit RandomnessRequested(sequenceNumber);
        }

        return sequenceNumbers;
    }

    receive() external payable {}
}
```

Deploy this contract using [Remix](https://remix.ethereum.org/) with the Entropy contract address for your target network:

| Network         | Entropy Contract Address                                                                    |
| --------------- | ------------------------------------------------------------------------------------------- |
| **Sei Mainnet** | [`0x98046bd286715d3b0bc227dd7a956b83d8978603`](https://docs.pyth.network/entropy/chainlist) |
| **Sei Testnet** | [`0x36825bf3fbdf5a29e2d5148bfe7dcf7b5639e320`](https://docs.pyth.network/entropy/chainlist) |

Note: Entropy V2 uses a default provider system, so you no longer need to specify a provider address in the constructor.

### Step 2: JavaScript Integration for Entropy Management

Create a module to interact with Entropy and manage randomness requests:

Note: The JavaScript examples below use CommonJS (`require`/`module.exports`). If your project uses `"type": "module"`, rename these files to `.cjs` or convert the snippets to ES Modules.

```javascript theme={"dark"}
const { ethers } = require('ethers');
const dotenv = require('dotenv');

dotenv.config();

// Contract ABI (simplified for key functions)
const ENTROPY_DEMO_ABI = ['function playDiceGame(uint256 targetNumber) external payable returns (uint64)', 'function getGameDetails(uint64 sequenceNumber) external view returns (tuple(address player, uint256 betAmount, uint256 targetNumber, bool fulfilled, bool won, uint256 diceRoll, uint256 timestamp))', 'function isRequestFulfilled(uint64 sequenceNumber) external view returns (bool)', 'function getPlayerBalance(address player) external view returns (uint256)', 'function withdraw() external', 'function getEntropyFee() external view returns (uint128)', 'function gameCounter() external view returns (uint256)', 'event GameRequested(uint64 indexed sequenceNumber, address indexed player, uint256 betAmount, uint256 targetNumber)', 'event GameResolved(uint64 indexed sequenceNumber, address indexed player, bool won, uint256 diceRoll)', 'event RandomnessRequested(uint64 indexed sequenceNumber)', 'event RandomnessFulfilled(uint64 indexed sequenceNumber, bytes32 randomNumber)'];

/**
 * Play a dice game using Pyth Entropy randomness
 * @param {string} contractAddress Deployed Entropy demo contract address
 * @param {string} privateKey Player's private key
 * @param {number} targetNumber Target dice number (1-6)
 * @param {string} betAmount Bet amount in SEI
 * @param {string} rpcUrl RPC endpoint URL
 */
async function playEntropyDiceGame(contractAddress, privateKey, targetNumber, betAmount, rpcUrl = 'https://evm-rpc.sei-apis.com') {
  try {
    console.log('🎲 Starting Pyth Entropy Dice Game...');

    // Setup provider and wallet
    const provider = new ethers.JsonRpcProvider(rpcUrl);
    const wallet = new ethers.Wallet(privateKey, provider);

    // Create contract instance
    const contract = new ethers.Contract(contractAddress, ENTROPY_DEMO_ABI, wallet);

    const balance = await provider.getBalance(wallet.address);
    console.log(`💼 Player Wallet: ${wallet.address} | Balance: ${ethers.formatEther(balance)} SEI`);

    console.log(`🎯 Player: ${wallet.address}`);
    console.log(`💰 Bet Amount: ${betAmount} SEI`);
    console.log(`🎲 Target Number: ${targetNumber}`);

    // Get current entropy fee
    const entropyFee = await contract.getEntropyFee();
    console.log(`⚡ Entropy Fee: ${ethers.formatEther(entropyFee)} SEI`);

    // Check current balance
    const currentBalance = await contract.getPlayerBalance(wallet.address);
    console.log(`💳 Current Contract Balance: ${ethers.formatEther(currentBalance)} SEI`);

    // Calculate total payment (bet + entropy fee)
    const betInWei = ethers.parseEther(betAmount);
    const totalPayment = betInWei + entropyFee;

    console.log('\n🔄 Submitting game transaction...');

    const tx = await contract.playDiceGame(targetNumber, {
      value: totalPayment,
      gasLimit: 300000
    });

    console.log(`📝 Transaction Hash: ${tx.hash}`);

    // Wait for confirmation and get receipt
    const receipt = await tx.wait();
    console.log(`✅ Transaction confirmed in block: ${receipt.blockNumber}`);

    // Extract sequence number from events
    const gameRequestedEvent = receipt.logs.find((log) => {
      try {
        const decoded = contract.interface.parseLog({
          topics: log.topics,
          data: log.data
        });
        return decoded.name === 'GameRequested';
      } catch {
        return false;
      }
    });

    if (!gameRequestedEvent) {
      throw new Error('GameRequested event not found');
    }

    const decodedEvent = contract.interface.parseLog({
      topics: gameRequestedEvent.topics,
      data: gameRequestedEvent.data
    });

    const sequenceNumber = decodedEvent.args[0];
    console.log(`🎟️ Sequence Number: ${sequenceNumber.toString()}`);

    // Wait for Entropy fulfillment
    console.log('\n⏳ Waiting for Entropy fulfillment...');
    await waitForEntropyFulfillment(contract, sequenceNumber);

    // Get final game results
    const gameDetails = await contract.getGameDetails(sequenceNumber);

    console.log('\n🎯 GAME RESULTS:');
    console.log(`🎲 Dice Roll: ${gameDetails.diceRoll}`);
    console.log(`🎯 Target: ${gameDetails.targetNumber}`);
    console.log(`${gameDetails.won ? '🎉 WINNER!' : '💔 Better luck next time!'}`);
    console.log(`💰 Bet Amount: ${ethers.formatEther(gameDetails.betAmount)} SEI`);

    if (gameDetails.won) {
      const winAmount = gameDetails.betAmount * BigInt(5);
      console.log(`💸 Winnings: ${ethers.formatEther(winAmount)} SEI`);
    }

    // Check updated balance
    const newBalance = await contract.getPlayerBalance(wallet.address);
    console.log(`💳 New Balance: ${ethers.formatEther(newBalance)} SEI`);

    return {
      sequenceNumber: sequenceNumber.toString(),
      diceRoll: Number(gameDetails.diceRoll),
      targetNumber: Number(gameDetails.targetNumber),
      won: gameDetails.won,
      txHash: receipt.transactionHash,
      blockNumber: receipt.blockNumber
    };
  } catch (error) {
    console.error('❌ Error playing Entropy dice game:', error.message);
    throw error;
  }
}

/**
 * Wait for Entropy fulfillment with timeout
 * @param {Contract} contract Contract instance
 * @param {BigInt} sequenceNumber Entropy sequence number
 * @param {number} timeoutMs Timeout in milliseconds
 */
async function waitForEntropyFulfillment(contract, sequenceNumber, timeoutMs = 120000) {
  const startTime = Date.now();

  while (Date.now() - startTime < timeoutMs) {
    try {
      const fulfilled = await contract.isRequestFulfilled(sequenceNumber);
      if (fulfilled) {
        console.log('✅ Entropy request fulfilled!');
        return;
      }

      process.stdout.write('.');
      await new Promise((resolve) => setTimeout(resolve, 3000)); // Wait 3 seconds
    } catch (error) {
      console.error('Error checking fulfillment:', error.message);
      await new Promise((resolve) => setTimeout(resolve, 3000));
    }
  }

  throw new Error('Entropy fulfillment timed out');
}

/**
 * Monitor Entropy events in real-time
 * @param {string} contractAddress Contract address
 * @param {string} rpcUrl RPC URL
 */
async function monitorEntropyEvents(contractAddress, rpcUrl = 'https://evm-rpc.sei-apis.com') {
  try {
    console.log('👂 Starting Entropy event monitoring...');

    const provider = new ethers.JsonRpcProvider(rpcUrl);
    const contract = new ethers.Contract(contractAddress, ENTROPY_DEMO_ABI, provider);

    // Listen for game events
    contract.on('GameRequested', (sequenceNumber, player, betAmount, targetNumber) => {
      console.log(`🎮 Game Requested - Sequence: ${sequenceNumber}, Player: ${player}, Target: ${targetNumber}, Bet: ${ethers.formatEther(betAmount)} SEI`);
    });

    contract.on('RandomnessRequested', (sequenceNumber) => {
      console.log(`🔄 Entropy Randomness Requested - Sequence: ${sequenceNumber}`);
    });

    contract.on('RandomnessFulfilled', (sequenceNumber, randomNumber) => {
      console.log(`✅ Entropy Randomness Fulfilled - Sequence: ${sequenceNumber}, Random: ${randomNumber}`);
    });

    contract.on('GameResolved', (sequenceNumber, player, won, diceRoll) => {
      console.log(`🎯 Game Resolved - Sequence: ${sequenceNumber}, Player: ${player}, Won: ${won}, Roll: ${diceRoll}`);
    });

    console.log('✅ Event monitoring active. Press Ctrl+C to stop.');
  } catch (error) {
    console.error('Error monitoring events:', error.message);
    throw error;
  }
}

/**
 * Simple Pyth Entropy demonstration
 */
async function demonstratePythEntropyIntegration() {
  const contractAddress = process.env.CONTRACT_ADDRESS;
  const privateKey = process.env.PRIVATE_KEY;
  const rpcUrl = 'https://evm-rpc.sei-apis.com';

  console.log('🚀 Starting Sei Pyth Entropy Integration Demo...');
  console.log(`📍 Contract Address: ${contractAddress}`);
  console.log(`🌐 RPC URL: ${rpcUrl}\n`);

  try {
    // Play a single dice game
    const result = await playEntropyDiceGame(contractAddress, privateKey, 3, '0.1', rpcUrl);

    console.log('\n🎉 Pyth Entropy Demo completed successfully!');
    console.log(`📋 Game Summary:`);
    console.log(`   - Sequence: ${result.sequenceNumber}`);
    console.log(`   - Target: ${result.targetNumber}, Roll: ${result.diceRoll}`);
    console.log(`   - Result: ${result.won ? 'WON' : 'LOST'}`);
    console.log(`   - Transaction: ${result.txHash}`);
    console.log(`   - Block: ${result.blockNumber}`);
  } catch (error) {
    console.error('❌ Demo failed:', error.message);
  }
}

// Export functions for use in other modules
module.exports = {
  playEntropyDiceGame,
  waitForEntropyFulfillment,
  monitorEntropyEvents,
  demonstratePythEntropyIntegration
};

// Run demo if this file is executed directly
// Usage: node SeiPythEntropyIntegration.js
if (require.main === module) {
  demonstratePythEntropyIntegration();
}
```

### Step 3: Complete Integration Example

Here's a simple usage example that puts it all together:

First, create a `.env` file in your project root (never commit this file):

```bash theme={"dark"}
# .env - NEVER commit this file to version control!
PRIVATE_KEY=your_private_key_here
CONTRACT_ADDRESS=your_deployed_entropy_contract_address
```

Then create the demo script:

```javascript theme={"dark"}
// demo.js - Complete Pyth Entropy demonstration
const { demonstratePythEntropyIntegration, monitorEntropyEvents } = require('./SeiPythEntropyIntegration.js');
const dotenv = require('dotenv');

dotenv.config();

// Validate required environment variables
if (!process.env.PRIVATE_KEY || !process.env.CONTRACT_ADDRESS) {
  console.error('❌ Missing required environment variables!');
  console.error('Please create a .env file with PRIVATE_KEY and CONTRACT_ADDRESS');
  process.exit(1);
}

// Option 1: Run the complete demo
demonstratePythEntropyIntegration()
  .then(() => {
    console.log('🎯 Pyth Entropy integration demo completed successfully!');
  })
  .catch((error) => {
    console.error('❌ Demo failed:', error);
  });

// Option 2: Monitor events in real-time
// monitorEntropyEvents(process.env.CONTRACT_ADDRESS);
```

### Expected Output

To run the complete demo, execute the `demo.js` script:

```bash theme={"dark"}
node demo.js
```

When you run the Pyth Entropy integration, you should see output similar to:

```
🚀 Starting Sei Pyth Entropy Integration Demo...
📍 Contract Address: 0xb879CEabC035CF1ACb95A2A9D679Be633BAa6BD0
🌐 RPC URL: https://evm-rpc.sei-apis.com

🎲 Starting Pyth Entropy Dice Game...
💼 Player Wallet: 0x232d055936450052c3df9B8064b2B56B01c49DEc | Balance: 0.931653993763751675 SEI
🎯 Player: 0x232d055936450052c3df9B8064b2B56B01c49DEc
💰 Bet Amount: 0.1 SEI
🎲 Target Number: 3
⚡ Entropy Fee: 0.050000000000000001 SEI
💳 Current Contract Balance: 1.532691867344799999 SEI

🔄 Submitting game transaction...
📝 Transaction Hash: 0x248d1b2b9fd5df95bc0ac6e67179e7e1c50e0a557c6acb9be790f7e2dacecab4
✅ Transaction confirmed in block: 184783333
🎟️ Sequence Number: 7547

⏳ Waiting for Entropy fulfillment...
.✅ Entropy request fulfilled!

🎯 GAME RESULTS:
🎲 Dice Roll: 4
🎯 Target: 3
💔 Better luck next time!
💰 Bet Amount: 0.1 SEI
💳 New Balance: 1.632691867344799999 SEI

🎉 Pyth Entropy Demo completed successfully!
📋 Game Summary:
   - Sequence: 7547
   - Target: 3, Roll: 4
   - Result: LOST
   - Transaction: 0x248d1b2b9fd5df95bc0ac6e67179e7e1c50e0a557c6acb9be790f7e2dacecab4
   - Block: 184783333
```

### Data Structure Details

Pyth Entropy V2 responses include several important fields:

* **sequenceNumber**: Unique identifier for the randomness request (uint64)
* **randomNumber**: The cryptographically secure random bytes32 value
* **providerAddress**: Address of the entropy provider that fulfilled the request
* **blockNumber**: Block number when the request was fulfilled

### Fee Structure

* **Dynamic Fees**: Always use the on-chain method `entropy.getFeeV2()` to get the current fee
* **Native Token Payment**: Fees are paid in the native blockchain token (SEI)
* **Per-Request Basis**: Each randomness request has its own fee
* **No User Commitment Required**: Entropy V2 simplifies the process by removing the need for user random numbers

## Best Practices

1. **Fee Management**: Always check current fees using `getFeeV2()` before submitting requests
2. **Callback Gas Limits**: Set appropriate gas limits for complex callback logic using Entropy V2's custom gas limit features
3. **Error Handling**: Implement proper timeout and error handling for unfulfilled requests
4. **Sequential Processing**: Handle multiple requests appropriately as they may be fulfilled out of order
5. **Storage Optimization**: Remember that fulfilled randomness is not stored by the contract - save it if needed for multiple uses

## Resources

* [Pyth Entropy Documentation](https://docs.pyth.network/entropy)
* [Entropy Contract Addresses](https://docs.pyth.network/entropy/chainlist)
* [Example Applications](https://github.com/pyth-network/pyth-examples/tree/main/entropy)
* [Entropy Explorer](https://entropy-explorer.pyth.network/)
* [Protocol Design](https://docs.pyth.network/entropy/protocol-design)

---

URL: https://docs.sei.io/evm/transactions

# Transactions

> Comprehensive guide on Transactions on Sei. Learn key concepts, commands, and best practices.

Sei supports EVM transactions, allowing compatibility with Ethereum-based tools and contracts. Transactions are signed messages originating from an externally owned account (EOA) that trigger state changes on the blockchain.

## Transaction Lifecycle

| Stage           | Description                                                                                            |
| --------------- | ------------------------------------------------------------------------------------------------------ |
| 1. Creation     | A transaction is created by an EOA, specifying the recipient, value, gas parameters, and other fields. |
| 2. Signing      | The transaction is signed with the sender's private key to create a valid signature.                   |
| 3. Submission   | The signed transaction is submitted to the network through an RPC endpoint.                            |
| 4. Mempool      | The transaction enters the mempool (transaction pool) where it awaits inclusion in a block.            |
| 5. Execution    | When selected by a validator, the transaction is executed in the EVM, causing state changes.           |
| 6. Validation   | The transaction and its state changes are validated by the consensus mechanism.                        |
| 7. Confirmation | Once validated, the transaction is included in a block and confirmed on-chain.                         |
| 8. Finality     | On Sei, transactions achieve immediate finality once included in a block.                              |

<Info>
  Unlike other EVM chains where you need to wait for multiple confirmations, Sei's consensus mechanism provides immediate transaction finality. Once a transaction is included in a block, it cannot be reversed.
</Info>

## Gas Mechanics

Gas is a unit of computational work in the EVM that helps prevent spam and allocate resources efficiently:

| Term                | Description                                                                                                               |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| Gas Limit           | The maximum amount of gas the transaction may consume, set by the sender.                                                 |
| Base Fee            | The minimum gas price required to be included in a block. On Sei, the base fee is not burned — all fees go to validators. |
| Priority Fee        | An additional fee (tip) paid to validators for faster inclusion.                                                          |
| Gas Price           | In legacy transactions, the price per unit of gas the sender is willing to pay.                                           |
| Effective Gas Price | The actual price paid per unit of gas (base fee + priority fee in EIP-1559).                                              |

<Warning>
  **Gas Requirements for Common Operations:**

  * Simple SEI transfer: 21,000 gas
  * ERC-20 transfer: \~45,000 gas
  * Contract deployment: Varies based on contract size and complexity
  * Always estimate gas before sending transactions using `eth_estimateGas`
</Warning>

## Transaction Structure

EVM transactions in Sei follow the Ethereum transaction format with standard properties:

<Tabs>
  <Tab title="Transaction Properties">
    | Property               | Description                                                                                                                                                                                                   |
    | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | `from`                 | The address of the sender who will sign the transaction. This must be an externally-owned account (EOA) as contract accounts cannot send transactions.                                                        |
    | `to`                   | The receiving address. If this is an EOA, the transaction transfers value. If a contract address, the transaction executes the contract code. If empty or null, the transaction creates a new contract.       |
    | `signature`            | The cryptographic signature generated when the sender's private key signs the transaction. This confirms the sender has authorized the transaction and includes the v, r, and s components.                   |
    | `nonce`                | A sequentially incrementing counter that indicates the transaction number from the account. This prevents replay attacks and ensures transaction ordering.                                                    |
    | `data`                 | The input data (also called 'input' or 'calldata') for contract execution. For simple transfers, this is usually empty. For contract interactions, this contains the function selector and encoded arguments. |
    | `value`                | Amount of SEI to transfer from sender to recipient (denominated in WEI, where 1 SEI equals 1e+18 WEI).                                                                                                        |
    | `gasLimit`             | The maximum amount of gas units that can be consumed by the transaction. Often referred to as 'gas' in transaction objects.                                                                                   |
    | `maxPriorityFeePerGas` | The maximum price of the consumed gas to be included as a tip to the validator (denominated in WEI). Used in EIP-1559 transactions.                                                                           |
    | `maxFeePerGas`         | The maximum fee per unit of gas willing to be paid for the transaction (inclusive of baseFeePerGas and maxPriorityFeePerGas). Used in EIP-1559 transactions.                                                  |
    | `gasPrice`             | The price per unit of gas the sender is willing to pay (denominated in WEI). Used in legacy transactions.                                                                                                     |
    | `chainId`              | The chain identifier number. Prevents transaction reuse across different chains.                                                                                                                              |
    | `accessList`           | A list of addresses and storage keys that the transaction plans to access. Used in EIP-2930 and EIP-1559 transactions to reduce gas costs for accessing specified addresses and storage slots.                |
    | `type`                 | The transaction type: 0 for legacy (pre-EIP-2718), 1 for EIP-2930 access list transactions, and 2 for EIP-1559 fee market transactions.                                                                       |
    | `hash`                 | The transaction hash, a unique identifier for the transaction generated after signing.                                                                                                                        |
  </Tab>

  <Tab title="Transaction Types">
    ### Legacy Transactions (Type 0)

    Pre-EIP-1559 transaction format that specifies a single gasPrice.

    ```json theme={"dark"}
    {
      "from": "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db",
      "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0",
      "gas": "0x55555",
      "gasPrice": "0x1234",
      "value": "0x1234",
      "data": "0xabcd",
      "nonce": "0x0"
    }
    ```

    ### Access List Transactions (Type 1, EIP-2930)

    Transactions with an optional access list of addresses and storage keys to reduce gas costs.

    ```json theme={"dark"}
    {
      "type": "0x1",
      "from": "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db",
      "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0",
      "gas": "0x55555",
      "gasPrice": "0x1234",
      "value": "0x1234",
      "data": "0xabcd",
      "nonce": "0x0",
      "accessList": [
        {
          "address": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0",
          "storageKeys": [
            "0x0000000000000000000000000000000000000000000000000000000000000000"
          ]
        }
      ]
    }
    ```

    ### Fee Market Transactions (Type 2, EIP-1559)

    Transaction format that supports dynamic base fees with a priority fee tip to validators.

    ```json theme={"dark"}
    {
      "type": "0x2",
      "from": "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db",
      "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0",
      "gas": "0x55555",
      "maxFeePerGas": "0x1234",
      "maxPriorityFeePerGas": "0x1234",
      "value": "0x1234",
      "data": "0xabcd",
      "nonce": "0x0",
      "accessList": []
    }
    ```
  </Tab>

  <Tab title="Example Request">
    ### Example Request: Sending an EIP-1559 Transaction

    ```json theme={"dark"}
    {
      "jsonrpc": "2.0",
      "method": "eth_sendTransaction",
      "params": [
        {
          "from": "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db",
          "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0",
          "gas": "0x55555",
          "maxFeePerGas": "0x1234",
          "maxPriorityFeePerGas": "0x1234",
          "value": "0x1234",
          "data": "0xabcd",
          "nonce": "0x0"
        }
      ],
      "id": 2
    }
    ```

    ### JavaScript example with web3.js

    <Info>
      Public RPC endpoints such as `https://evm-rpc.sei-apis.com` do not manage or unlock accounts, so `eth_getAccounts` and `eth_sendTransaction` are not available. Sign transactions locally with a private key and broadcast the raw transaction instead.
    </Info>

    ```javascript theme={"dark"}
    // Example using web3.js v4 to sign and broadcast a transaction.
    // Public RPC endpoints do not manage accounts, so sign locally with a private key.
    const { Web3 } = require('web3');
    const web3 = new Web3('https://evm-rpc.sei-apis.com');

    // Load your account from a private key. Never hard-code keys — read from an env var.
    const account = web3.eth.accounts.privateKeyToAccount(process.env.PRIVATE_KEY);

    async function sendTransaction() {
      // Current nonce for the sender
      const nonce = await web3.eth.getTransactionCount(account.address);

      // Use the latest base fee to set EIP-1559 fees
      const block = await web3.eth.getBlock('latest');
      const maxPriorityFeePerGas = web3.utils.toWei('1', 'gwei');
      const maxFeePerGas = (BigInt(block.baseFeePerGas) + BigInt(maxPriorityFeePerGas)).toString();

      const tx = {
        from: account.address,
        to: '0x07a565b7ed7d7a678680a4c162885bedbb695fe0',
        value: web3.utils.toWei('0.1', 'ether'),
        gas: 21000, // Gas limit for a simple transfer
        maxFeePerGas,
        maxPriorityFeePerGas,
        nonce,
        chainId: 1329 // pacific-1 mainnet (use 1328 for atlantic-2 testnet)
      };

      // Sign locally, then broadcast the raw transaction
      const signed = await web3.eth.accounts.signTransaction(tx, process.env.PRIVATE_KEY);
      const receipt = await web3.eth.sendSignedTransaction(signed.rawTransaction);
      console.log('Transaction receipt:', receipt);
    }

    sendTransaction().catch(console.error);
    ```
  </Tab>

  <Tab title="Example Response">
    ### `eth_sendTransaction`

    ```json theme={"dark"}
    {
      "jsonrpc": "2.0",
      "id": 2,
      "result": "0xeba2df809e7a612a0a0d444ccfa5c839624bdc00dd29e3340d46df3870f8a30e"
    }
    ```

    ### `eth_getTransactionByHash`

    ```json theme={"dark"}
    {
      "jsonrpc": "2.0",
      "id": 3,
      "result": {
        "blockHash": "0x5d15649e25d8e7c60b5a1cb3612b6b45dceaa3c774f438d4d5b4e1e1b2db634a",
        "blockNumber": "0x92a",
        "from": "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db",
        "gas": "0x55555",
        "gasPrice": "0x1234",
        "hash": "0xeba2df809e7a612a0a0d444ccfa5c839624bdc00dd29e3340d46df3870f8a30e",
        "input": "0xabcd",
        "nonce": "0x0",
        "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0",
        "transactionIndex": "0x1",
        "value": "0x1234",
        "type": "0x2",
        "accessList": [],
        "chainId": "0x1",
        "maxFeePerGas": "0x1234",
        "maxPriorityFeePerGas": "0x1234",
        "v": "0x0",
        "r": "0x223a7c9bcf5531c99be5ea7082183816eb20cfe0bbc322e97cc5c7f71ab8b20e",
        "s": "0x2aadee6b34b45bb15bc42d9c09de4a6754e7000908da72d48cc7704971491663"
      }
    }
    ```

    ### Transaction receipt

    ```json theme={"dark"}
    {
      "jsonrpc": "2.0",
      "id": 4,
      "result": {
        "transactionHash": "0xeba2df809e7a612a0a0d444ccfa5c839624bdc00dd29e3340d46df3870f8a30e",
        "transactionIndex": "0x1",
        "blockHash": "0x5d15649e25d8e7c60b5a1cb3612b6b45dceaa3c774f438d4d5b4e1e1b2db634a",
        "blockNumber": "0x92a",
        "from": "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db",
        "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0",
        "cumulativeGasUsed": "0xd190",
        "gasUsed": "0x5208",
        "contractAddress": null,
        "logs": [],
        "status": "0x1",
        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        "effectiveGasPrice": "0x1234",
        "type": "0x2"
      }
    }
    ```
  </Tab>
</Tabs>

## Transaction Guidelines

<Info>
  **Transaction Best Practices:**

  * **Set appropriate gas parameters:** Use network conditions to estimate optimal values for `maxFeePerGas` and `maxPriorityFeePerGas`.
  * **Manage nonces carefully:** Track and increment nonces correctly to avoid transaction failures.
  * **Use typed transactions:** Prefer EIP-1559 transactions (type 2) for more predictable fees.
  * **Implement proper error handling:** Account for potential transaction failures and revert reasons.
  * **Verify recipient addresses:** Always double-check destination addresses, as transactions cannot be reversed.
</Info>

| Common Issue              | Cause                                  | Solution                                           |
| ------------------------- | -------------------------------------- | -------------------------------------------------- |
| Transaction Underpriced   | Gas price or priority fee too low      | Increase `maxFeePerGas` and `maxPriorityFeePerGas` |
| Nonce Too Low             | Using a nonce that's already been used | Query current nonce with `getTransactionCount`     |
| Out of Gas                | Gas limit too low for the operation    | Use `eth_estimateGas` to set appropriate limit     |
| Contract Execution Failed | Contract function reverted             | Test with `eth_call` before sending transaction    |

## Additional Resources

<CardGroup cols={3}>
  <Card horizontal title="RPC Reference" icon="circle-info" href="/evm/reference">
    Complete documentation of Sei's EVM RPC endpoints for transaction creation and monitoring
  </Card>

  <Card horizontal title="Gas & Fees" icon="coins" href="/learn/dev-gas">
    Learn more about gas calculation, fee estimation, and cost optimization on Sei
  </Card>

  <Card horizontal title="Accounts" icon="user" href="/learn/accounts">
    Understanding Externally Owned Accounts and Contract Accounts on Sei
  </Card>
</CardGroup>

---

URL: https://docs.sei.io/evm/reference

# Sei EVM JSON-RPC API Reference

> Comprehensive reference documentation for Sei's EVM JSON-RPC API endpoints, including standard Ethereum methods and Sei-specific extensions for developers.

export const RPCMethodsViewer = () => {
  const NETWORKS = {
    mainnet: {
      label: 'Pacific-1 · Mainnet',
      chainId: '1329',
      http: 'https://evm-rpc.sei-apis.com',
      ws: 'wss://evm-ws.sei-apis.com'
    },
    testnet: {
      label: 'Atlantic-2 · Testnet',
      chainId: '1328',
      http: 'https://evm-rpc-testnet.sei-apis.com',
      ws: 'wss://evm-ws-testnet.sei-apis.com'
    }
  };
  const NAMESPACE_META = {
    eth: {
      label: 'eth',
      color: '#b05c6c',
      blurb: 'Standard Ethereum methods — accounts, balances, blocks, transactions, logs, calls, and filters.'
    },
    debug: {
      label: 'debug',
      color: '#966f22',
      blurb: 'Transaction and block tracing.'
    },
    txpool: {
      label: 'txpool',
      color: '#3b82f6',
      blurb: 'Transaction-pool inspection.'
    },
    net: {
      label: 'net',
      color: '#0d9488',
      blurb: 'Network metadata.'
    },
    web3: {
      label: 'web3',
      color: '#7c3aed',
      blurb: 'Client metadata.'
    },
    sei: {
      label: 'sei',
      color: '#600014',
      blurb: 'Legacy Sei extensions for cross-VM lookups and synthetic transactions.',
      deprecated: true
    },
    sei2: {
      label: 'sei2',
      color: '#34050d',
      blurb: 'Legacy Sei block queries that include bank transfers.',
      deprecated: true
    },
    admin: {
      label: 'admin',
      color: '#6b7280',
      blurb: 'Node administration — not exposed on Sei.',
      unavailable: true
    },
    miner: {
      label: 'miner',
      color: '#6b7280',
      blurb: 'Mining control — not applicable (no proof-of-work).',
      unavailable: true
    },
    clique: {
      label: 'clique',
      color: '#6b7280',
      blurb: 'Clique proof-of-authority — not applicable (CometBFT consensus).',
      unavailable: true
    },
    engine: {
      label: 'engine',
      color: '#6b7280',
      blurb: 'Consensus Engine API — not applicable (CometBFT consensus).',
      unavailable: true
    },
    les: {
      label: 'les',
      color: '#6b7280',
      blurb: 'Light Ethereum Subprotocol — not exposed on Sei.',
      unavailable: true
    },
    personal: {
      label: 'personal',
      color: '#6b7280',
      blurb: 'Hosted-key account management — not exposed on Sei.',
      unavailable: true
    }
  };
  const NAMESPACE_ORDER = ['eth', 'debug', 'txpool', 'net', 'web3', 'sei', 'sei2', 'admin', 'miner', 'clique', 'engine', 'les', 'personal'];
  const STATUS_META = {
    supported: {
      label: 'Supported',
      dark: '#22c55e',
      light: '#16a34a',
      tip: 'Implemented with standard Ethereum behavior.'
    },
    limited: {
      label: 'Limited',
      dark: '#f59e0b',
      light: '#b45309',
      tip: 'Works, but is deprecated, returns a static value, or has a Sei-specific caveat.'
    },
    unsupported: {
      label: 'Unavailable',
      dark: '#9ca3af',
      light: '#6b7280',
      tip: 'Not registered on Sei, explicitly errors, or not applicable to Sei’s architecture.'
    }
  };
  const LANGUAGES = [{
    id: 'curl',
    name: 'cURL'
  }, {
    id: 'cast',
    name: 'cast'
  }, {
    id: 'javascript',
    name: 'JavaScript'
  }, {
    id: 'typescript',
    name: 'TypeScript'
  }, {
    id: 'python',
    name: 'Python'
  }, {
    id: 'go',
    name: 'Go'
  }, {
    id: 'rust',
    name: 'Rust'
  }, {
    id: 'java',
    name: 'Java'
  }, {
    id: 'kotlin',
    name: 'Kotlin'
  }, {
    id: 'swift',
    name: 'Swift'
  }, {
    id: 'csharp',
    name: 'C#'
  }];
  const SEI_RPC_METHODS = [{
    "namespace": "eth",
    "name": "eth_blockNumber",
    "status": "supported",
    "description": "Returns the number of the most recent committed EVM block as a hex uint64.",
    "seiNote": "Block height comes from CometBFT latest height; the latest committed block is already final on Sei (instant finality, so latest == safe == finalized)."
  }, {
    "namespace": "eth",
    "name": "eth_chainId",
    "status": "supported",
    "description": "Returns the EVM chain ID as a hex big int.",
    "seiNote": "Sourced from the x/evm keeper. Mainnet (pacific-1) = 1329 (0x531); testnet (atlantic-2) = 1328 (0x530)."
  }, {
    "namespace": "eth",
    "name": "eth_coinbase",
    "status": "limited",
    "description": "Returns the block reward beneficiary (coinbase) address.",
    "seiNote": "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."
  }, {
    "namespace": "eth",
    "name": "eth_accounts",
    "status": "limited",
    "description": "Returns the list of addresses for which the node holds hosted keys.",
    "seiNote": "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."
  }, {
    "namespace": "eth",
    "name": "eth_gasPrice",
    "status": "limited",
    "description": "Returns a suggested gas price in wei (hex).",
    "seiNote": "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."
  }, {
    "namespace": "eth",
    "name": "eth_maxPriorityFeePerGas",
    "status": "limited",
    "description": "Returns a suggested priority fee (tip) per gas in wei (hex).",
    "seiNote": "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."
  }, {
    "namespace": "eth",
    "name": "eth_feeHistory",
    "status": "supported",
    "description": "Returns base fees, gas-used ratios, and reward percentile data over a range of blocks.",
    "seiNote": "Base fees and rewards reflect Sei's x/evm fee market (GetNextBaseFee), not an Ethereum EIP-1559 mempool, and Sei does not burn the base fee. Watermark-aware: pruned/historical blocks may not be available as far back as on Ethereum archive nodes.",
    "params": [{
      "name": "blockCount",
      "type": "QUANTITY",
      "description": "Number of blocks in the requested range.",
      "example": "0x5"
    }, {
      "name": "newestBlock",
      "type": "BLOCKNUMBER",
      "description": "Highest block of the range (number or tag).",
      "example": "latest"
    }, {
      "name": "rewardPercentiles",
      "type": "array of float",
      "description": "Monotonically increasing percentiles to sample for priority-fee rewards.",
      "example": "[25,50,75]"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_blobBaseFee",
    "status": "unsupported",
    "description": "EIP-4844 blob base fee. Registered but always returns an unsupported error.",
    "seiNote": "Always returns JSON-RPC error -32000 with message 'blobs not supported on this chain'. Sei does not implement EIP-4844 blob transactions."
  }, {
    "namespace": "eth",
    "name": "eth_syncing",
    "status": "unsupported",
    "description": "Sync status. Registered but always returns an unsupported error instead of false/a sync object.",
    "seiNote": "InfoAPI.Syncing returns a JSON-RPC error with the exact message 'eth_syncing is not supported on Sei EVM RPC' (via ErrEVMNotSupported, code -32000, not -32601). Sei does not expose Ethereum sync semantics here; query CometBFT status endpoints instead."
  }, {
    "namespace": "eth",
    "name": "eth_getBalance",
    "status": "supported",
    "description": "Returns the wei balance of an account at a given block.",
    "seiNote": "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.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Account address.",
      "example": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag (latest/earliest/pending/safe/finalized), or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getCode",
    "status": "supported",
    "description": "Returns the contract bytecode at an address for a given block.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Contract address.",
      "example": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getStorageAt",
    "status": "supported",
    "description": "Returns the value stored at a storage slot of an address at a given block.",
    "seiNote": "Reads the EVM keeper's slot value directly rather than from an MPT trie. The slot key must decode to at most 32 bytes.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Contract address.",
      "example": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7"
    }, {
      "name": "key",
      "type": "DATA, 32 bytes",
      "description": "Storage slot key (hex, up to 32 bytes).",
      "example": "0x0"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getProof",
    "status": "limited",
    "description": "Returns a Merkle proof for an account and the requested storage slots.",
    "seiNote": "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.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Account address.",
      "example": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7"
    }, {
      "name": "storageKeys",
      "type": "array of DATA, 32 bytes",
      "description": "Storage slot keys to prove (bounded by MaxStorageKeysPerProof).",
      "example": "[\"0x0\"]"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getNonce",
    "status": "limited",
    "description": "Sei-specific helper that returns the current EVM nonce for an address (latest state only).",
    "seiNote": "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.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Account address.",
      "example": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_call",
    "status": "supported",
    "description": "Executes a read-only message call against state without creating a transaction; supports state and block overrides.",
    "seiNote": "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.",
    "params": [{
      "name": "args",
      "type": "object",
      "description": "Call object (to, from, data/input, gas, gasPrice/maxFeePerGas, value).",
      "example": "{\"to\":\"0x0000000000000000000000000000000000001004\",\"data\":\"0x0c3c20ed000000000000000000000000Da52B9E673d1f48FcD9916b3F606A136a8eA5e55\"}"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash. Defaults to latest.",
      "example": "latest"
    }, {
      "name": "overrides",
      "type": "object",
      "description": "Optional per-account state overrides (balance, code, nonce, state).",
      "example": "{}"
    }, {
      "name": "blockOverrides",
      "type": "object",
      "description": "Optional block-context overrides (number, time, coinbase).",
      "example": "{}"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_estimateGas",
    "status": "supported",
    "description": "Estimates the gas needed to execute a transaction.",
    "seiNote": "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.",
    "params": [{
      "name": "args",
      "type": "object",
      "description": "Transaction call object.",
      "example": "{\"to\":\"0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7\",\"data\":\"0x18160ddd\"}"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Optional block number, tag, or hash; defaults to latest.",
      "example": "latest"
    }, {
      "name": "overrides",
      "type": "object",
      "description": "Optional state overrides.",
      "example": "{}"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_estimateGasAfterCalls",
    "status": "limited",
    "description": "Estimates gas for a transaction after first applying a sequence of preceding calls against the same simulated state.",
    "seiNote": "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.",
    "params": [{
      "name": "args",
      "type": "object",
      "description": "The final call to estimate gas for.",
      "example": "{\"to\":\"0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7\",\"data\":\"0x\"}"
    }, {
      "name": "calls",
      "type": "array of object",
      "description": "Ordered list of preceding calls applied before the estimate.",
      "example": "[]"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Optional block number, tag, or hash; defaults to latest.",
      "example": "latest"
    }, {
      "name": "overrides",
      "type": "object",
      "description": "Optional state overrides.",
      "example": "{}"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_createAccessList",
    "status": "supported",
    "description": "Generates an EIP-2930 access list (and gas used) for a transaction.",
    "seiNote": "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.",
    "params": [{
      "name": "args",
      "type": "object",
      "description": "Transaction call object.",
      "example": "{\"to\":\"0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7\",\"data\":\"0x\"}"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Optional block number, tag, or hash; defaults to pending.",
      "example": "pending"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_sendRawTransaction",
    "status": "supported",
    "description": "Submits a signed, RLP-encoded raw EVM transaction to the network and returns its hash.",
    "seiNote": "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.",
    "params": [{
      "name": "data",
      "type": "DATA",
      "description": "Signed, RLP-encoded transaction bytes (0x-prefixed).",
      "example": "0x02f8b101808459682f00..."
    }]
  }, {
    "namespace": "eth",
    "name": "eth_sendTransaction",
    "status": "limited",
    "description": "Signs (with a node-hosted key) and submits a transaction in one call.",
    "seiNote": "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.",
    "params": [{
      "name": "args",
      "type": "object",
      "description": "Transaction object (from, to, value, data, gas, nonce, etc.).",
      "example": "{\"from\":\"0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55\",\"to\":\"0x7507454444fa193d39f1392076bc784b77a7a8ff\",\"value\":\"0x1\"}"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_signTransaction",
    "status": "limited",
    "description": "Signs a transaction with a node-hosted key and returns the signed payload without broadcasting.",
    "seiNote": "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.",
    "params": [{
      "name": "args",
      "type": "object",
      "description": "SendTxArgs transaction object to sign (from, to, gas, gasPrice, value, nonce, data).",
      "example": "{\"from\":\"0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55\",\"to\":\"0x7507454444fa193d39f1392076bc784b77a7a8ff\",\"value\":\"0x1\",\"nonce\":\"0x0\",\"gas\":\"0x5208\",\"gasPrice\":\"0x3b9aca00\"}"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_sign",
    "status": "limited",
    "description": "Signs an EIP-191 personal message with a node-hosted key for the given address.",
    "seiNote": "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.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Address whose hosted key signs the data.",
      "example": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55"
    }, {
      "name": "data",
      "type": "DATA",
      "description": "Message bytes to sign.",
      "example": "0xdeadbeef"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getBlockByNumber",
    "status": "supported",
    "description": "Returns block information by number or tag, with full transactions when fullTx is true.",
    "seiNote": "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.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number (hex) or tag (latest/safe/finalized/pending/earliest).",
      "example": "latest"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "true"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getBlockByHash",
    "status": "supported",
    "description": "Returns block information by block hash, with full transactions when fullTx is true.",
    "seiNote": "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.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "false"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getBlockTransactionCountByNumber",
    "status": "supported",
    "description": "Returns the number of EVM transactions in a block by number, as a hex quantity.",
    "seiNote": "Counts EVM transactions only (via getEvmTxCount); synthetic/bank-transfer txs are excluded. Genesis returns 0x0; non-existent/future blocks return null.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getBlockTransactionCountByHash",
    "status": "supported",
    "description": "Returns the number of EVM transactions in a block by hash, as a hex quantity.",
    "seiNote": "Counts EVM transactions only; synthetic/bank-transfer txs are excluded. Genesis hash returns 0x0; unknown hash returns null.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getBlockReceipts",
    "status": "supported",
    "description": "Returns all EVM transaction receipts for a given block.",
    "seiNote": "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.",
    "params": [{
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getTransactionByHash",
    "status": "supported",
    "description": "Returns the EVM transaction matching the given hash, or null if not found.",
    "seiNote": "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. Use the legacy sei_getTransactionByHash to also surface Cosmos txs with synthetic representations.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getTransactionReceipt",
    "status": "supported",
    "description": "Returns the receipt of a transaction by hash, or null if not found.",
    "seiNote": "Receipt is reconstructed from keeper.GetReceipt + CometBFT block data rather than from a native MPT receipt trie; status/logs are standard Ethereum format.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getTransactionByBlockNumberAndIndex",
    "status": "supported",
    "description": "Returns the EVM transaction at the given index within the block at the specified number.",
    "seiNote": "Index maps over EVM transactions only; an out-of-range index yields a null result rather than an error.",
    "params": [{
      "name": "blockNr",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }, {
      "name": "index",
      "type": "QUANTITY",
      "description": "Transaction index within the block.",
      "example": "0x0"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getTransactionByBlockHashAndIndex",
    "status": "supported",
    "description": "Returns the EVM transaction at the given index within the block identified by hash.",
    "seiNote": "Index maps over EVM transactions only; same null-on-overflow semantics as the block-number variant.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "index",
      "type": "QUANTITY",
      "description": "Transaction index within the block.",
      "example": "0x0"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getTransactionCount",
    "status": "supported",
    "description": "Returns the number of transactions sent from an address (nonce) at a given block.",
    "seiNote": "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.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Account address.",
      "example": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash; 'pending' returns the next pending nonce.",
      "example": "latest"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getVMError",
    "status": "limited",
    "description": "Sei extension that returns the EVM VM error string recorded in a transaction's receipt by hash.",
    "seiNote": "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).",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getTransactionErrorByHash",
    "status": "limited",
    "description": "Sei extension that returns the recorded VM error string for a transaction by hash (empty string if it succeeded or is not found).",
    "seiNote": "Non-standard Sei extension registered under the eth namespace. Unlike eth_getVMError, a not-found lookup returns an empty string and no error.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_newFilter",
    "status": "supported",
    "description": "Creates a log filter for the given criteria and returns a filter ID for later polling.",
    "seiNote": "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.",
    "params": [{
      "name": "crit",
      "type": "object",
      "description": "Filter criteria: fromBlock, toBlock (or blockHash), address(es), and topics.",
      "example": "{\"fromBlock\":\"latest\",\"address\":\"0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7\",\"topics\":[]}"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_newBlockFilter",
    "status": "supported",
    "description": "Creates a filter that tracks newly arrived block hashes and returns its ID."
  }, {
    "namespace": "eth",
    "name": "eth_newPendingTransactionFilter",
    "status": "unsupported",
    "description": "Pending-transaction filter. Registered but always returns an unsupported error.",
    "seiNote": "Always returns JSON-RPC -32000. Sei has no geth-style public pending mempool to filter; the corresponding newPendingTransactions subscription type is likewise unavailable."
  }, {
    "namespace": "eth",
    "name": "eth_getFilterChanges",
    "status": "supported",
    "description": "Polls a filter and returns new logs (log filters) or block hashes (block filters) since the last poll.",
    "params": [{
      "name": "filterID",
      "type": "QUANTITY/ID",
      "description": "Filter ID from a New*Filter call.",
      "example": "0x1"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getFilterLogs",
    "status": "supported",
    "description": "Returns all logs matching a previously created log filter, including historical logs.",
    "seiNote": "Bounded by the same caps as eth_getLogs (2,000-block range, 10,000-log limit) with large-query rate limiting.",
    "params": [{
      "name": "filterID",
      "type": "QUANTITY/ID",
      "description": "Filter ID from a NewFilter call.",
      "example": "0x1"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getLogs",
    "status": "supported",
    "description": "Returns logs matching the given filter criteria.",
    "seiNote": "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.",
    "params": [{
      "name": "crit",
      "type": "object",
      "description": "Filter criteria: fromBlock, toBlock (or blockHash), address(es), topics.",
      "example": "{\"fromBlock\":\"0x0\",\"toBlock\":\"latest\",\"address\":\"0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7\",\"topics\":[]}"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_uninstallFilter",
    "status": "supported",
    "description": "Removes a previously installed filter by ID; returns true if it existed and was removed.",
    "seiNote": "Returns false if the filter did not exist rather than erroring. Filters also expire automatically when not polled.",
    "params": [{
      "name": "filterID",
      "type": "QUANTITY/ID",
      "description": "Filter ID to remove.",
      "example": "0x1"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_subscribe",
    "status": "limited",
    "description": "Opens a WebSocket-only push subscription for newHeads or logs notifications.",
    "seiNote": "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.",
    "params": [{
      "name": "subscriptionType",
      "type": "string",
      "description": "Subscription name: 'newHeads' or 'logs'.",
      "example": "newHeads"
    }, {
      "name": "filter",
      "type": "object",
      "description": "Optional filter criteria (address/topics) for the 'logs' subscription.",
      "example": "{\"address\":\"0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7\",\"topics\":[]}"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_unsubscribe",
    "status": "supported",
    "description": "Cancels an existing WebSocket subscription by ID; returns true on success.",
    "seiNote": "WebSocket only; has no effect over HTTP (notifications unsupported there).",
    "params": [{
      "name": "subscriptionID",
      "type": "string",
      "description": "The subscription ID returned by a prior eth_subscribe call.",
      "example": "0x9cef478923ff08bf67fde6c64013158d"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_mining",
    "status": "unsupported",
    "description": "Whether the node is mining. Not registered on Sei.",
    "seiNote": "Sei uses CometBFT proof-of-stake consensus with no PoW mining; the method is not registered and returns -32601 method not found."
  }, {
    "namespace": "eth",
    "name": "eth_hashrate",
    "status": "unsupported",
    "description": "Node mining hashrate. Not registered on Sei.",
    "seiNote": "No PoW mining on Sei (CometBFT consensus); not registered, returns -32601 method not found."
  }, {
    "namespace": "eth",
    "name": "eth_getWork",
    "status": "unsupported",
    "description": "PoW work package (current header hash, seed, target). Not registered on Sei.",
    "seiNote": "The proof-of-work concept does not exist under Sei's CometBFT consensus; not registered."
  }, {
    "namespace": "eth",
    "name": "eth_submitWork",
    "status": "unsupported",
    "description": "Submit a PoW solution. Not registered on Sei.",
    "seiNote": "PoW submission is meaningless on Sei (CometBFT PoS); not registered.",
    "params": [{
      "name": "nonce",
      "type": "DATA, 8 bytes",
      "description": "Found PoW nonce.",
      "example": "0x0000000000000001"
    }, {
      "name": "powHash",
      "type": "DATA, 32 bytes",
      "description": "Header pow-hash.",
      "example": "0x0000000000000000000000000000000000000000000000000000000000000000"
    }, {
      "name": "mixDigest",
      "type": "DATA, 32 bytes",
      "description": "Mix digest.",
      "example": "0x0000000000000000000000000000000000000000000000000000000000000000"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_submitHashrate",
    "status": "unsupported",
    "description": "Submit a node's mining hashrate. Not registered on Sei.",
    "seiNote": "No PoW mining on Sei; not registered.",
    "params": [{
      "name": "hashrate",
      "type": "QUANTITY",
      "description": "Hashrate value (hex).",
      "example": "0x500000"
    }, {
      "name": "id",
      "type": "DATA, 32 bytes",
      "description": "Random hex ID identifying the client.",
      "example": "0x59daa26581d0acd1fce254fb7e85952f4c09d0915afd33d3886cd914bc7d283c"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_protocolVersion",
    "status": "unsupported",
    "description": "Ethereum (devp2p) protocol version. Not registered on Sei.",
    "seiNote": "Sei does not expose the Ethereum devp2p protocol version; not registered, returns -32601 method not found."
  }, {
    "namespace": "eth",
    "name": "eth_getUncleCountByBlockNumber",
    "status": "unsupported",
    "description": "Uncle count by block number. Not registered; Sei has no uncles.",
    "seiNote": "Sei uses CometBFT (single canonical chain, no uncles/ommers); not registered, returns -32601.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getUncleCountByBlockHash",
    "status": "unsupported",
    "description": "Uncle count by block hash. Not registered; Sei has no uncles.",
    "seiNote": "No uncle blocks under CometBFT consensus; not registered, returns -32601.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getUncleByBlockNumberAndIndex",
    "status": "unsupported",
    "description": "Uncle block by number and index. Not registered; Sei has no uncles.",
    "seiNote": "No uncle blocks under CometBFT consensus; not registered, returns -32601.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }, {
      "name": "index",
      "type": "QUANTITY",
      "description": "Uncle index.",
      "example": "0x0"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_getUncleByBlockHashAndIndex",
    "status": "unsupported",
    "description": "Uncle block by hash and index. Not registered; Sei has no uncles.",
    "seiNote": "No uncle blocks under CometBFT consensus; not registered, returns -32601.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "index",
      "type": "QUANTITY",
      "description": "Uncle index.",
      "example": "0x0"
    }]
  }, {
    "namespace": "eth",
    "name": "eth_pendingTransactions",
    "status": "unsupported",
    "description": "List pending transactions in the node's transaction pool. Not registered on Sei.",
    "seiNote": "Sei exposes no geth-style mempool through this method; pending state is surfaced only via the 'pending' tag on eth_getTransactionCount and via txpool_content. Not registered, returns -32601."
  }, {
    "namespace": "net",
    "name": "net_version",
    "status": "supported",
    "description": "Returns the network/chain ID as a decimal string.",
    "seiNote": "Returns the EVM chain ID in decimal (alias of eth_chainId): '1329' on pacific-1 mainnet, '1328' on atlantic-2 testnet."
  }, {
    "namespace": "net",
    "name": "net_listening",
    "status": "unsupported",
    "description": "Whether the node is listening for connections. Not registered on Sei.",
    "seiNote": "Not registered on Sei's NetAPI; returns -32601 method not found (P2P is handled by CometBFT, not this RPC)."
  }, {
    "namespace": "net",
    "name": "net_peerCount",
    "status": "unsupported",
    "description": "Number of connected peers. Not registered on Sei.",
    "seiNote": "Not registered on Sei's NetAPI; returns -32601. Query CometBFT net_info for peer data instead."
  }, {
    "namespace": "web3",
    "name": "web3_clientVersion",
    "status": "supported",
    "description": "Returns the client version string.",
    "seiNote": "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."
  }, {
    "namespace": "web3",
    "name": "web3_sha3",
    "status": "unsupported",
    "description": "Keccak-256 hash of the input. Not implemented in Sei's Web3API.",
    "seiNote": "Unlike go-ethereum, Sei's Web3API does not implement web3_sha3; it is not registered and returns -32601 method not found.",
    "params": [{
      "name": "data",
      "type": "DATA",
      "description": "Bytes to hash.",
      "example": "0x68656c6c6f20776f726c64"
    }]
  }, {
    "namespace": "txpool",
    "name": "txpool_content",
    "status": "limited",
    "description": "Returns the transactions currently in the pool, grouped by sender address and nonce into pending and queued buckets.",
    "seiNote": "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."
  }, {
    "namespace": "txpool",
    "name": "txpool_contentFrom",
    "status": "unsupported",
    "description": "Pending/queued transactions for a single account. Not implemented on Sei.",
    "seiNote": "Not registered; returns -32601 method not found. The only txpool method available on Sei is txpool_content.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "The account address to filter by.",
      "example": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55"
    }]
  }, {
    "namespace": "txpool",
    "name": "txpool_status",
    "status": "unsupported",
    "description": "Counts of pending and queued transactions. Not implemented on Sei.",
    "seiNote": "Not registered; returns -32601 method not found."
  }, {
    "namespace": "txpool",
    "name": "txpool_inspect",
    "status": "unsupported",
    "description": "Human-readable summary of pending/queued transactions. Not implemented on Sei.",
    "seiNote": "Not registered; returns -32601 method not found."
  }, {
    "namespace": "debug",
    "name": "debug_traceTransaction",
    "status": "supported",
    "description": "Replays a transaction by hash and returns an execution trace using the configured tracer.",
    "seiNote": "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.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash to trace.",
      "example": "0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060"
    }, {
      "name": "config",
      "type": "object",
      "description": "Optional tracer config (tracer name, tracerConfig, timeout, reexec, disableStorage/Stack/Memory).",
      "example": "{\"tracer\":\"callTracer\"}"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_traceBlockByNumber",
    "status": "supported",
    "description": "Traces all transactions in a block by number and returns per-transaction execution traces.",
    "seiNote": "HTTP-only. safe/finalized/latest are equivalent due to instant finality.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }, {
      "name": "config",
      "type": "object",
      "description": "Optional tracer config.",
      "example": "{\"tracer\":\"callTracer\"}"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_traceBlockByHash",
    "status": "supported",
    "description": "Traces all transactions in a block by hash and returns per-transaction execution traces.",
    "seiNote": "HTTP-only.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "config",
      "type": "object",
      "description": "Optional tracer config.",
      "example": "{\"tracer\":\"callTracer\"}"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_traceCall",
    "status": "supported",
    "description": "Executes and traces a call against a block's state without creating a transaction.",
    "seiNote": "HTTP-only. Arbitrary geth tracer names pass through. Tracing on the pending block is not supported.",
    "params": [{
      "name": "args",
      "type": "object",
      "description": "Transaction call object.",
      "example": "{\"to\":\"0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7\",\"data\":\"0x70a08231\"}"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }, {
      "name": "config",
      "type": "object",
      "description": "Optional trace-call config (tracer name, state overrides, block overrides).",
      "example": "{\"tracer\":\"callTracer\"}"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_traceStateAccess",
    "status": "limited",
    "description": "Sei extension that replays a transaction and returns its app/tendermint/receipt state-access traces.",
    "seiNote": "Sei-specific extension (not part of upstream go-ethereum's debug namespace). HTTP-only and subject to historical-debug-trace availability guards.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash whose state accesses are returned.",
      "example": "0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_getRawHeader",
    "status": "unsupported",
    "description": "RLP-encoded block header. Registered but always returns an unsupported error.",
    "seiNote": "Always returns JSON-RPC -32000. Sei block headers are CometBFT headers, not RLP-encoded Ethereum headers.",
    "params": [{
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_getRawBlock",
    "status": "unsupported",
    "description": "RLP-encoded full block. Registered but always returns an unsupported error.",
    "seiNote": "Always returns JSON-RPC -32000; no canonical RLP-encoded Ethereum block exists on Sei.",
    "params": [{
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_getRawReceipts",
    "status": "unsupported",
    "description": "RLP-encoded receipts for a block. Registered but always returns an unsupported error.",
    "seiNote": "Always returns JSON-RPC -32000.",
    "params": [{
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_getRawTransaction",
    "status": "unsupported",
    "description": "RLP-encoded signed transaction by hash. Registered but always returns an unsupported error.",
    "seiNote": "Always returns JSON-RPC -32000.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_storageRangeAt",
    "status": "unsupported",
    "description": "Range of storage entries for a contract at a block/tx. Not implemented on Sei.",
    "seiNote": "Not registered; returns -32601. Sei uses IAVL state, not an Ethereum MPT, so geth's MPT-based storage-range walk is not provided.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "txIndex",
      "type": "QUANTITY",
      "description": "Transaction index.",
      "example": "0x0"
    }, {
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Contract address.",
      "example": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7"
    }, {
      "name": "startKey",
      "type": "DATA",
      "description": "Start storage key.",
      "example": "0x00"
    }, {
      "name": "maxResult",
      "type": "QUANTITY",
      "description": "Maximum number of entries.",
      "example": "0x64"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_traceBlock",
    "status": "unsupported",
    "description": "Trace a block supplied as raw RLP bytes. Not implemented on Sei.",
    "seiNote": "Not registered; returns -32601. Sei does not accept RLP-encoded Ethereum blocks; use debug_traceBlockByNumber/ByHash instead.",
    "params": [{
      "name": "blockRlp",
      "type": "DATA",
      "description": "RLP-encoded block bytes.",
      "example": "0xf90211..."
    }]
  }, {
    "namespace": "debug",
    "name": "debug_intermediateRoots",
    "status": "unsupported",
    "description": "Intermediate state roots while executing a block. Not implemented on Sei.",
    "seiNote": "Not registered; returns -32601. Sei uses IAVL state, not an Ethereum MPT, so per-transaction MPT intermediate roots are not produced.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "config",
      "type": "object",
      "description": "Optional trace config.",
      "example": "{}"
    }]
  }, {
    "namespace": "debug",
    "name": "debug_setHead",
    "status": "unsupported",
    "description": "Rewind the chain head to a given block. Not implemented on Sei.",
    "seiNote": "Not registered; returns -32601. The chain head is controlled by CometBFT consensus, not the EVM RPC layer.",
    "params": [{
      "name": "number",
      "type": "QUANTITY",
      "description": "Block number to set as head.",
      "example": "0x1a2b3c"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getSeiAddress",
    "status": "limited",
    "description": "Returns the native Sei bech32 (sei1...) address associated with a given EVM (0x) address.",
    "seiNote": "Deprecated legacy sei_* method, but ENABLED by default in the enabled_legacy_sei_apis allowlist on seid init. New integrations should call the addr precompile at 0x0000000000000000000000000000000000001004 (getSeiAddr) via eth_call. Errors if the address is not yet associated. HTTP-only.",
    "params": [{
      "name": "ethAddress",
      "type": "DATA, 20 bytes",
      "description": "The EVM address to resolve.",
      "example": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getEVMAddress",
    "status": "limited",
    "description": "Returns the EVM (0x) address associated with a given native Sei bech32 (sei1...) address.",
    "seiNote": "Deprecated legacy sei_* method, ENABLED by default in enabled_legacy_sei_apis. Prefer the addr precompile at 0x...1004 (getEvmAddr) via eth_call. Errors if the bech32 is malformed or the address is not yet associated. HTTP-only.",
    "params": [{
      "name": "seiAddress",
      "type": "string",
      "description": "The Sei bech32 address to resolve.",
      "example": "sei13ytysxs88z0fp9cssagg77ekpecrrlrwce9pwl"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getCosmosTx",
    "status": "limited",
    "description": "Returns the underlying CometBFT/Cosmos transaction hash corresponding to a given EVM transaction hash.",
    "seiNote": "Deprecated legacy sei_* method, but ENABLED by default in enabled_legacy_sei_apis (it has no precompile equivalent yet). Bridges Sei's dual-tx model: every EVM tx is wrapped in a Cosmos tx; this returns the wrapping Cosmos tx hash. HTTP-only.",
    "params": [{
      "name": "ethHash",
      "type": "DATA, 32 bytes",
      "description": "The EVM transaction hash to map to its underlying Cosmos tx hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getEvmTx",
    "status": "limited",
    "description": "Returns the EVM transaction hash corresponding to a given CometBFT/Cosmos transaction hash.",
    "seiNote": "Deprecated legacy sei_* method and DISABLED by default (not in the default enabled_legacy_sei_apis allowlist); disabled calls return -32601 with data 'legacy_sei_deprecated'. Inverse of sei_getCosmosTx; the cosmosHash arg is a plain hex string (no 0x prefix). HTTP-only.",
    "params": [{
      "name": "cosmosHash",
      "type": "string",
      "description": "The Cosmos/CometBFT transaction hash as a hex string (no 0x prefix).",
      "example": "A1B2C3D4E5F60718293A4B5C6D7E8F90A1B2C3D4E5F60718293A4B5C6D7E8F901"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_associate",
    "status": "limited",
    "description": "Submits an address-association transaction linking an EVM address and its Sei address via a signed payload.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default (not in the default enabled_legacy_sei_apis allowlist). Broadcasts a real Cosmos AssociateTx (no gas) and returns no result on success. The same action is available on-chain via the addr precompile at 0x...1004 (associate/associatePubKey). HTTP-only.",
    "params": [{
      "name": "req",
      "type": "object",
      "description": "AssociateRequest with hex-string signature components r, s, v and a custom_message.",
      "example": "{\"r\":\"0x1c8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36deac8\",\"s\":\"0x2c8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36deac8\",\"v\":\"0x1b\",\"custom_message\":\"associate\"}"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getBlockByNumber",
    "status": "limited",
    "description": "Returns block info by number including Cosmos transactions that have synthetic EVM receipts.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default (must be added to enabled_legacy_sei_apis); disabled calls return -32601 with data 'legacy_sei_deprecated'. Unlike eth_getBlockByNumber it includes synthetic (shell) EVM txs for Cosmos activity, so tx indices differ from eth_. HTTP-only.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "true"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getBlockByHash",
    "status": "limited",
    "description": "Returns block info by hash including Cosmos transactions that have synthetic EVM receipts.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. Includes synthetic shell EVM txs (bank/Cosmos activity), unlike eth_getBlockByHash. HTTP-only.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "false"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getBlockReceipts",
    "status": "limited",
    "description": "Returns all receipts for a block including synthetic receipts for Cosmos transactions.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. Returns more receipts than eth_getBlockReceipts for the same block (covering Sei synthetic/Cosmos-originated EVM activity). HTTP-only.",
    "params": [{
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getBlockTransactionCountByNumber",
    "status": "limited",
    "description": "Returns the transaction count of a block by number, including synthetic Cosmos txs.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getBlockTransactionCountByHash",
    "status": "limited",
    "description": "Returns the transaction count of a block by hash, including synthetic Cosmos txs.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getBlockByNumberExcludeTraceFail",
    "status": "limited",
    "description": "Returns a block by number excluding transactions whose EVM trace failed (Sei extension).",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. Sei-only method (no Ethereum equivalent) that omits untraceable txs; passes includeSyntheticTxs=false, excludeUntraceable=true. HTTP-only.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "true"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getBlockByHashExcludeTraceFail",
    "status": "limited",
    "description": "Returns a block by hash excluding transactions whose EVM trace failed (Sei extension).",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. Sei-only method (no Ethereum equivalent) that omits untraceable txs. HTTP-only.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "true"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getTransactionByHash",
    "status": "limited",
    "description": "Returns a transaction by hash including Cosmos txs with synthetic EVM representation.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. Broader visibility than eth_getTransactionByHash (also surfaces Cosmos txs). HTTP-only.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getTransactionReceipt",
    "status": "limited",
    "description": "Returns a transaction receipt by hash including synthetic receipts for Cosmos txs.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. Broader visibility than eth_getTransactionReceipt. HTTP-only.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getTransactionReceiptExcludeTraceFail",
    "status": "limited",
    "description": "Returns a transaction receipt, omitting it if the transaction panicked/failed during trace (Sei extension).",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. Calls getTransactionReceipt with excludePanicTxs=true, so receipts for panic/trace-fail txs are omitted (returns null). HTTP-only.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getTransactionByBlockNumberAndIndex",
    "status": "limited",
    "description": "Returns a transaction by block number and index over the combined (incl. Cosmos) transaction set.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. The index space includes Cosmos txs, so it differs from eth_. HTTP-only.",
    "params": [{
      "name": "blockNumber",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }, {
      "name": "index",
      "type": "QUANTITY",
      "description": "Transaction index over all txs, including Cosmos.",
      "example": "0x0"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getTransactionByBlockHashAndIndex",
    "status": "limited",
    "description": "Returns a transaction by block hash and index over the combined (incl. Cosmos) transaction set.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "index",
      "type": "QUANTITY",
      "description": "Transaction index over all txs, including Cosmos.",
      "example": "0x0"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getTransactionCount",
    "status": "limited",
    "description": "Returns the transaction count (nonce) of an address at a given block.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. Prefer eth_getTransactionCount. HTTP-only.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Account address.",
      "example": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55"
    }, {
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getTransactionErrorByHash",
    "status": "limited",
    "description": "Returns the recorded error message for a failed transaction by hash.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default (not in the default allowlist). HTTP-only.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getVMError",
    "status": "limited",
    "description": "Returns the EVM/VM error string for a transaction by hash.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Transaction hash.",
      "example": "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getLogs",
    "status": "limited",
    "description": "Returns logs matching filter criteria, including synthetic logs from Cosmos transactions.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. Unlike eth_getLogs it includes synthetic logs from Cosmos txs. Subject to the same 2,000-block / 10,000-log caps. HTTP-only.",
    "params": [{
      "name": "crit",
      "type": "object",
      "description": "Filter criteria (fromBlock, toBlock, address, topics, blockHash).",
      "example": "{\"fromBlock\":\"0x0\",\"toBlock\":\"latest\",\"address\":\"0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7\"}"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getFilterLogs",
    "status": "limited",
    "description": "Returns all logs for a filter ID, including synthetic Cosmos logs.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "filterID",
      "type": "QUANTITY/ID",
      "description": "Filter ID.",
      "example": "0x1"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_getFilterChanges",
    "status": "limited",
    "description": "Returns new logs/hashes since the last poll of a filter (Sei view including synthetic events).",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "filterID",
      "type": "QUANTITY/ID",
      "description": "Filter ID.",
      "example": "0x1"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_newFilter",
    "status": "limited",
    "description": "Creates a log filter over the Sei (EVM+synthetic) view and returns its ID.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "crit",
      "type": "object",
      "description": "Filter criteria (fromBlock, toBlock, address, topics).",
      "example": "{\"fromBlock\":\"latest\",\"address\":\"0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7\",\"topics\":[]}"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_newBlockFilter",
    "status": "limited",
    "description": "Creates a new-block filter (Sei view) and returns its ID.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. HTTP-only."
  }, {
    "namespace": "sei",
    "name": "sei_uninstallFilter",
    "status": "limited",
    "description": "Removes a previously created sei filter by ID.",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "filterID",
      "type": "QUANTITY/ID",
      "description": "Filter ID.",
      "example": "0x1"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_traceBlockByNumberExcludeTraceFail",
    "status": "limited",
    "description": "Traces all transactions in a block by number, excluding those whose trace failed (Sei extension).",
    "seiNote": "Deprecated legacy sei_* method (registered via SeiDebugAPI), DISABLED by default. Filters out txs whose trace errored. HTTP-only.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }, {
      "name": "config",
      "type": "object",
      "description": "Optional tracer config.",
      "example": "{\"tracer\":\"callTracer\"}"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_traceBlockByHashExcludeTraceFail",
    "status": "limited",
    "description": "Traces all transactions in a block by hash, excluding those whose trace failed (Sei extension).",
    "seiNote": "Deprecated legacy sei_* method (registered via SeiDebugAPI), DISABLED by default. HTTP-only.",
    "params": [{
      "name": "hash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "config",
      "type": "object",
      "description": "Optional tracer config.",
      "example": "{\"tracer\":\"callTracer\"}"
    }]
  }, {
    "namespace": "sei",
    "name": "sei_sign",
    "status": "limited",
    "description": "Signs data with a node-hosted key (Sei legacy variant of eth_sign).",
    "seiNote": "Deprecated legacy sei_* method, DISABLED by default; notably the Docker localnet enables all gated methods EXCEPT sei_sign. Requires a node-hosted key (unusable on public RPC). HTTP-only.",
    "params": [{
      "name": "address",
      "type": "DATA, 20 bytes",
      "description": "Account to sign with (must be in the node keyring).",
      "example": "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55"
    }, {
      "name": "data",
      "type": "DATA",
      "description": "Data to sign.",
      "example": "0xdeadbeef"
    }]
  }, {
    "namespace": "sei2",
    "name": "sei2_getBlockByNumber",
    "status": "limited",
    "description": "Returns block info by number in the sei block shape, additionally including Cosmos bank transfers.",
    "seiNote": "Deprecated legacy sei2_* method, DISABLED by default (all sei2_* methods must be explicitly added to enabled_legacy_sei_apis); disabled calls return -32601 with data 'legacy_sei_deprecated'. Same shape as sei_ blocks plus Cosmos bank MsgSend transfers surfaced as synthetic EVM txs. HTTP-only (Sei2BlockAPI is not on the WebSocket server).",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "true"
    }]
  }, {
    "namespace": "sei2",
    "name": "sei2_getBlockByHash",
    "status": "limited",
    "description": "Returns block info by hash in the sei block shape, additionally including Cosmos bank transfers.",
    "seiNote": "Deprecated legacy sei2_* method, DISABLED by default. Includes bank transfers in the block payload. HTTP-only.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "false"
    }]
  }, {
    "namespace": "sei2",
    "name": "sei2_getBlockReceipts",
    "status": "limited",
    "description": "Returns all receipts for a block in the sei2 shape (with bank-transfer context).",
    "seiNote": "Deprecated legacy sei2_* method, DISABLED by default. HTTP-only. Note: in some source revisions the inherited GetBlockReceipts calls shouldIncludeSynthetic(\"sei2\"), which only accepts 'eth'/'sei' and can surface as an internal error for the sei2 namespace.",
    "params": [{
      "name": "blockNrOrHash",
      "type": "BLOCKNUMBER or DATA",
      "description": "Block number, tag, or hash.",
      "example": "latest"
    }]
  }, {
    "namespace": "sei2",
    "name": "sei2_getBlockTransactionCountByNumber",
    "status": "limited",
    "description": "Returns the transaction count of a block by number in the sei2 shape.",
    "seiNote": "Deprecated legacy sei2_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }]
  }, {
    "namespace": "sei2",
    "name": "sei2_getBlockTransactionCountByHash",
    "status": "limited",
    "description": "Returns the transaction count of a block by hash in the sei2 shape.",
    "seiNote": "Deprecated legacy sei2_* method, DISABLED by default. The sei2 namespace has only block/receipt/count methods (no transaction or filter APIs). HTTP-only.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }]
  }, {
    "namespace": "sei2",
    "name": "sei2_getBlockByNumberExcludeTraceFail",
    "status": "limited",
    "description": "Returns a block by number excluding trace-failing txs, with bank transfers per the sei2 config.",
    "seiNote": "Deprecated legacy sei2_* method, DISABLED by default. Passes includeSyntheticTxs=false, excludeUntraceable=true; includeBankTransfers=true still applies. HTTP-only.",
    "params": [{
      "name": "number",
      "type": "BLOCKNUMBER",
      "description": "Block number or tag.",
      "example": "latest"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "true"
    }]
  }, {
    "namespace": "sei2",
    "name": "sei2_getBlockByHashExcludeTraceFail",
    "status": "limited",
    "description": "Returns a block by hash excluding trace-failing txs, with bank transfers per the sei2 config.",
    "seiNote": "Deprecated legacy sei2_* method, DISABLED by default. HTTP-only.",
    "params": [{
      "name": "blockHash",
      "type": "DATA, 32 bytes",
      "description": "Block hash.",
      "example": "0x5620c15afd9a1d0ab19d7560043df6e038d731c6205974dca7a55900071e3864"
    }, {
      "name": "fullTx",
      "type": "boolean",
      "description": "If true include full transaction objects, else only hashes.",
      "example": "false"
    }]
  }, {
    "namespace": "admin",
    "name": "admin_*",
    "status": "unsupported",
    "description": "Geth node administration namespace (admin_nodeInfo, admin_peers, admin_addPeer, admin_datadir, etc.). Not run by Sei.",
    "seiNote": "Sei does not run go-ethereum's admin namespace; node administration is via the CometBFT/Cosmos stack. All admin_* methods return -32601 method not found."
  }, {
    "namespace": "miner",
    "name": "miner_*",
    "status": "unsupported",
    "description": "Geth miner-control namespace (miner_start, miner_stop, miner_setEtherbase, miner_setGasPrice, etc.). Not run by Sei.",
    "seiNote": "Sei has no PoW/PoA miner (CometBFT PoS consensus); the namespace is not served. All miner_* methods return -32601."
  }, {
    "namespace": "clique",
    "name": "clique_*",
    "status": "unsupported",
    "description": "Clique proof-of-authority consensus namespace (clique_getSnapshot, clique_propose, etc.). Not run by Sei.",
    "seiNote": "Sei uses CometBFT, not the Clique PoA engine; the namespace is not served. All clique_* methods return -32601."
  }, {
    "namespace": "engine",
    "name": "engine_*",
    "status": "unsupported",
    "description": "Ethereum Engine API namespace (engine_newPayloadV*, engine_forkchoiceUpdatedV*, engine_getPayloadV*) for consensus/execution-layer payload exchange. Not run by Sei.",
    "seiNote": "Sei is not a post-merge Ethereum execution client; there is no CL/EL split or payload engine (consensus is CometBFT). All engine_* methods return -32601."
  }, {
    "namespace": "les",
    "name": "les_*",
    "status": "unsupported",
    "description": "Light Ethereum Subprotocol (LES) light-server namespace. Not run by Sei.",
    "seiNote": "Sei does not implement LES light-server endpoints; the namespace is not served. All les_* methods return -32601."
  }, {
    "namespace": "personal",
    "name": "personal_*",
    "status": "unsupported",
    "description": "Geth account-management namespace (personal_newAccount, personal_unlockAccount, personal_sendTransaction, personal_sign, etc.). Not run by Sei.",
    "seiNote": "Sei does not expose the deprecated personal namespace; hosted RPC nodes hold no user keys. Key management/signing is client-side and eth_sendRawTransaction is the supported path. All personal_* methods return -32601."
  }];
  const parseValue = raw => {
    if (typeof raw !== 'string') return raw;
    const t = raw.trim();
    if (t === '') return '';
    const looksJson = t[0] === '{' || t[0] === '[' || t === 'true' || t === 'false' || t === 'null';
    if (looksJson) {
      try {
        return JSON.parse(t);
      } catch (e) {
        return raw;
      }
    }
    return raw;
  };
  const isEmptyValue = v => {
    if (v === '' || v === undefined || v === null) return true;
    if (Array.isArray(v)) return v.length === 0;
    if (typeof v === 'object') return Object.keys(v).length === 0;
    return false;
  };
  const buildParams = (method, values) => {
    const defs = method.params || [];
    const raw = defs.map(p => {
      const v = values ? values[p.name] : undefined;
      return v !== undefined ? v : p.example || '';
    });
    const isBlank = v => typeof v === 'string' && v.trim() === '';
    let end = raw.length;
    while (end > 0 && isEmptyValue(parseValue(raw[end - 1]))) end--;
    const params = raw.slice(0, end).map((v, i) => isBlank(v) ? parseValue(defs[i].example || '') : parseValue(v));
    const sub = typeof params[0] === 'string' ? params[0].trim().toLowerCase() : params[0];
    if (method.name === 'eth_subscribe' && sub !== 'logs') params.length = 1;
    return params;
  };
  const deriveWsEndpoint = httpUrl => {
    if (!httpUrl) return 'wss://<your-ws-endpoint>';
    try {
      const u = new URL(httpUrl);
      u.protocol = u.protocol === 'http:' ? 'ws:' : 'wss:';
      return u.toString().replace(/\/$/, '');
    } catch (e) {
      return 'wss://<your-ws-endpoint>';
    }
  };
  const isWsOnly = name => name === 'eth_subscribe' || name === 'eth_unsubscribe';
  const isMutation = name => name === 'eth_sendRawTransaction' || name === 'eth_sendTransaction' || name === 'eth_signTransaction' || name === 'eth_sign' || name === 'sei_sign' || name === 'sei_associate' || name.startsWith('personal_');
  const [theme, setTheme] = useState('dark');
  const [isMobile, setIsMobile] = useState(false);
  const [mobileView, setMobileView] = useState('list');
  const rootRef = useRef(null);
  const runIdRef = useRef(0);
  const probeIdRef = useRef(0);
  const [network, setNetwork] = useState('mainnet');
  const [customEndpoint, setCustomEndpoint] = useState('');
  const endpoint = network === 'custom' ? customEndpoint : NETWORKS[network].http;
  const wsEndpoint = network === 'custom' ? deriveWsEndpoint(customEndpoint) : NETWORKS[network].ws;
  const [connection, setConnection] = useState('idle');
  const [consoleActive, setConsoleActive] = useState(false);
  const [searchTerm, setSearchTerm] = useState('');
  const [selectedNamespace, setSelectedNamespace] = useState('all');
  const [showAll, setShowAll] = useState(false);
  const isHiddenByDefault = m => m.status === 'unsupported' || !!(NAMESPACE_META[m.namespace] && NAMESPACE_META[m.namespace].deprecated);
  const [selectedMethod, setSelectedMethod] = useState(null);
  const [selectedLanguage, setSelectedLanguage] = useState('curl');
  const [paramValues, setParamValues] = useState({});
  const [debouncedParams, setDebouncedParams] = useState({});
  const [requestResult, setRequestResult] = useState(null);
  const [isLoading, setIsLoading] = useState(false);
  const [copied, setCopied] = useState('');
  const isDark = theme === 'dark';
  useEffect(() => {
    const detect = () => setTheme(document.documentElement.classList.contains('dark') ? 'dark' : 'light');
    detect();
    const observer = new MutationObserver(detect);
    observer.observe(document.documentElement, {
      attributes: true,
      attributeFilter: ['class']
    });
    return () => observer.disconnect();
  }, []);
  useEffect(() => {
    const stackBelow = w => setIsMobile(w < 768);
    const el = rootRef.current;
    if (el && typeof ResizeObserver !== 'undefined') {
      const ro = new ResizeObserver(entries => stackBelow(entries[0].contentRect.width));
      ro.observe(el);
      return () => ro.disconnect();
    }
    const check = () => stackBelow(window.innerWidth);
    check();
    window.addEventListener('resize', check);
    return () => window.removeEventListener('resize', check);
  }, []);
  useEffect(() => {
    const t = setTimeout(() => setDebouncedParams(paramValues), 250);
    return () => clearTimeout(t);
  }, [paramValues]);
  const validateEndpoint = useCallback(async () => {
    if (!endpoint) {
      setConnection('idle');
      return;
    }
    const probeId = ++probeIdRef.current;
    try {
      const res = await fetch(endpoint, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          jsonrpc: '2.0',
          id: 1,
          method: 'web3_clientVersion',
          params: []
        })
      });
      if (probeId === probeIdRef.current) setConnection(res.ok ? 'ok' : 'fail');
    } catch (e) {
      if (probeId === probeIdRef.current) setConnection('fail');
    }
  }, [endpoint]);
  useEffect(() => {
    if (consoleActive) validateEndpoint();
  }, [validateEndpoint, consoleActive]);
  useEffect(() => {
    runIdRef.current++;
    setRequestResult(null);
    setIsLoading(false);
  }, [endpoint]);
  const allMethods = useMemo(() => SEI_RPC_METHODS.map(m => ({
    ...m,
    meta: NAMESPACE_META[m.namespace] || ({
      label: m.namespace,
      color: '#6b7280'
    })
  })), []);
  const filteredMethods = useMemo(() => {
    let list = allMethods;
    if (selectedNamespace !== 'all') list = list.filter(m => m.namespace === selectedNamespace);
    if (!showAll) list = list.filter(m => !isHiddenByDefault(m));
    if (searchTerm) {
      const q = searchTerm.toLowerCase();
      list = list.filter(m => m.name.toLowerCase().includes(q) || (m.description || '').toLowerCase().includes(q));
    }
    const rank = s => s === 'supported' ? 0 : s === 'limited' ? 1 : 2;
    return [...list].sort((a, b) => {
      const ns = NAMESPACE_ORDER.indexOf(a.namespace) - NAMESPACE_ORDER.indexOf(b.namespace);
      if (ns !== 0) return ns;
      return rank(a.status) - rank(b.status);
    });
  }, [allMethods, selectedNamespace, showAll, searchTerm]);
  const visibleNamespaces = useMemo(() => {
    const present = new Set();
    allMethods.forEach(m => {
      if (showAll || !isHiddenByDefault(m)) present.add(m.namespace);
    });
    return NAMESPACE_ORDER.filter(ns => present.has(ns));
  }, [allMethods, showAll]);
  const counts = useMemo(() => allMethods.reduce((a, m) => (a[m.status] = (a[m.status] || 0) + 1, a), {}), [allMethods]);
  const selectMethod = m => {
    setConsoleActive(true);
    setSelectedMethod(m);
    setParamValues({});
    setDebouncedParams({});
    runIdRef.current++;
    setRequestResult(null);
    setIsLoading(false);
    setSelectedLanguage('curl');
    if (isMobile) setMobileView('detail');
  };
  const copy = (text, key) => {
    navigator.clipboard.writeText(text);
    setCopied(key);
    setTimeout(() => setCopied(''), 1500);
  };
  const execute = async () => {
    if (!selectedMethod) return;
    const runId = ++runIdRef.current;
    setIsLoading(true);
    setRequestResult(null);
    const params = buildParams(selectedMethod, paramValues);
    try {
      const res = await fetch(endpoint, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          jsonrpc: '2.0',
          id: 1,
          method: selectedMethod.name,
          params
        })
      });
      const json = await res.json();
      if (runId === runIdRef.current) setRequestResult(json);
    } catch (e) {
      if (runId === runIdRef.current) setRequestResult({
        error: {
          code: -1,
          message: e.message + ' (the endpoint may not allow browser requests / CORS)'
        }
      });
    } finally {
      if (runId === runIdRef.current) setIsLoading(false);
    }
  };
  const generateCode = useCallback((method, language) => {
    if (!method) return '';
    const params = buildParams(method, debouncedParams);
    const paramsJson = JSON.stringify(params);
    const bodyJson = JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: method.name,
      params
    });
    const url = endpoint || 'https://evm-rpc.sei-apis.com';
    const ws = wsEndpoint;
    const BT = String.fromCharCode(96);
    const csBody = bodyJson.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
    if (isWsOnly(method.name)) {
      if (language === 'javascript') {
        return [`// ${method.name} runs over WebSocket only.`, `const socket = new WebSocket('${ws}');`, 'socket.onopen = () => socket.send(JSON.stringify({', `  jsonrpc: '2.0', id: 1, method: '${method.name}', params: ${paramsJson},`, '}));', 'socket.onmessage = (e) => console.log(JSON.parse(e.data));', '', '// ethers v6', "import { WebSocketProvider } from 'ethers';", `const provider = new WebSocketProvider('${ws}');`, `console.log(await provider.send('${method.name}', ${paramsJson}));`].join('\n');
      }
      if (language === 'typescript') {
        return [`// ${method.name} runs over WebSocket only.`, `const socket = new WebSocket('${ws}');`, 'socket.onopen = () => socket.send(JSON.stringify({', `  jsonrpc: '2.0', id: 1, method: '${method.name}', params: ${paramsJson},`, '}));', 'socket.onmessage = (e: MessageEvent) => console.log(JSON.parse(e.data));'].join('\n');
      }
      if (language === 'python') {
        return ['# pip install websocket-client', 'from websocket import create_connection', `socket = create_connection("${ws}")`, `socket.send(r"""${bodyJson}""")`, 'print(socket.recv())', 'socket.close()'].join('\n');
      }
      if (language === 'go') {
        return ['// go get github.com/gorilla/websocket', 'package main', '', 'import (', '\t"fmt"', '\t"github.com/gorilla/websocket"', ')', '', 'func main() {', `\tc, _, err := websocket.DefaultDialer.Dial("${ws}", nil)`, '\tif err != nil {', '\t\tpanic(err)', '\t}', '\tdefer c.Close()', '\tc.WriteMessage(websocket.TextMessage, []byte(' + BT + bodyJson + BT + '))', '\t_, msg, _ := c.ReadMessage()', '\tfmt.Println(string(msg))', '}'].join('\n');
      }
      if (language === 'rust') {
        return ['// tokio-tungstenite = "0.23"  futures-util = "0.3"  tokio = { version = "1", features = ["full"] }', 'use futures_util::{SinkExt, StreamExt};', 'use tokio_tungstenite::{connect_async, tungstenite::Message};', '', '#[tokio::main]', 'async fn main() -> Result<(), Box<dyn std::error::Error>> {', `    let (mut socket, _) = connect_async("${ws}").await?;`, '    socket.send(Message::Text(r#"' + bodyJson + '"#.to_string())).await?;', '    if let Some(msg) = socket.next().await {', '        println!("{}", msg?);', '    }', '    Ok(())', '}'].join('\n');
      }
      if (language === 'csharp') {
        return ['using System;', 'using System.Net.WebSockets;', 'using System.Text;', 'using System.Threading;', '', 'using var socket = new ClientWebSocket();', `await socket.ConnectAsync(new Uri("${ws}"), CancellationToken.None);`, `var body = Encoding.UTF8.GetBytes("${csBody}");`, 'await socket.SendAsync(body, WebSocketMessageType.Text, true, CancellationToken.None);', 'var buffer = new byte[8192];', 'var res = await socket.ReceiveAsync(buffer, CancellationToken.None);', 'Console.WriteLine(Encoding.UTF8.GetString(buffer, 0, res.Count));'].join('\n');
      }
      if (language === 'cast') {
        return [`# ${method.name} is WebSocket-only. cast has no native WebSocket support.`, '# Use wscat (npm i -g wscat):', `wscat -c ${ws}`, `> ${bodyJson}`].join('\n');
      }
      if (language === 'java') {
        return ['import java.net.URI;', 'import java.net.http.*;', 'import java.util.concurrent.CompletableFuture;', 'import java.util.concurrent.CompletionStage;', '', 'var done = new CompletableFuture<Void>();', 'HttpClient.newHttpClient().newWebSocketBuilder()', `    .buildAsync(URI.create("${ws}"), new WebSocket.Listener() {`, '        public void onOpen(WebSocket ws) {', `            ws.sendText("${csBody}", true); ws.request(1);`, '        }', '        public CompletionStage<?> onText(WebSocket ws, CharSequence data, boolean last) {', '            System.out.println(data); done.complete(null); return null;', '        }', '    }).join();', 'done.join();'].join('\n');
      }
      if (language === 'kotlin') {
        return ['import java.net.URI', 'import java.net.http.*', 'import java.util.concurrent.CompletableFuture', 'import java.util.concurrent.CompletionStage', '', 'val done = CompletableFuture<Void>()', 'HttpClient.newHttpClient().newWebSocketBuilder()', `    .buildAsync(URI.create("${ws}"), object : WebSocket.Listener {`, '        override fun onOpen(ws: WebSocket) {', `            ws.sendText("${csBody}", true); ws.request(1)`, '        }', '        override fun onText(ws: WebSocket, data: CharSequence, last: Boolean): CompletionStage<*>? {', '            println(data); done.complete(null); ws.request(1); return null', '        }', '    }).join()', 'done.join()'].join('\n');
      }
      if (language === 'swift') {
        return ['import Foundation', '', `let task = URLSession.shared.webSocketTask(with: URL(string: "${ws}")!)`, 'task.resume()', `try await task.send(.string(#"${bodyJson}"#))`, 'let msg = try await task.receive()', 'if case .string(let text) = msg { print(text) }', 'task.cancel(with: .normalClosure, reason: nil)'].join('\n');
      }
      return [`# ${method.name} is WebSocket-only. Use wscat (npm i -g wscat):`, `wscat -c ${ws}`, `> ${bodyJson}`].join('\n');
    }
    if (language === 'javascript') {
      return ['// fetch', `const res = await fetch('${url}', {`, "  method: 'POST',", "  headers: { 'Content-Type': 'application/json' },", '  body: JSON.stringify({', "    jsonrpc: '2.0', id: 1,", `    method: '${method.name}',`, `    params: ${paramsJson},`, '  }),', '});', 'console.log((await res.json()).result);', '', '// ethers v6', "import { JsonRpcProvider } from 'ethers';", `const provider = new JsonRpcProvider('${url}');`, `console.log(await provider.send('${method.name}', ${paramsJson}));`, '', '// viem', "import { createPublicClient, http } from 'viem';", `const client = createPublicClient({ transport: http('${url}') });`, `console.log(await client.request({ method: '${method.name}', params: ${paramsJson} }));`].join('\n');
    }
    if (language === 'typescript') {
      return ['type RpcResponse<T> = {', '  jsonrpc: string; id: number;', '  result?: T; error?: { code: number; message: string };', '};', '', `const res = await fetch('${url}', {`, "  method: 'POST',", "  headers: { 'Content-Type': 'application/json' },", '  body: JSON.stringify({', "    jsonrpc: '2.0', id: 1,", `    method: '${method.name}',`, `    params: ${paramsJson},`, '  }),', '});', 'const data: RpcResponse<unknown> = await res.json();', 'console.log(data.result);', '', '// ethers v6', "import { JsonRpcProvider } from 'ethers';", `const provider = new JsonRpcProvider('${url}');`, `console.log(await provider.send('${method.name}', ${paramsJson}));`].join('\n');
    }
    if (language === 'python') {
      return ['import requests, json', '', `url = "${url}"`, `params = json.loads(r"""${paramsJson}""")`, 'res = requests.post(url, json={', '    "jsonrpc": "2.0", "id": 1,', `    "method": "${method.name}", "params": params,`, '})', 'print(res.json().get("result"))', '', '# web3.py', 'from web3 import Web3', 'w3 = Web3(Web3.HTTPProvider(url))', `print(w3.provider.make_request("${method.name}", params))`].join('\n');
    }
    if (language === 'go') {
      return ['package main', '', 'import (', '\t"bytes"', '\t"fmt"', '\t"io"', '\t"net/http"', ')', '', 'func main() {', '\tbody := []byte(' + BT + bodyJson + BT + ')', `\tresp, err := http.Post("${url}", "application/json", bytes.NewBuffer(body))`, '\tif err != nil {', '\t\tpanic(err)', '\t}', '\tdefer resp.Body.Close()', '\tout, _ := io.ReadAll(resp.Body)', '\tfmt.Println(string(out))', '}'].join('\n');
    }
    if (language === 'rust') {
      return ['// reqwest = { version = "0.12", features = ["json"] }', '// serde_json = "1"   tokio = { version = "1", features = ["full"] }', 'use serde_json::Value;', '', '#[tokio::main]', 'async fn main() -> Result<(), Box<dyn std::error::Error>> {', '    let body: Value = serde_json::from_str(r#"' + bodyJson + '"#)?;', `    let res = reqwest::Client::new().post("${url}")`, '        .json(&body).send().await?', '        .json::<Value>().await?;', '    println!("{:#?}", res["result"]);', '    Ok(())', '}'].join('\n');
    }
    if (language === 'csharp') {
      return ['using System;', 'using System.Net.Http;', 'using System.Text;', '', 'using var http = new HttpClient();', `var json = "${csBody}";`, 'var content = new StringContent(json, Encoding.UTF8, "application/json");', `var res = await http.PostAsync("${url}", content);`, 'Console.WriteLine(await res.Content.ReadAsStringAsync());'].join('\n');
    }
    if (language === 'cast') {
      const castArgs = params.map(p => `'${JSON.stringify(p)}'`).join(' ');
      return `cast rpc --rpc-url ${url} ${method.name}${params.length ? ' ' + castArgs : ''}`;
    }
    if (language === 'java') {
      return ['import java.net.URI;', 'import java.net.http.*;', '', `var json = "${csBody}";`, `var req = HttpRequest.newBuilder(URI.create("${url}"))`, '    .header("Content-Type", "application/json")', '    .POST(HttpRequest.BodyPublishers.ofString(json))', '    .build();', 'var res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());', 'System.out.println(res.body());'].join('\n');
    }
    if (language === 'kotlin') {
      return ['import java.net.URI', 'import java.net.http.HttpClient', 'import java.net.http.HttpRequest', 'import java.net.http.HttpResponse', '', `val json = "${csBody}"`, `val req = HttpRequest.newBuilder(URI.create("${url}"))`, '    .header("Content-Type", "application/json")', '    .POST(HttpRequest.BodyPublishers.ofString(json))', '    .build()', 'val res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString())', 'println(res.body())'].join('\n');
    }
    if (language === 'swift') {
      return ['import Foundation', '', `let url = URL(string: "${url}")!`, 'var request = URLRequest(url: url)', 'request.httpMethod = "POST"', 'request.setValue("application/json", forHTTPHeaderField: "Content-Type")', `request.httpBody = Data(#"${bodyJson}"#.utf8)`, '', 'let (data, _) = try await URLSession.shared.data(for: request)', 'print(String(decoding: data, as: UTF8.self))'].join('\n');
    }
    const curlBody = bodyJson.replace(/'/g, "'\\''");
    return `curl -s -X POST ${url} \\\n  -H "Content-Type: application/json" \\\n  -d '${curlBody}'`;
  }, [endpoint, wsEndpoint, debouncedParams]);
  const codeExample = useMemo(() => generateCode(selectedMethod, selectedLanguage), [selectedMethod, selectedLanguage, generateCode]);
  const c = {
    bg: isDark ? '#000000' : '#f5f5f7',
    panel: isDark ? '#0a0a0a' : '#ffffff',
    panel2: isDark ? '#121212' : '#f5f5f7',
    border: isDark ? '#1f1f1f' : '#ececee',
    text: isDark ? '#ffffff' : '#131313',
    sub: isDark ? '#9ca3af' : '#666666',
    faint: isDark ? '#6b7280' : '#999999',
    input: isDark ? '#161616' : '#ffffff',
    code: isDark ? '#0d0d0d' : '#1a1a1a',
    maroon: '#600014'
  };
  const mono = 'var(--sei-font-mono, ui-monospace, "SF Mono", Menlo, monospace)';
  const bd = '1px solid ' + c.border;
  const fieldStyle = {
    width: '100%',
    fontSize: 12,
    fontFamily: mono,
    padding: '7px 10px',
    background: c.input,
    color: c.text,
    border: bd,
    borderRadius: 4,
    outline: 'none',
    boxSizing: 'border-box'
  };
  const statusColor = s => isDark ? STATUS_META[s].dark : STATUS_META[s].light;
  const StatusDot = ({status}) => <span title={STATUS_META[status].label} style={{
    display: 'inline-block',
    width: 7,
    height: 7,
    borderRadius: 9,
    background: statusColor(status),
    flexShrink: 0
  }} />;
  const Badge = ({status}) => <span style={{
    fontSize: 11,
    fontWeight: 600,
    padding: '2px 8px',
    borderRadius: 3,
    color: statusColor(status),
    background: statusColor(status) + '22',
    border: `1px solid ${statusColor(status)}55`
  }}>
      {STATUS_META[status].label}
    </span>;
  const CopyBtn = ({text, k}) => <button onClick={() => copy(text, k)} style={{
    fontSize: 11,
    color: c.sub,
    background: 'transparent',
    border: bd,
    borderRadius: 3,
    padding: '3px 8px',
    cursor: 'pointer'
  }}>
      {copied === k ? 'Copied' : 'Copy'}
    </button>;
  const CodeBlock = ({text, maxHeight}) => <pre style={{
    margin: 0,
    padding: 14,
    borderRadius: 4,
    background: c.code,
    border: bd,
    overflowX: 'auto',
    maxHeight
  }}>
      <code style={{
    fontFamily: mono,
    fontSize: 12,
    color: '#d4d4d4',
    whiteSpace: 'pre',
    lineHeight: 1.6
  }}>{text}</code>
    </pre>;
  const m = selectedMethod;
  const mMeta = m ? NAMESPACE_META[m.namespace] || ({}) : {};
  return <div ref={rootRef} className="not-prose rpc-explorer-root" style={{
    fontFamily: 'var(--sei-font-body, inherit)',
    color: c.text,
    background: c.bg,
    border: bd,
    borderRadius: 6,
    overflow: 'hidden',
    display: 'flex',
    flexDirection: 'column',
    height: '96vh',
    minHeight: 768
  }}>
      <div style={{
    borderBottom: bd,
    background: c.panel,
    padding: '14px 18px',
    display: 'flex',
    flexDirection: 'column',
    gap: 12,
    flexShrink: 0
  }}>
        <div>
          <div style={{
    fontSize: 16,
    fontWeight: 700,
    letterSpacing: '-0.01em'
  }}>Sei EVM JSON-RPC Explorer</div>
          <div style={{
    fontSize: 12,
    color: c.sub,
    marginTop: 2
  }}>
            {allMethods.length} methods · {counts.supported} supported · {counts.limited} limited · {counts.unsupported} unavailable
          </div>
        </div>
        <div style={{
    display: 'flex',
    gap: 8,
    alignItems: 'center',
    flexWrap: 'wrap'
  }}>
          {}
          <div style={{
    display: 'flex',
    border: bd,
    borderRadius: 4,
    overflow: 'hidden'
  }}>
            {['mainnet', 'testnet', 'custom'].map(n => <button key={n} onClick={() => {
    setNetwork(n);
    setConnection('idle');
  }} style={{
    fontSize: 12,
    padding: '6px 12px',
    cursor: 'pointer',
    border: 'none',
    textTransform: 'capitalize',
    background: network === n ? c.maroon : 'transparent',
    color: network === n ? '#fff' : c.sub,
    fontWeight: network === n ? 600 : 400
  }}>
                {n}
              </button>)}
          </div>
          {network === 'custom' ? <input value={customEndpoint} onChange={e => {
    setCustomEndpoint(e.target.value);
    setConnection('idle');
  }} onBlur={validateEndpoint} placeholder="https://your-rpc" style={{
    fontSize: 12,
    fontFamily: mono,
    padding: '6px 10px',
    width: 220,
    background: c.input,
    color: c.text,
    border: bd,
    borderRadius: 4,
    outline: 'none'
  }} /> : <code style={{
    fontSize: 12,
    fontFamily: mono,
    color: c.sub,
    padding: '5px 10px',
    background: c.panel2,
    borderRadius: 4,
    border: bd,
    maxWidth: '100%',
    overflowWrap: 'anywhere'
  }}>{endpoint}</code>}
          <span title={connection === 'ok' ? 'Reachable' : connection === 'fail' ? 'Unreachable from this browser' : 'Not checked'} style={{
    display: 'inline-flex',
    alignItems: 'center',
    gap: 5,
    fontSize: 11,
    color: connection === 'ok' ? '#22c55e' : connection === 'fail' ? '#ef4444' : c.faint
  }}>
            <span style={{
    width: 8,
    height: 8,
    borderRadius: 9,
    background: connection === 'ok' ? '#22c55e' : connection === 'fail' ? '#ef4444' : c.faint
  }} />
            {connection === 'ok' ? 'Live' : connection === 'fail' ? 'Offline' : '—'}
          </span>
        </div>
      </div>

      {}
      <div style={{
    flex: 1,
    display: 'flex',
    overflow: 'hidden'
  }}>
        {}
        <div style={{
    width: isMobile ? '100%' : 320,
    flexShrink: 0,
    display: isMobile && mobileView !== 'list' ? 'none' : 'flex',
    flexDirection: 'column',
    borderRight: isMobile ? 'none' : bd,
    background: c.panel,
    overflow: 'hidden'
  }}>
          <div style={{
    padding: 14,
    borderBottom: bd
  }}>
            <input value={searchTerm} onChange={e => setSearchTerm(e.target.value)} placeholder="Search methods…" style={{
    width: '100%',
    fontSize: 13,
    padding: '8px 12px',
    background: c.input,
    color: c.text,
    border: bd,
    borderRadius: 4,
    outline: 'none',
    boxSizing: 'border-box'
  }} />
            <div style={{
    display: 'flex',
    flexWrap: 'wrap',
    gap: 5,
    marginTop: 10
  }}>
              <button onClick={() => setSelectedNamespace('all')} style={{
    fontSize: 11,
    padding: '3px 9px',
    borderRadius: 3,
    cursor: 'pointer',
    fontWeight: 600,
    border: `1px solid ${selectedNamespace === 'all' ? c.maroon : c.border}`,
    background: selectedNamespace === 'all' ? c.maroon : 'transparent',
    color: selectedNamespace === 'all' ? '#fff' : c.sub
  }}>
                All
              </button>
              {visibleNamespaces.map(ns => {
    const active = selectedNamespace === ns;
    const col = NAMESPACE_META[ns].color;
    return <button key={ns} onClick={() => setSelectedNamespace(ns)} style={{
      fontSize: 11,
      padding: '3px 9px',
      borderRadius: 3,
      cursor: 'pointer',
      fontWeight: 600,
      border: `1px solid ${col}`,
      background: active ? col : 'transparent',
      color: active ? '#fff' : isDark ? col : col,
      opacity: active ? 1 : 0.85
    }}>
                    {NAMESPACE_META[ns].label}
                  </button>;
  })}
            </div>
            <label style={{
    display: 'flex',
    alignItems: 'center',
    gap: 7,
    marginTop: 11,
    fontSize: 12,
    color: c.sub,
    cursor: 'pointer'
  }}>
              <input type="checkbox" checked={showAll} onChange={e => {
    const next = e.target.checked;
    setShowAll(next);
    if (!next) {
      if (selectedNamespace !== 'all') {
        const meta = NAMESPACE_META[selectedNamespace];
        if (meta && (meta.deprecated || meta.unavailable)) setSelectedNamespace('all');
      }
      if (selectedMethod && isHiddenByDefault(selectedMethod)) {
        runIdRef.current++;
        setSelectedMethod(null);
        setRequestResult(null);
        setIsLoading(false);
      }
    }
  }} style={{
    accentColor: c.maroon
  }} />
              Show deprecated & unavailable methods
            </label>
          </div>
          <div style={{
    flex: 1,
    overflowY: 'auto'
  }}>
            {filteredMethods.length === 0 && <div style={{
    padding: 24,
    fontSize: 13,
    color: c.faint,
    textAlign: 'center'
  }}>No methods match.</div>}
            {filteredMethods.map(mm => {
    const active = m && m.name === mm.name;
    return <button key={mm.name} onClick={() => selectMethod(mm)} style={{
      width: '100%',
      textAlign: 'left',
      padding: '9px 13px 9px 12px',
      cursor: 'pointer',
      border: 'none',
      borderLeft: `3px solid ${mm.meta.color}`,
      borderBottom: bd,
      background: active ? isDark ? '#161616' : '#f0eef0' : 'transparent',
      display: 'block',
      opacity: mm.status === 'unsupported' ? 0.6 : 1
    }}>
                  <div style={{
      display: 'flex',
      alignItems: 'center',
      gap: 7
    }}>
                    <StatusDot status={mm.status} />
                    <code style={{
      fontFamily: mono,
      fontSize: 12.5,
      color: active ? c.text : isDark ? '#e5e5e5' : '#1a1a1a',
      fontWeight: active ? 600 : 500,
      whiteSpace: 'nowrap',
      overflow: 'hidden',
      textOverflow: 'ellipsis'
    }}>{mm.name}</code>
                  </div>
                  <div style={{
      fontSize: 11.5,
      color: c.faint,
      marginTop: 3,
      lineHeight: 1.35,
      display: '-webkit-box',
      WebkitLineClamp: 2,
      WebkitBoxOrient: 'vertical',
      overflow: 'hidden'
    }}>{mm.description}</div>
                </button>;
  })}
          </div>
        </div>

        {}
        <div style={{
    flex: 1,
    display: isMobile && mobileView !== 'detail' ? 'none' : 'flex',
    flexDirection: 'column',
    overflowY: 'auto',
    background: c.bg
  }}>
          {!m ? <div style={{
    flex: 1,
    display: 'flex',
    alignItems: 'center',
    justifyContent: 'center',
    color: c.faint,
    fontSize: 14,
    padding: 24,
    textAlign: 'center'
  }}>
              Select a method to see its reference, parameters, and runnable examples.
            </div> : <div style={{
    padding: isMobile ? 16 : 24,
    maxWidth: 860
  }}>
              {isMobile && <button onClick={() => setMobileView('list')} style={{
    fontSize: 12,
    color: c.sub,
    background: 'transparent',
    border: 'none',
    cursor: 'pointer',
    padding: 0,
    marginBottom: 12
  }}>← Methods</button>}
              <div style={{
    display: 'flex',
    alignItems: 'center',
    gap: 10,
    flexWrap: 'wrap'
  }}>
                <code style={{
    fontFamily: mono,
    fontSize: 19,
    fontWeight: 700,
    color: c.text
  }}>{m.name}</code>
                <Badge status={m.status} />
                <span style={{
    fontSize: 11,
    padding: '2px 8px',
    borderRadius: 3,
    color: '#fff',
    background: mMeta.color
  }}>{mMeta.label}</span>
              </div>
              <p style={{
    fontSize: 14,
    color: c.sub,
    marginTop: 10,
    lineHeight: 1.55
  }}>{m.description}</p>

              {mMeta.deprecated && <div style={{
    marginTop: 14,
    padding: '10px 14px',
    borderRadius: 4,
    background: '#f59e0b18',
    border: '1px solid #f59e0b55',
    fontSize: 12.5,
    color: isDark ? '#fbbf24' : '#92400e',
    lineHeight: 1.5
  }}>
                  <strong>Deprecated.</strong> The <code style={{
    fontFamily: mono
  }}>{m.namespace}_*</code> surface is scheduled for removal and is gated by <code style={{
    fontFamily: mono
  }}>enabled_legacy_sei_apis</code> in <code style={{
    fontFamily: mono
  }}>app.toml</code>. Prefer standard <code style={{
    fontFamily: mono
  }}>eth_*</code>/<code style={{
    fontFamily: mono
  }}>debug_*</code> methods for new integrations.
                </div>}
              {mMeta.unavailable && <div style={{
    marginTop: 14,
    padding: '10px 14px',
    borderRadius: 4,
    background: isDark ? '#ffffff0a' : '#0000000a',
    border: bd,
    fontSize: 12.5,
    color: c.sub,
    lineHeight: 1.5
  }}>
                  The entire <code style={{
    fontFamily: mono
  }}>{m.namespace}_*</code> namespace is not exposed on Sei. {mMeta.blurb}
                </div>}
              {m.seiNote && <div style={{
    marginTop: 14,
    padding: '12px 14px',
    borderRadius: 4,
    background: c.maroon + (isDark ? '22' : '12'),
    border: `1px solid ${c.maroon}${isDark ? '66' : '44'}`,
    fontSize: 12.5,
    color: isDark ? '#e9b8c0' : '#600014',
    lineHeight: 1.55
  }}>
                  <div style={{
    fontWeight: 700,
    marginBottom: 4,
    fontSize: 11,
    letterSpacing: '0.04em',
    textTransform: 'uppercase'
  }}>Sei-specific behavior</div>
                  {m.seiNote}
                </div>}

              {}
              {m.params && m.params.length > 0 && <div style={{
    marginTop: 22
  }}>
                  <div style={{
    fontSize: 13,
    fontWeight: 700,
    marginBottom: 10
  }}>Parameters</div>
                  <div style={{
    display: 'flex',
    flexDirection: 'column',
    gap: 8
  }}>
                    {m.params.map(p => <div key={p.name} style={{
    padding: '10px 13px',
    borderRadius: 4,
    background: c.panel2,
    border: bd
  }}>
                        <div style={{
    display: 'flex',
    alignItems: 'center',
    gap: 8,
    flexWrap: 'wrap'
  }}>
                          <code style={{
    fontFamily: mono,
    fontSize: 12.5,
    color: isDark ? '#e9b8c0' : c.maroon,
    fontWeight: 600
  }}>{p.name}</code>
                          <span style={{
    fontSize: 10.5,
    padding: '1px 7px',
    borderRadius: 3,
    color: c.sub,
    background: isDark ? '#ffffff10' : '#00000008',
    border: bd,
    fontFamily: mono
  }}>{p.type}</span>
                        </div>
                        <div style={{
    fontSize: 12.5,
    color: c.sub,
    marginTop: 5,
    lineHeight: 1.5
  }}>{p.description}</div>
                      </div>)}
                  </div>
                </div>}

              {}
              {m.status !== 'unsupported' && <div style={{
    marginTop: 22
  }}>
                  <div style={{
    fontSize: 13,
    fontWeight: 700,
    marginBottom: 10,
    display: 'flex',
    alignItems: 'center',
    gap: 8
  }}>
                    Try it
                    <span style={{
    fontSize: 11,
    fontWeight: 400,
    color: c.faint
  }}>· {network === 'custom' ? endpoint || 'set a custom endpoint' : NETWORKS[network].label}</span>
                  </div>

                  {isWsOnly(m.name) && <div style={{
    padding: '10px 14px',
    borderRadius: 4,
    background: c.panel2,
    border: bd,
    fontSize: 12.5,
    color: c.sub,
    lineHeight: 1.5,
    marginBottom: 10
  }}>
                      This is a WebSocket subscription method. Connect to <code style={{
    fontFamily: mono
  }}>{wsEndpoint}</code> and send the payload below — edit the parameters to customize the subscription.
                      {network === 'custom' && ' This URL is derived from your HTTP endpoint as a best guess; Sei serves WebSocket on a separate host (evm-ws…) from HTTP (evm-rpc…), so replace it with your node’s actual WebSocket endpoint if they differ.'}
                    </div>}
                  {m.params && m.params.length > 0 && <div style={{
    display: 'flex',
    flexDirection: 'column',
    gap: 8,
    marginBottom: 10
  }}>
                      {m.params.map(p => {
    const ex = p.example || '';
    const big = ex.trim().startsWith('{') || ex.trim().startsWith('[') || (p.type || '').toLowerCase().includes('object');
    const fieldId = `rpc-param-${p.name}`;
    const field = {
      id: fieldId,
      value: paramValues[p.name] !== undefined ? paramValues[p.name] : '',
      onChange: e => setParamValues(prev => ({
        ...prev,
        [p.name]: e.target.value
      })),
      placeholder: ex
    };
    return <div key={p.name}>
                            <label htmlFor={fieldId} style={{
      fontSize: 11,
      color: c.faint,
      fontFamily: mono,
      display: 'block',
      marginBottom: 3
    }}>{p.name}</label>
                            {big ? <textarea rows={2} {...field} style={{
      ...fieldStyle,
      resize: 'vertical'
    }} /> : <input {...field} style={fieldStyle} />}
                          </div>;
  })}
                    </div>}
                  {isMutation(m.name) && <div style={{
    fontSize: 11.5,
    color: c.faint,
    marginBottom: 8,
    lineHeight: 1.45
  }}>
                      This is a state-changing / signing method. Public RPC nodes hold no keys, so it generally errors unless you supply a signed payload.
                    </div>}

                  {}
                  <div style={{
    marginTop: 12
  }}>
                    <div style={{
    display: 'flex',
    justifyContent: 'space-between',
    alignItems: 'center',
    marginBottom: 8,
    flexWrap: 'wrap',
    gap: 8
  }}>
                      <div style={{
    fontSize: 12,
    fontWeight: 700,
    color: c.sub
  }}>Request</div>
                      <div style={{
    display: 'flex',
    gap: 8,
    alignItems: 'center'
  }}>
                        <div style={{
    display: 'flex',
    gap: 3,
    flexWrap: 'wrap'
  }}>
                          {LANGUAGES.map(l => <button key={l.id} onClick={() => setSelectedLanguage(l.id)} style={{
    fontSize: 11,
    padding: '3px 9px',
    borderRadius: 3,
    cursor: 'pointer',
    border: 'none',
    background: selectedLanguage === l.id ? c.maroon : isDark ? '#161616' : '#ececee',
    color: selectedLanguage === l.id ? '#fff' : c.sub
  }}>
                              {l.name}
                            </button>)}
                        </div>
                        <CopyBtn text={codeExample} k="code" />
                      </div>
                    </div>
                    <CodeBlock text={codeExample} />
                  </div>

                  {}
                  {!isWsOnly(m.name) && <div style={{
    marginTop: 14
  }}>
                      <button onClick={execute} disabled={isLoading || !endpoint} style={{
    fontSize: 13,
    fontWeight: 600,
    padding: '8px 18px',
    borderRadius: 4,
    cursor: isLoading || !endpoint ? 'not-allowed' : 'pointer',
    border: 'none',
    background: c.maroon,
    color: '#fff',
    opacity: isLoading || !endpoint ? 0.55 : 1
  }}>
                        {isLoading ? 'Running…' : 'Run request'}
                      </button>
                      {requestResult && <div style={{
    marginTop: 12
  }}>
                          <div style={{
    display: 'flex',
    justifyContent: 'space-between',
    alignItems: 'center',
    marginBottom: 6
  }}>
                            <span style={{
    fontSize: 11,
    color: requestResult.error ? '#ef4444' : '#22c55e',
    fontWeight: 600
  }}>{requestResult.error ? 'Error' : 'Result'}</span>
                            <CopyBtn text={JSON.stringify(requestResult, null, 2)} k="resp" />
                          </div>
                          <CodeBlock text={JSON.stringify(requestResult, null, 2)} maxHeight={280} />
                        </div>}
                    </div>}
                </div>}
            </div>}
        </div>
      </div>
    </div>;
};

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.

<RPCMethodsViewer />

<Note>
  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](#sei-custom-endpoints).
</Note>

## Overview

Sei supports the [Ethereum JSON-RPC API](https://ethereum.org/en/developers/docs/apis/json-rpc/) with some Sei-specific extensions to support cross-VM operations, synthetic transactions, and other advanced features. Because Sei has [instant finality](/evm/differences-with-ethereum#finality), the `safe`, `finalized`, and `latest` block tags all resolve to the same (latest committed) block.

All endpoints follow the standard JSON-RPC format:

<Accordion title="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
</Accordion>

### 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](/learn/rpc-providers) and [Chains & endpoints](/learn/dev-chains).

### Filter and subscription limits

<Info>
  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](/evm/evm-parity/websocket) for transport details.
</Info>

## 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](/evm/differences-with-ethereum#finality). The deprecated `sei_*`/`sei2_*` extensions are documented separately under [Sei custom endpoints](#sei-custom-endpoints).

<Accordion title="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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_sign",
    "params": [
      "0xDa52B9E673d1f48FcD9916b3F606A136a8eA5e55",
      "0xdeadbeef"
    ]
  }
  ```
</Accordion>

<Accordion title="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. 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:**

  ```json theme={"dark"}
  {
    "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.

  **Parameters:**

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

  **Example request:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getVMError",
    "params": [
      "0x828c91592453fe7c5bf743204495a35bf02b67b579b8f59ee7eea8af031d7c14"
    ]
  }
  ```
</Accordion>

<Accordion title="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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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.

  **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:**

  ```json theme={"dark"}
  {
    "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.
</Accordion>

<Accordion title="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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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 EVM transactions only (via getEvmTxCount); synthetic/bank-transfer txs are excluded. Genesis returns 0x0; non-existent/future blocks return null.

  **Parameters:**

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

  **Example request:**

  ```json theme={"dark"}
  {
    "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.

  **Parameters:**

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

  **Example request:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_getBlockReceipts",
    "params": [
      "latest"
    ]
  }
  ```
</Accordion>

<Accordion title="Blockchain information">
  #### `eth_blockNumber`

  **Supported.** Returns the number of the most recent committed EVM block as a hex uint64.

  **Sei-specific behavior:** Block height comes from CometBFT latest height; the latest committed block is already final on Sei (instant finality, so latest == safe == finalized).

  **Parameters:** none.

  #### `eth_chainId`

  **Supported.** Returns the EVM chain ID as a hex big int.

  **Sei-specific behavior:** Sourced from the x/evm keeper. Mainnet (pacific-1) = 1329 (0x531); testnet (atlantic-2) = 1328 (0x530).

  **Parameters:** none.

  #### `eth_coinbase`

  **Limited.** Returns the block reward beneficiary (coinbase) address.

  **Sei-specific behavior:** Sei has no miner; this returns the Cosmos fee-collector module address (GetFeeCollectorAddress), not a validator/miner address. The COINBASE opcode returns the same value.

  **Parameters:** none.

  #### `eth_gasPrice`

  **Limited.** Returns a suggested gas price in wei (hex).

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

  **Parameters:** none.

  #### `eth_maxPriorityFeePerGas`

  **Limited.** Returns a suggested priority fee (tip) per gas in wei (hex).

  **Sei-specific behavior:** Sei-specific: returns a hardcoded 1 gwei (defaultPriorityFeePerGas) when the chain is uncongested; only when congested does it derive the tip from the previous block's 50th-percentile reward. Sei docs advise using a single gasPrice and omitting EIP-1559 fee fields.

  **Parameters:** none.

  #### `eth_feeHistory`

  **Supported.** Returns base fees, gas-used ratios, and reward percentile data over a range of blocks.

  **Sei-specific behavior:** Base fees and rewards reflect Sei's x/evm fee market (GetNextBaseFee), not an Ethereum EIP-1559 mempool, and Sei does not burn the base fee. Watermark-aware: pruned/historical blocks may not be available as far back as on Ethereum archive nodes.

  **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:**

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

  #### `net_version`

  **Supported.** Returns the network/chain ID as a decimal string.

  **Sei-specific behavior:** Returns the EVM chain ID in decimal (alias of eth\_chainId): '1329' on pacific-1 mainnet, '1328' on atlantic-2 testnet.

  **Parameters:** none.

  #### `web3_clientVersion`

  **Supported.** Returns the client version string.

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

  **Parameters:** none.
</Accordion>

<Accordion title="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:**

  ```json theme={"dark"}
  {
    "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.

  **Parameters:**

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

  **Example request:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_uninstallFilter",
    "params": [
      "0x1"
    ]
  }
  ```

  #### `eth_subscribe`

  **Limited.** Opens a WebSocket-only push subscription for newHeads or logs notifications.

  **Sei-specific behavior:** WebSocket-only (SubscriptionAPI is not registered on the HTTP server; returns rpc.ErrNotificationsUnsupported over HTTP). Only 'newHeads' and 'logs' are implemented in source; there is no 'newPendingTransactions' subscription despite some client docs implying otherwise. newHeads subscriptions are capped by MaxSubscriptionsNewHead.

  **Parameters:**

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

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

  **Example request:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_unsubscribe",
    "params": [
      "0x9cef478923ff08bf67fde6c64013158d"
    ]
  }
  ```
</Accordion>

<Accordion title="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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_createAccessList",
    "params": [
      {
        "to": "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7",
        "data": "0x"
      },
      "pending"
    ]
  }
  ```
</Accordion>

<Accordion title="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.
</Accordion>

<Accordion title="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.

  **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:**

  ```json theme={"dark"}
  {
    "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.

  **Parameters:**

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

  **Example request:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "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:**

  ```json theme={"dark"}
  {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "debug_traceStateAccess",
    "params": [
      "0x5c504ed432cb51138bcf09aa5e8a410dd4a1e204ef84bfed1be16dfba1b22060"
    ]
  }
  ```
</Accordion>

## 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.

<Warning>
  **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 methods pass through unchanged, with an optional `Sei-Legacy-RPC-Deprecation` HTTP response header signaling deprecation.
</Warning>

### 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`):

```toml theme={"dark"}
[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.

<Accordion title="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_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 failed traces                 |
  | `sei_getBlockByNumberExcludeTraceFail`      | Get block by number excluding failed traces               |
  | `sei_getTransactionReceiptExcludeTraceFail` | Get receipt excluding failed traces                       |
  | `sei_traceBlockByHashExcludeTraceFail`      | Trace block by hash excluding failed traces               |
  | `sei_traceBlockByNumberExcludeTraceFail`    | Trace block by number excluding failed traces             |

  **`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) |
</Accordion>

### 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.

```bash theme={"dark"}
# 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:

```ts theme={"dark"}
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](/learn/accounts) for the full association lifecycle and how the bidirectional mapping is established.

<Note>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.</Note>

### 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.

<Accordion title="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**

  ```json theme={"dark"}
  {
    "jsonrpc": "2.0",
    "method": "sei_getCosmosTx",
    "params": ["0xabc123..."],
    "id": 1
  }
  ```
</Accordion>

### Legacy Deprecation Error

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

```json theme={"dark"}
{
  "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.

---

URL: https://docs.sei.io/evm/tokens

# Viewing Tokens in MetaMask

> Learn how to view and manage different token types in MetaMask with Sei network, including ERC20 tokens, ERC721 NFTs.

#### ERC20 Tokens

To view ERC20 tokens in MetaMask, the process mirrors that on other EVM chains.
For tokens not automatically listed, you'll need to manually import them into
your wallet. Detailed instructions can be found
[here](https://support.metamask.io/manage-crypto/tokens/how-to-display-tokens-in-metamask/).

#### ERC721 NFTs

Viewing NFTs in MetaMask requires manual addition. Follow the steps provided
[here](https://support.metamask.io/manage-crypto/nfts/nft-tokens-in-your-metamask-wallet/)
to add and view your NFTs in the wallet.

---

URL: https://docs.sei.io/evm/analytics-setup

# Analytics Setup

> Comprehensive guide on how to set up analytics for your project

## Overview

Setting up analytics for your project helps track user activity, transaction counts, and project growth. This guide walks you through integrating with three key platforms that provide comprehensive insights into your project's performance.

**What you'll set up:**

* Token Terminal
* Artemis
* Dune Analytics

**Time required:** 20-25 minutes

## Step 1: Sei Ecosystem Directory + Token Terminal

The Monday form registers your project in the Sei ecosystem directory and automatically submits it to Token Terminal.

**Complete the Monday Form** : [Monday Form](http://forms.monday.com/forms/b6816df94378117836cd0d4046d7213b?r=apse2)

**What happens next:**

* Your project appears in the Sei ecosystem directory
* Token Terminal automatically receives your project info
* Metrics begin tracking within 48-72 hours

## Step 2: Artemis Analytics

Artemis provides detailed user activity and transaction analytics for your project.

**Complete Artemis Application** : [Artemis Application Form](https://ry0v9n8oa4l.typeform.com/to/sXX203Nk?typeform-source=app.artemisanalytics.com)

**Processing time:** 2-4 business days for approval

## Step 3: Dune Dashboard

Create custom analytics dashboards with detailed blockchain data.

**Follow the Sei Dune Guide** : [Dune Guide](/evm/dune)

**Setup process:**

1. Create a free Dune account
2. Use pre-built query templates in the above guide
3. Customize queries for your contract addresses
4. Build charts and visualizations
5. Set up automated data refresh

**Key metrics to track:**

* Daily transaction counts
* Unique wallet addresses
* Token transfer volumes
* Contract interaction patterns

**Setup time:** 10-15 minutes using templates

***

These analytics platforms will provide valuable insights as your project grows and help you make data-driven decisions about development and strategy.

---

URL: https://docs.sei.io/evm/ecosystem-contracts

# Ecosystem Contracts

> Comprehensive registry of smart contract addresses for projects building on Sei. Find verified contract addresses organized by project.

export const EcosystemContracts = () => {
  const ECOSYSTEM_CONTRACTS_DATA = [{
    Protocol: 'Common',
    'Contract Address': '0xB952578f3520EE8Ea45b7914994dcf4702cEe578',
    'Contract Name': 'Permit2'
  }, {
    Protocol: 'Common',
    'Contract Address': '0xcA11bde05977b3631167028862bE2a173976CA11',
    'Contract Name': 'Multicall3'
  }, {
    Protocol: 'Common',
    'Contract Address': '0x0000000000FFe8B47B3e2130213B802212439497',
    'Contract Name': 'ImmutableCreate2Factory'
  }, {
    Protocol: 'Common',
    'Contract Address': '0xce0042B868300000d44A59004Da54A005ffdcf9f',
    'Contract Name': 'SingletonFactory'
  }, {
    Protocol: 'Common',
    'Contract Address': '0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed',
    'Contract Name': 'CreateX'
  }, {
    Protocol: 'Account Abstraction',
    'Contract Address': '0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789',
    'Contract Name': 'EntryPoint v0.6.0'
  }, {
    Protocol: 'Account Abstraction',
    'Contract Address': '0x0000000071727De22E5E9d8BAf0edAc6f37da032',
    'Contract Name': 'EntryPoint v0.7.0'
  }, {
    Protocol: 'Account Abstraction',
    'Contract Address': '0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108',
    'Contract Name': 'EntryPoint v0.8.0 (+ EIP-7702)'
  }, {
    Protocol: 'Account Abstraction',
    'Contract Address': '0x433709009B8330FDa32311DF1C2AFA402eD8D009',
    'Contract Name': 'EntryPoint v0.9.0 (+ EIP-7702)'
  }, {
    Protocol: 'Account Abstraction',
    'Contract Address': '0x0A630a99Df908A81115A3022927Be82f9299987e',
    'Contract Name': 'SenderCreator v0.9'
  }, {
    Protocol: 'Saphyre',
    'Contract Address': '0x11da6463d6cb5a03411dbf5ab6f6bc3997ac7428',
    'Contract Name': 'SwapRouter02'
  }, {
    Protocol: 'Saphyre',
    'Contract Address': '0x179d9a5592bc77050796f7be28058c51ca575df4',
    'Contract Name': 'DragonswapV2Factory'
  }, {
    Protocol: 'Saphyre',
    'Contract Address': '0xe30fedd158a2e3b13e9badaeabafc5516e95e8c7',
    'Contract Name': 'WSEI'
  }, {
    Protocol: 'Saphyre',
    'Contract Address': '0x71f6b49ae1558357bbb5a6074f1143c46cbca03d',
    'Contract Name': 'DragonswapFactory'
  }, {
    Protocol: 'Saphyre',
    'Contract Address': '0x150b4A3088dFB06d92531D1cCa6E980FB9a270e1',
    'Contract Name': 'Dragonswap DS ERC 20'
  }, {
    Protocol: 'Saphyre',
    'Contract Address': '0xa4cf2f53d1195addde9e4d3aca54f556895712f2',
    'Contract Name': 'DragonswapRouter'
  }, {
    Protocol: 'Stargate',
    'Contract Address': '0xDe48600aA18Ae707f5D57e0FaafEC7C118ABaeb2',
    'Contract Name': 'FeeLibV1'
  }, {
    Protocol: 'Stargate',
    'Contract Address': '0x873cfB4bAe1Ab6A5DE753400e9d0616e10Dced22',
    'Contract Name': 'Treasurer'
  }, {
    Protocol: 'Stargate',
    'Contract Address': '0x1502FA4be69d526124D453619276FacCab275d3D',
    'Contract Name': 'TokenMessaging'
  }, {
    Protocol: 'Stargate',
    'Contract Address': '0x5c386D85b1B82FD9Db681b9176C8a4248bb6345B',
    'Contract Name': 'StargateOFT'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0x8138da4417340594aeea4be8fbc7693d9875b6cb',
    'Contract Name': 'PoolAddressesProviderRegistry'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0x5c57266688a4ad1d3ab61209ebcb967b84227642',
    'Contract Name': 'PoolAddressesProvider'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0xa1ce28cebab91d8df346d19970e4ee69a6989734',
    'Contract Name': 'AaveOracle'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0x127201e84ad4ee06ec15104cf083696d6354f8dd',
    'Contract Name': 'PullRewardsTransferStrategy'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0x4ec5e3f9a32aabd6af62b9a22188f429d65f39c7',
    'Contract Name': 'CollectorController'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0xbf63c919a8c15f4741e75c232c7be0d0af4d1d05',
    'Contract Name': 'InitializableAdminUpgradeabilityProxy'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0x69ea2c310a950e58984f4bec4accf2ece391dafd',
    'Contract Name': 'EmissionManager'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0xd078c43f88fbed47b3ce16dc361606b594c8f305',
    'Contract Name': 'Pool'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0x800f3e929686ec90eeaabb8b98ed1eff126d532c',
    'Contract Name': 'Collector'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0x60c82a40c57736a9c692c42e87a8849fb407f0d6',
    'Contract Name': 'AaveProtocolDataProvider'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0xf8157786e3401a7377becb7af288b84c8ee614e1',
    'Contract Name': 'InitializableImmutableAdminUpgradeabilityProxy'
  }, {
    Protocol: 'YEI',
    'Contract Address': '0x241995b768c1ae629eb5a6f3749c6e7b8c4d47f2',
    'Contract Name': 'ACLManager'
  }, {
    Protocol: 'CarbonDeFi',
    'Contract Address': '0xe4816658ad10bF215053C533cceAe3f59e1f1087',
    'Contract Name': 'Carbon Controller'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0x75FC67473A91335B5b8F8821277262a13B38c9b3',
    'Contract Name': 'v3 Core Factory'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0xa683c66045ad16abb1bCE5ad46A64d95f9A25785',
    'Contract Name': 'Universal Router'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0xB3309C48F8407651D918ca3Da4C45DE40109E641',
    'Contract Name': 'Proxy Admin'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0xE3dbcD53f4Ce1b06Ab200f4912BD35672e68f1FA',
    'Contract Name': 'Tick Lens'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0x454050C4c9190390981Ac4b8d5AFcd7aC65eEffa',
    'Contract Name': 'NFT Descriptor Library V1.3.0'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0x38EB9e62ABe4d3F70C0e161971F29593b8aE29FF',
    'Contract Name': 'Nonfungible Token Position Descriptor V1.3.0'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0x743E03cceB4af2efA3CC76838f6E8B50B63F184c',
    'Contract Name': 'Descriptor Proxy'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0x8B3c541c30f9b29560f56B9E44b59718916B69EF',
    'Contract Name': 'Nonfungible Token Position Manager'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0x6Aa54a43d7eEF5b239a18eed3Af4877f46522BCA',
    'Contract Name': 'v3 Migrator'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0xaa52bB8110fE38D0d2d2AF0B85C3A3eE622CA455',
    'Contract Name': 'v3 Staker'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0x807F4E281B7A3B324825C64ca53c69F0b418dE40',
    'Contract Name': 'Quoter V2'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0xdD489C75be1039ec7d843A6aC2Fd658350B067Cf',
    'Contract Name': 'Swap Router02'
  }, {
    Protocol: 'oku.trade',
    'Contract Address': '0xA9d71E1dd7ca26F26e656E66d6AA81ed7f745bf0',
    'Contract Name': 'Limit order registry'
  }, {
    Protocol: 'JellyVerse',
    'Contract Address': '0xfb43069f6d0473b85686a85f4ce4fc1fd8f00875',
    'Contract Name': 'Vault'
  }, {
    Protocol: 'Takara Lend',
    'Contract Address': '0x56A171Acb1bBa46D4fdF21AfBE89377574B8D9BD',
    'Contract Name': 'Comptroller'
  }, {
    Protocol: 'Takara Lend',
    'Contract Address': '0x71034bf5eC0FAd7aEE81a213403c8892F3d8CAeE',
    'Contract Name': 'Unitroller'
  }, {
    Protocol: 'Takara Lend',
    'Contract Address': '0x323917A279B209754B32Ab57a817c64ECfE2AF40',
    'Contract Name': 'MarketState'
  }, {
    Protocol: 'Takara Lend',
    'Contract Address': '0x68A92Be349d48766128C0Ae893Fc391859F9BC11',
    'Contract Name': 'MultiRewardDistributor'
  }, {
    Protocol: 'Takara Lend',
    'Contract Address': '0x8DF1265bFb778fFD08341c63e7C67367c0a60288',
    'Contract Name': 'ProxyAdmin'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x5512D5E89a29447462Ab6BBBcbD3fe6F0A0D9FDd',
    'Contract Name': 'vaultOriginalAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x6944BfDAcD00957715eCBCeAac3F49e07cB6f35F',
    'Contract Name': 'vaultFactoryAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x7c96Bf5203fA1584A81f160B9445EAB02bfa3E7B',
    'Contract Name': 'tokenizedStrategyAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0xE560fC83EA78028a95CCAb1ECD45039fFB62301C',
    'Contract Name': 'registryAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x43e60c59567996C5a1b27ca8719ADF6CA2bC407B',
    'Contract Name': 'releaseRegistryAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x79756b033390232a5A55B5D6571a7Bc1b11A2b93',
    'Contract Name': 'accountantAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x07428D1CdC20Ce70Ac5D06E44CCB9920F99ab447',
    'Contract Name': 'accountantFactoryAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x9CDdFFc79Ba597CCBBd6da6a81Cc1b1ef29FB4de',
    'Contract Name': 'keeperAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0xed6A3CD7591Df25bC92E42381d9c53E041B5ACAa',
    'Contract Name': 'baseAprOracleAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0xdF7F9020800c2B444ad524982Fc6cA5A30915811',
    'Contract Name': 'aaveStrategyAprOracleAddress'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x63E37028c1740303e8456962E6ddf98359FE0BDc',
    'Contract Name': 'vault-PITv1-AAVEv3-WSEI-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x0044f5f3F121beB7ef11c6cfBc45a56e80adFd6B',
    'Contract Name': 'strategy-PITv1-AAVEv3-WSEI-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x0f9BaCD61cf1fd9d038F41a8380dBd7A826470A7',
    'Contract Name': 'rewards-escrow-PITv1-AAVEv3-WSEI-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x1e3BcEb9AD3dc3f80820d29039C1A46e28d3A573',
    'Contract Name': 'vault-PITv1-AAVEv3-USDT-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x5E2BAF273586F747e406eB0fD0CAdAECe0f479Da',
    'Contract Name': 'strategy-PITv1-AAVEv3-USDT-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x3aEC64F4e285cFFD50605EB962455159d436d31B',
    'Contract Name': 'rewards-escrow-PITv1-AAVEv3-USDT-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x575E2291C6FDe8eEf7284CBd7Ff17615de75c47B',
    'Contract Name': 'vault-PITv1-AAVEv3-USDC-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x1eB5B573852897831414Fbd607c214EdB9b0B7Dd',
    'Contract Name': 'strategy-PITv1-AAVEv3-USDC-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x318253deCE357Ef0f75428C7369A180D60FD0971',
    'Contract Name': 'rewards-escrow-PITv1-AAVEv3-USDC-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x49561C4a905f7acCdaCAec5e3C17113d5f1C5a3b',
    'Contract Name': 'vault-PITv1-AAVEv3-iSEI-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0xA4A3B54665A5ef21ac5B294b8945Dd130aC6E5fc',
    'Contract Name': 'strategy-PITv1-AAVEv3-iSEI-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x130c58f93cE57121c97F524CD5171BDd258f4314',
    'Contract Name': 'rewards-escrow-PITv1-AAVEv3-iSEI-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0xE8d7f53173BB5D0C898e4D576E4E297cB2859472',
    'Contract Name': 'vault-PITv1-AAVEv3-FRAX-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0xCd6d59a116F0d4E370A62b8D6EA146dD02E2114A',
    'Contract Name': 'strategy-PITv1-AAVEv3-FRAX-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x9975f0d8560ed6a29C376ddc950f5663527327e8',
    'Contract Name': 'rewards-escrow-PITv1-AAVEv3-FRAX-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0x0AEfC6F2E9a866ddB4813Cb1E897a2E9e26a1E53',
    'Contract Name': 'vault-PITv1-AAVEv3-WETH-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0xE77790035f956E9C6E895e57cded63A7AC69F2c9',
    'Contract Name': 'strategy-PITv1-AAVEv3-WETH-LENDER-POOL'
  }, {
    Protocol: 'Pit',
    'Contract Address': '0xb4169a0cD663FB4A7762a71c9d0Dd0ddc18201e2',
    'Contract Name': 'rewards-escrow-PITv1-AAVEv3-WETH-LENDER-POOL'
  }, {
    Protocol: 'Symbiosis',
    'Contract Address': '0x292fC50e4eB66C3f6514b9E402dBc25961824D62',
    'Contract Name': 'Portal'
  }, {
    Protocol: 'Filament Finance',
    'Contract Address': '0xB28EAb5253f6a0f8a5B0a1120d9C03Db8Fc10C2f',
    'Contract Name': 'DiamondProxy'
  }, {
    Protocol: 'DonkeSwap',
    'Contract Address': '0x4B4746216214f9e972c5D35D3Fe88e6Ec4C28A6B',
    'Contract Name': 'DonkeV2Factory'
  }, {
    Protocol: 'Sailor Finance',
    'Contract Address': '0xd1EFe48B71Acd98Db16FcB9E7152B086647Ef544',
    'Contract Name': 'SwapRouter'
  }, {
    Protocol: 'Sailor Finance',
    'Contract Address': '0x4ed1F9Cc4ee6bc11b27e285464C4DCaF911c85d9',
    'Contract Name': 'NFTDescriptor'
  }, {
    Protocol: 'Sailor Finance',
    'Contract Address': '0xA51136931fdd3875902618bF6B3abe38Ab2D703b',
    'Contract Name': 'UniswapV3Factory'
  }, {
    Protocol: 'Sailor Finance',
    'Contract Address': '0x9aeB489F5bc0d3Eb7892DD7E1FAE2d2ebD02E80b',
    'Contract Name': 'Quoter'
  }, {
    Protocol: 'Sailor Finance',
    'Contract Address': '0xE40703878aC5d3F76eAc66f8688A8F5652Af85b1',
    'Contract Name': 'QuoterV2'
  }, {
    Protocol: 'Citrex',
    'Contract Address': '0x993543DC8BdFCba9fc7355d822108eF49dB6b9F9',
    'Contract Name': 'OrderDispatch'
  }, {
    Protocol: 'Citrex',
    'Contract Address': '0x7461cFe1A4766146cAFce60F6907Ea657550670d',
    'Contract Name': 'Ciao'
  }, {
    Protocol: 'Symphony',
    'Contract Address': '0xAD3DF981018149CD90e5869d14Efe2516b108270',
    'Contract Name': 'Symphony'
  }, {
    Protocol: 'Open Ocean',
    'Contract Address': '0x6352a56caadC4F1E25CD6c75970Fa768A3304e64',
    'Contract Name': 'OpenOceanExchangeProxy'
  }, {
    Protocol: 'DZap',
    'Contract Address': '0xb3926deF2e0989B0700a57034C9A211bfBcF858B',
    'Contract Name': 'DZapDiamond'
  }, {
    Protocol: 'OKX Dex',
    'Contract Address': '0x411d2C093e4c2e69Bf0D8E94be1bF13DaDD879c6',
    'Contract Name': 'DexRouter'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0xc9cDAc20FCeAAF616f7EB0bb6Cd2c69dcfa9094c',
    'Contract Name': 'Morpho'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0x6eFA8e3Aa8279eB2fd46b6083A9E52dA72EA56c4',
    'Contract Name': 'Adaptive Curve Irm'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0x4bD68c2FF3274207EC07ED281C915758b6F23F07',
    'Contract Name': 'Morpho ChainlinkOracleV2 Factory'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0x8Dea49ec5bd5AeAc8bcf96B3E187F59354118291',
    'Contract Name': 'MetaMorpho Factory V1.1'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0xD878509446bE2C601f0f032F501851001B159D6B',
    'Contract Name': 'Public Allocator'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0x65eD61058cEB4895B7d62437BaCEA39b04f6D27B',
    'Contract Name': 'PreLiquidation Factory'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0xF9457356F18A3349Bb317Ac144c3Bcc62e5761aD',
    'Contract Name': 'Bundler3'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0x02e0e71e145f254820B9D89c9E6068f08256F601',
    'Contract Name': 'GeneralAdapter1'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0x30f5b078c80bd06fedc3b40b4a4441a96dd9cf22',
    'Contract Name': 'VaultV2Factory'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0xbADd49F7db90f65fF5822681AA6B8548E8356a1D',
    'Contract Name': 'MorphoMarketV1AdapterV2Factory'
  }, {
    Protocol: 'Morpho',
    'Contract Address': '0x26abEaee65A878E9Fe8F99fEb31aec62fbA2624E',
    'Contract Name': 'MorphoRegistry'
  }, {
    Protocol: 'LayerZero',
    'Contract Address': '0x1a44076050125825900e736c501f859c50fE728c',
    'Contract Name': 'EndpointV2'
  }, {
    Protocol: 'Circle CCTP',
    'Contract Address': '0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d',
    'Contract Name': 'TokenMessengerV2'
  }, {
    Protocol: 'Circle CCTP',
    'Contract Address': '0x81D40F21F12A8F0E3252Bccb954D722d4c464B64',
    'Contract Name': 'MessageTransmitterV2'
  }, {
    Protocol: 'Circle CCTP',
    'Contract Address': '0xfd78EE919681417d192449715b2594ab58f5D002',
    'Contract Name': 'TokenMinterV2'
  }, {
    Protocol: 'Tokens',
    'Contract Address': '0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392',
    'Contract Name': 'USDC'
  }, {
    Protocol: 'Tokens',
    'Contract Address': '0x9151434b16b9763660705744891fA906F660EcC5',
    'Contract Name': 'USDT0'
  }, {
    Protocol: 'Tokens',
    'Contract Address': '0x54cD901491AeF397084453F4372B93c33260e2A6',
    'Contract Name': 'USDY (Ondo)'
  }, {
    Protocol: 'Splashing',
    'Contract Address': '0xC257361320F4514D91c05F461006CE6a0300E2d2',
    'Contract Name': 'spSEI Token'
  }, {
    Protocol: 'Splashing',
    'Contract Address': '0x151669B501b561a52ad95574603AD52546F46Bf4',
    'Contract Name': 'Staking Pool (Proxy)'
  }, {
    Protocol: 'Pyth',
    'Contract Address': '0x6dd1f8257e1fb3ef75f8d6aafae608b42cfc1270',
    'Contract Name': 'Pyth Oracle'
  }, {
    Protocol: 'Chainlink',
    'Contract Address': '0x60fAa7faC949aF392DFc858F5d97E3EEfa07E9EB',
    'Contract Name': 'VerifierProxy'
  }, {
    Protocol: 'Safe',
    'Contract Address': '0x914d7Fec6aaC8cd542e72Bca78B30650d45643d7',
    'Contract Name': 'SafeSingletonFactory'
  }];
  const nameKey = 'Contract Name';
  const addressKey = 'Contract Address';
  const [isDark, setIsDark] = useState(false);
  useEffect(() => {
    const el = document.documentElement;
    const update = () => setIsDark(el.classList.contains('dark'));
    update();
    const obs = new MutationObserver(update);
    obs.observe(el, {
      attributes: true,
      attributeFilter: ['class']
    });
    return () => obs.disconnect();
  }, []);
  const groupedData = useMemo(() => {
    const groups = {};
    for (const row of ECOSYSTEM_CONTRACTS_DATA) {
      const key = row.Protocol;
      if (!groups[key]) groups[key] = [];
      groups[key].push(row);
    }
    return Object.entries(groups).map(([projectName, contracts]) => ({
      projectName,
      contracts,
      contractCount: contracts.length
    }));
  }, []);
  const [query, setQuery] = useState('');
  const [openSections, setOpenSections] = useState({});
  const [pendingScrollId, setPendingScrollId] = useState(null);
  const slugify = value => {
    return String(value).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
  };
  const toggleSection = projectName => {
    setOpenSections(prev => ({
      ...prev,
      [projectName]: !prev[projectName]
    }));
  };
  const handleSearchSubmit = e => {
    e.preventDefault();
    const q = query.trim().toLowerCase();
    if (!q) return;
    for (const group of groupedData) {
      for (const contract of group.contracts) {
        const name = String(contract[nameKey] || '').toLowerCase();
        const address = String(contract[addressKey] || '').toLowerCase();
        if (name.includes(q) || address.includes(q)) {
          const baseId = `contract-${slugify(group.projectName)}-${address}`;
          setOpenSections(prev => ({
            ...prev,
            [group.projectName]: true
          }));
          setPendingScrollId(baseId);
          return;
        }
      }
    }
  };
  useEffect(() => {
    if (!pendingScrollId) return;
    const baseId = pendingScrollId;
    setPendingScrollId(null);
    const el = [`${baseId}-desktop`, `${baseId}-mobile`].map(cid => document.getElementById(cid)).find(node => node && node.offsetParent !== null) || document.getElementById(`${baseId}-desktop`) || document.getElementById(`${baseId}-mobile`);
    if (!el) return;
    const rect = el.getBoundingClientRect();
    const currentScrollY = window.scrollY || window.pageYOffset;
    const absoluteTop = rect.top + currentScrollY;
    const viewportHeight = window.innerHeight;
    const targetTop = absoluteTop - Math.max(0, (viewportHeight - rect.height) / 2);
    const maxScroll = Math.max(0, (document.documentElement.scrollHeight || document.body.scrollHeight) - viewportHeight);
    const clampedTop = Math.min(Math.max(0, targetTop), maxScroll);
    window.scrollTo({
      top: clampedTop,
      behavior: 'smooth'
    });
  }, [pendingScrollId]);
  const seiScanStyle = isDark ? {
    color: 'var(--sei-maroon-25)',
    backgroundColor: 'rgba(96, 0, 20, 0.2)'
  } : {
    color: 'var(--sei-maroon-100)',
    backgroundColor: 'var(--sei-grey-25)'
  };
  const focusRingColor = 'var(--sei-maroon-100)';
  const rowGridStyle = {
    display: 'grid',
    gridTemplateColumns: 'minmax(0, 1fr) minmax(0, 1.3fr)'
  };
  const SeiScanLink = ({address}) => {
    const [hover, setHover] = useState(false);
    const baseStyle = isDark ? {
      color: hover ? 'var(--sei-cream)' : 'var(--sei-maroon-25)',
      backgroundColor: hover ? 'rgba(96, 0, 20, 0.3)' : 'rgba(96, 0, 20, 0.2)'
    } : {
      color: hover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
      backgroundColor: hover ? 'var(--sei-grey-30)' : 'var(--sei-grey-25)'
    };
    return <a href={`https://seiscan.io/address/${address}`} target="_blank" rel="noopener noreferrer" onMouseEnter={() => setHover(true)} onMouseLeave={() => setHover(false)} style={{
      ...baseStyle,
      transition: 'colors 0.15s ease'
    }} className="text-xs px-2 py-1 transition-colors no-underline">
				SeiScan ↗
			</a>;
  };
  if (groupedData.length === 0) {
    return <div className="my-4 p-4 border border-yellow-300 dark:border-yellow-700 bg-yellow-50 dark:bg-yellow-900/20 text-yellow-800 dark:text-yellow-200 text-sm">
				No contract data available.
			</div>;
  }
  const SearchButton = () => {
    const [hover, setHover] = useState(false);
    return <button type="submit" onMouseEnter={() => setHover(true)} onMouseLeave={() => setHover(false)} style={{
      backgroundColor: hover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)'
    }} className="px-3 py-2 text-white text-sm transition-colors focus:outline-none">
				Search
			</button>;
  };
  return <div className="my-6">
			<div className="sheet-content">
				<div className="space-y-4">
					<form onSubmit={handleSearchSubmit} className="flex gap-2 items-center">
						<input type="text" value={query} onChange={e => setQuery(e.target.value)} placeholder="Search by contract name or address" aria-label="Search by contract name or address" autoComplete="off" onFocus={e => {
    e.target.style.borderColor = focusRingColor;
    e.target.style.boxShadow = `0 0 0 2px rgba(96, 0, 20, 0.25)`;
  }} onBlur={e => {
    e.target.style.borderColor = '';
    e.target.style.boxShadow = '';
  }} className="w-full px-3 py-2 rounded border border-neutral-300 dark:border-neutral-700 bg-neutral-50 dark:!bg-neutral-900 text-sm text-neutral-900 dark:text-neutral-100 placeholder:text-neutral-400 dark:placeholder:text-neutral-500 focus:outline-none transition-colors" />
						<SearchButton />
					</form>

					<div className="w-full space-y-3">
						{groupedData.map(group => {
    const isOpen = !!openSections[group.projectName];
    const sectionId = `section-${slugify(group.projectName)}`;
    return <div key={group.projectName} className="border border-neutral-200 dark:border-neutral-800 overflow-hidden">
									<button type="button" onClick={() => toggleSection(group.projectName)} className="w-full flex items-center justify-between px-4 py-3 bg-white dark:!bg-neutral-900 hover:bg-neutral-50 dark:hover:!bg-neutral-800 transition-colors" aria-expanded={isOpen} aria-controls={sectionId}>
										<span className="flex items-center gap-3 text-left">
											<span className="text-sm sm:text-base font-semibold text-neutral-900 dark:text-neutral-100">{group.projectName}</span>
											<span className="text-xs bg-blue-100 dark:bg-blue-900 text-blue-800 dark:text-blue-200 px-2 py-1 rounded-full">
												{group.contractCount} contract{group.contractCount !== 1 ? 's' : ''}
											</span>
										</span>
										<span className={`ml-4 inline-block transition-transform ${isOpen ? 'rotate-180' : ''}`} aria-hidden="true">
											<svg width="16" height="16" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg" className="text-neutral-600 dark:text-neutral-300">
												<path d="M5 8l5 5 5-5" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
											</svg>
										</span>
									</button>
									<section id={sectionId} className={`${isOpen ? 'block' : 'hidden'}`}>
										<div className="p-4 space-y-4">
												{}
											<div className="hidden sm:block border border-gray-200 dark:border-gray-700">
												<div role="table" className="w-full text-sm">
													<div role="row" style={rowGridStyle} className="bg-gray-50 dark:bg-gray-800 border-b border-gray-200 dark:border-gray-700">
														<div role="columnheader" className="px-4 py-3 text-left font-semibold text-gray-900 dark:text-white">
															Contract Name
														</div>
														<div role="columnheader" className="px-4 py-3 text-left font-semibold text-gray-900 dark:text-white">
															Contract Address
														</div>
													</div>
													{group.contracts.map((contract, contractIndex) => {
      const addr = String(contract[addressKey] || '').toLowerCase();
      const id = `contract-${slugify(group.projectName)}-${addr}`;
      return <div role="row" key={contractIndex} id={`${id}-desktop`} style={rowGridStyle} className="border-b border-gray-200 dark:border-gray-700 last:border-b-0 transition-colors">
																<div role="cell" className="px-4 py-3 text-gray-900 dark:text-white font-medium break-words">
																	{contract[nameKey] || 'Unnamed Contract'}
																</div>
																<div role="cell" className="px-4 py-3">
																	<div className="flex items-center gap-2 min-w-0">
																		<code className="text-xs bg-gray-100 dark:bg-gray-800 px-2 py-1 rounded break-all" style={{
        fontFamily: 'var(--sei-font-mono)'
      }}>
																			{contract[addressKey]}
																		</code>
																		<SeiScanLink address={contract[addressKey]} />
																	</div>
																</div>
															</div>;
    })}
												</div>
											</div>

											{}
											<div className="block sm:hidden space-y-3">
												{group.contracts.map((contract, contractIndex) => {
      const addr = String(contract[addressKey] || '').toLowerCase();
      const id = `contract-${slugify(group.projectName)}-${addr}`;
      return <div key={contractIndex} id={`${id}-mobile`} className="border border-gray-200 dark:border-gray-700 p-4 bg-white dark:bg-gray-800">
															<div className="space-y-2">
																<div>
																	<span className="text-xs text-gray-500 dark:text-gray-400 block mb-1">Contract Name</span>
																	<span className="text-sm font-medium text-gray-900 dark:text-white">{contract[nameKey] || 'Unnamed Contract'}</span>
																</div>
																<div>
																	<span className="text-xs text-gray-500 dark:text-gray-400 block mb-1">Contract Address</span>
																	<div className="flex items-center gap-2">
																		<code className="text-xs bg-gray-100 dark:bg-gray-800 px-2 py-1 rounded break-all" style={{
        fontFamily: 'var(--sei-font-mono)'
      }}>
																			{contract[addressKey]}
																		</code>
																		<SeiScanLink address={contract[addressKey]} />
																	</div>
																</div>
															</div>
														</div>;
    })}
											</div>
										</div>
									</section>
								</div>;
  })}
					</div>
				</div>
			</div>
		</div>;
};

Discover and interact with the ecosystem building on Sei. This registry contains smart contract addresses for projects built across Sei.

<Info>
  **Work in Progress**

  This registry is actively maintained and expanded. We're constantly adding new projects and updating contract addresses. Check back regularly for the latest additions to the Sei ecosystem.
</Info>

***

### How to Use This Registry

* **Search by Project Name**: Use the search bar to quickly find contracts for specific projects.
* **View Contract Details**: Click on the Seiscan link to see detailed information about the contract
* **Bookmark This Page**: Keep this registry handy for quick access to the latest contract addresses and updates.

<Tip>
  **Add Your Project**

  Don't see your project listed? Want to add your contracts to this registry? **Reach out to us** in the [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk) and we'll help get you added!
</Tip>

## Contract Registry

<EcosystemContracts />

***

<Warning>Always verify contract addresses independently before interacting with them. While we strive to maintain accurate information, you should always double-check addresses through official project channels.</Warning>

---

URL: https://docs.sei.io/evm/ledger-ethers

# Ledger Setup (EVM)

> Set up your Ledger hardware wallet for signing EVM transactions on Sei, including device configuration, Ethers.js integration, and a simple transfer example.

This guide covers connecting a Ledger hardware wallet to Sei's EVM for signing transactions with Ethers.js. For Cosmos-side signing with the `@sei-js/ledger` package, see the [@sei-js/ledger reference](/evm/sei-js/ledger).

## Prerequisites

1. **Ledger App Installation**

   On your Ledger device, open the Manager in Ledger Live and install **either** the **Sei** app **or** the **Ethereum** app. The Ethereum app supports any EVM chain (like Sei), but the native Sei app may provide optimal compatibility.

2. **Enable Blind Signing**

   In the Ledger device's Ethereum or Sei app settings, **enable "Blind signing"**. This permits the device to sign arbitrary EVM transactions and contract calls (e.g. precompiles), which would otherwise be rejected.

3. **USB Permissions (Linux only)**

   You'll need a **udev rule** so your process can talk to the Ledger over USB/HID. Clone the official rules from [LedgerHQ/udev-rules](https://github.com/LedgerHQ/udev-rules), copy `49-ledger.rules` into `/etc/udev/rules.d/`, then run `sudo udevadm control --reload-rules` and replug your Ledger.

4. **Install Dependencies**
   ```bash theme={"dark"}
   npm install ethers @ethers-ext/signer-ledger @ledgerhq/hw-transport-node-hid
   ```

## Connecting Your Ledger

```tsx theme={"dark"}
import { LedgerSigner } from '@ethers-ext/signer-ledger';
import TransportNodeHid from '@ledgerhq/hw-transport-node-hid';
import { ethers } from 'ethers';

const rpcUrl = 'https://evm-rpc-testnet.sei-apis.com';
const provider = new ethers.JsonRpcProvider(rpcUrl);
const signer = new LedgerSigner(TransportNodeHid, provider);

const addr = await signer.getAddress();
console.log('Using Ledger address:', addr);
```

Every transaction sent through this signer will require physical confirmation on the Ledger device.

## Sending a Transfer

A simple example sending SEI from your Ledger to another address:

```tsx theme={"dark"}
import { LedgerSigner } from '@ethers-ext/signer-ledger';
import TransportNodeHid from '@ledgerhq/hw-transport-node-hid';
import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://evm-rpc-testnet.sei-apis.com');
const signer = new LedgerSigner(TransportNodeHid, provider);

const tx = await signer.sendTransaction({
  to: '0xRECIPIENT_ADDRESS',
  value: ethers.parseEther('1.0')
});

console.log('TX sent:', tx.hash);
const receipt = await tx.wait();
console.log('Confirmed in block:', receipt.blockNumber);
```

<Info>This signer works with any contract interaction — you can pass it to `ethers.Contract` constructors to sign [precompile](/evm/precompiles) calls, ERC-20 transfers, or any other EVM transaction.</Info>

## Troubleshooting

* **Timeouts:** If the Ledger times out, increase the HID timeouts or ensure the device stays awake during signing.
* **"Blind signing required" errors:** Double-check that blind signing is enabled in the app settings on the device itself.
* **Connection failures:** Make sure no other application (e.g. Ledger Live) is holding the USB connection to your device.

---

URL: https://docs.sei.io/node

# Node Operations on Sei

> Deploy and maintain Sei Network infrastructure with comprehensive guides for validators, RPC nodes, and archive nodes, including hardware requirements, installation steps, and operational best practices.

export const RandomPeers = ({format = 'bash', network = 'mainnet', count = 5}) => {
  const PEERS = {
    mainnet: ['d53ab7681ed0df3d3249fc0132df7c3a131c9c1a@45.250.253.40:51656', '4ee8aea5bb58e9038d72e74322e3bba755287398@202.8.8.183:11956', '81409623ae4da3ec7b400cf640dea0b0999a964b@57.128.230.96:51556', '61a5be64b5215786fe5da712584678d0626636b5@87.249.137.71:51556', 'f83c536f43df9a5d900cd3c2f702c04d7dddc7b5@136.243.67.45:11956', 'b8d600a2f568576b5a2df5ee649cf9b809389064@162.19.62.176:26756', '57860b18ed3e1bbe8901ba73f2e63c7e6fe8b3d3@57.129.54.81:26656', '04fc6bba6c5c33034811612dca31c7adda24b299@91.134.60.37:16856', 'de64b779c7f4091e6f1765f5ca4c46f9d3011732@65.108.70.106:46656', '3be6b24cf86a5938cce7d48f44fb6598465a9924@p2p.state-sync.pacific-1.seinetwork.io:26656', '70e0c91b83b5ed1beaca798267f2debdf97dac10@18.156.6.83:26656', 'dd6b1ae002a15c1c8a38e05660f49a93c75d4159@148.251.181.225:26656'],
    testnet: ['71beea83970431f55816eee5f066a611a1dc80f7@p2p.state-sync.atlantic-2.seinetwork.io:26656', '65c257f9275beb1b99ca169ef89743c034b15db0@3.76.192.224:26656', '33588592e477c5238ff2a5d8dc765f85790ef853@23.109.47.225:26656', 'babc3f3f7804933265ec9c40ad94f4da8e9e0017@testnet-seed.rhinostake.com:11956', '8542cd7e6bf9d260fef543bc49e59be5a3fa9074@seed.publicnode.com:56656']
  };
  const pickRandom = (arr, n) => {
    const shuffled = [...arr];
    for (let i = shuffled.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
    }
    return shuffled.slice(0, Math.min(n, arr.length));
  };
  const CopyIcon = ({className}) => <svg role="img" aria-label="Copy" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
      <path d="M7 7m0 2.667a2.667 2.667 0 0 1 2.667 -2.667h8.666a2.667 2.667 0 0 1 2.667 2.667v8.666a2.667 2.667 0 0 1 -2.667 2.667h-8.666a2.667 2.667 0 0 1 -2.667 -2.667z" />
      <path d="M4.012 16.737a2.005 2.005 0 0 1 -1.012 -1.737v-10c0 -1.1 .9 -2 2 -2h10c.75 0 1.158 .385 1.5 1" />
    </svg>;
  const CheckIcon = ({className}) => <svg role="img" aria-label="Copied" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
      <path d="M5 12l5 5l10 -10" />
    </svg>;
  const ShuffleIcon = ({className}) => <svg role="img" aria-label="Shuffle" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
      <path d="M16 3h5v5" />
      <path d="M4 20l16.2 -16.2" />
      <path d="M21 16v5h-5" />
      <path d="M15 15l6 6" />
      <path d="M4 4l5 5" />
    </svg>;
  const pool = PEERS[network] ?? [];
  const [peers, setPeers] = useState(() => pool.slice(0, count));
  const [copied, setCopied] = useState(false);
  const shuffle = () => {
    setPeers(pickRandom(pool, count));
  };
  useEffect(() => {
    shuffle();
  }, [network, count]);
  if (pool.length === 0) {
    return <div className="not-prose w-full">
        <pre className="m-0 p-3 rounded-md bg-neutral-100 dark:bg-neutral-800 text-sm opacity-70" style={{
      fontFamily: 'var(--sei-font-mono)'
    }}>
          No peers configured for network “{network}”.
        </pre>
      </div>;
  }
  const peerString = peers.join(',');
  const displayText = format === 'toml' ? `persistent_peers = "${peerString}"` : `PEERS="${peerString}"`;
  const handleCopy = async () => {
    try {
      await navigator.clipboard.writeText(displayText);
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    } catch {}
  };
  return <div className="not-prose w-full">
      <div className="relative">
        <pre className="m-0 px-4 py-3 pr-28 rounded-lg bg-neutral-100 dark:bg-neutral-900 text-[12.5px] leading-[1.55] whitespace-pre-wrap break-all border border-neutral-200 dark:border-neutral-700 text-neutral-900 dark:text-neutral-100" style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>
          <code style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>{displayText}</code>
        </pre>
        <div className="absolute top-2 right-2 flex items-center gap-1.5">
          <button type="button" onClick={shuffle} aria-label="Shuffle peers" title="Shuffle" className="inline-flex items-center gap-1 px-2 py-1 rounded-md text-[11px] font-semibold border border-neutral-300 dark:border-neutral-600 bg-white/80 dark:bg-neutral-800/80 text-neutral-700 dark:text-neutral-200 hover:bg-white dark:hover:bg-neutral-800 transition-colors">
            <ShuffleIcon />
            Shuffle
          </button>
          <button type="button" onClick={handleCopy} aria-label="Copy peers" title="Copy to clipboard" className="inline-flex items-center gap-1 px-2 py-1 rounded-md text-[11px] font-semibold border border-neutral-300 dark:border-neutral-600 bg-white/80 dark:bg-neutral-800/80 text-neutral-700 dark:text-neutral-200 hover:bg-white dark:hover:bg-neutral-800 transition-colors">
            {copied ? <>
                <CheckIcon className="text-green-600" />
                Copied
              </> : <>
                <CopyIcon />
                Copy
              </>}
          </button>
        </div>
      </div>
    </div>;
};

export const VersionTable = () => {
  const networks = [{
    label: 'Mainnet',
    chainId: 'pacific-1',
    rpcEndpoint: 'https://rpc.sei-apis.com',
    evmChainId: '1329'
  }, {
    label: 'Testnet',
    chainId: 'atlantic-2',
    rpcEndpoint: 'https://rpc-testnet.sei-apis.com',
    evmChainId: '1328'
  }];
  const [versions, setVersions] = useState({});
  useEffect(() => {
    const oneHour = 3600000;
    const setVersionFor = (chainId, version) => {
      setVersions(prev => ({
        ...prev,
        [chainId]: version
      }));
    };
    const fetchVersion = async (chainId, rpcEndpoint) => {
      try {
        const response = await fetch(`${rpcEndpoint}/abci_info`);
        const data = await response.json();
        const info = data && data.result && data.result.response || data && data.response || ({});
        const version = info.version;
        if (typeof version === 'string' && version) {
          setVersionFor(chainId, version);
          localStorage.setItem(`${chainId}-version`, version);
          localStorage.setItem(`${chainId}-version-timestamp`, Date.now().toString());
          return;
        }
        throw new Error('abci_info response had no version field');
      } catch (error) {
        console.error('Error fetching version:', error);
        if (!localStorage.getItem(`${chainId}-version`)) {
          setVersionFor(chainId, 'Unavailable');
        }
      }
    };
    networks.forEach(({chainId, rpcEndpoint}) => {
      const storedVersion = localStorage.getItem(`${chainId}-version`);
      const storedTimestamp = localStorage.getItem(`${chainId}-version-timestamp`);
      const isFresh = storedVersion && storedTimestamp && Date.now() - parseInt(storedTimestamp, 10) < oneHour;
      if (storedVersion) {
        setVersionFor(chainId, storedVersion);
      }
      if (!isFresh) {
        fetchVersion(chainId, rpcEndpoint);
      }
    });
  }, []);
  return <table className="min-w-full divide-y divide-neutral-200 dark:divide-neutral-800">
      <thead className="bg-neutral-50 dark:bg-neutral-900/50">
        <tr>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">Network</th>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">Version</th>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">Chain ID</th>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">EVM Chain ID</th>
        </tr>
      </thead>
      <tbody className="divide-y divide-neutral-200 dark:divide-neutral-800 bg-neutral-50 dark:bg-neutral-900/30">
        {networks.map(({label, chainId, evmChainId}) => <tr key={chainId}>
            <td className="px-4 py-3 text-sm font-medium text-neutral-900 dark:text-neutral-100">{label}</td>
            <td className="px-4 py-3 text-sm text-neutral-600 dark:text-neutral-400">
              <code style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>{versions[chainId] || 'Fetching...'}</code>
            </td>
            <td className="px-4 py-3 text-sm text-neutral-600 dark:text-neutral-400">{chainId}</td>
            <td className="px-4 py-3 text-sm text-neutral-600 dark:text-neutral-400">{evmChainId}</td>
          </tr>)}
      </tbody>
    </table>;
};

**Power the Sei Network Infrastructure**

Comprehensive guides for running, maintaining, and optimizing Sei network nodes. Whether you're setting up a validator, an RPC node, or a relayer, you'll find detailed instructions and best practices to ensure optimal performance and security.

<CardGroup cols={4}>
  <Card horizontal title="RPC/API Nodes" icon="network-wired" />

  <Card horizontal title="Validator Nodes" icon="shield" />

  <Card horizontal title="Statesync Nodes" icon="shuffle" />

  <Card horizontal title="Archive Nodes" icon="database" />
</CardGroup>

## Network Versions

<VersionTable />

*Live binary versions, genesis, and seed peers — see the [technical reference](/node/technical-reference).*

## Hardware Requirements

| Component | Required                                           |
| --------- | -------------------------------------------------- |
| CPU       | 16 cores (Intel Xeon/Core i7/i9 or AMD Epyc/Ryzen) |
| RAM       | 256 GB DDR5 or better                              |
| Storage   | 2 TB NVMe SSD (high IOPS required)                 |
| Network   | 2 Gbps with low latency                            |

## Installation & Setup Steps

<Steps>
  <Step title="Environment Setup">
    ##### System Preparation

    ###### 1. Update and Upgrade System

    ```bash theme={"dark"}
    sudo apt update && sudo apt upgrade -y
    ```

    ###### 2. Install Essential Packages

    ```bash theme={"dark"}
    sudo apt install make gcc git jq chrony curl lz4 wget tar build-essential -y
    ```

    ###### 3. Synchronize System Time

    ```bash theme={"dark"}
    sudo timedatectl set-timezone UTC
    sudo systemctl enable --now chronyd
    timedatectl
    ```

    ##### Install Go

    Suggested Version: Go 1.24.x (required for seid v6.3+)

    ###### Installation Steps

    ```bash theme={"dark"}
    # Check for existing Go installation
    go version

    # Download and install Go 1.24.x
    wget https://go.dev/dl/go1.24.5.linux-amd64.tar.gz
    sudo tar -C /usr/local -xzf go1.24.5.linux-amd64.tar.gz

    # Add Go to your environment variables
    echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.bashrc
    source $HOME/.bashrc

    # Verify installation
    go version
    ```
  </Step>

  <Step title="Install Sei">
    ##### Install Sei Binary

    ```bash theme={"dark"}
    # Clone repository and install
    git clone https://github.com/sei-protocol/sei-chain.git
    cd sei-chain
    git checkout <version-tag>  # Replace with specific version
    make install

    # Verify installation
    seid version
    ```

    See Network Versions table above for current recommended version.

    <Accordion title="Alternative: Docker Image">
      Official Docker images are available at GitHub Container Registry.

      ```bash theme={"dark"}
      # Pull the latest version
      docker pull ghcr.io/sei-protocol/sei:latest

      # Or pull a specific version (recommended)
      docker pull ghcr.io/sei-protocol/sei:v6.3.1
      ```

      Available architectures: linux/amd64 and linux/arm64.
    </Accordion>

    <Info>
      If you encounter an error like `command not found: seid`, you may need to set your GOPATH environment variable.

      Add the following to your `~/.bashrc` or `~/.zshrc`:

      ```bash theme={"dark"}
      export GOPATH=$(go env GOPATH)
      export PATH=$PATH:$GOPATH/bin
      ```

      Then reload your shell with `source ~/.bashrc` or `source ~/.zshrc`.

      For more information see [here](https://pkg.go.dev/cmd/go#hdr-GOPATH_environment_variable).
    </Info>

    ##### Initialize Chain Files

    <Info>Default init mode is **full** (RPC/P2P bind to all interfaces). For **validator** or **seed** nodes, use `--mode validator` or `--mode seed` so RPC and P2P bind to localhost only. See the [Validator Operations Guide](/node/validators) for the full validator init example.</Info>

    Peers can be found here -

    * mainnet (pacific-1):

    <RandomPeers network="mainnet" format="bash" />

    * testnet (atlantic-2):

    <RandomPeers network="testnet" format="bash" />

    ```bash theme={"dark"}
    # Initialize node (default mode is full: RPC/P2P bind to all interfaces)
    # For validator nodes, use: seid init <your-moniker> --chain-id <chain-id> --mode validator
    seid init <your-moniker> --chain-id <chain-id>

    # Genesis is written automatically for known networks (mainnet and testnets); no download needed.

    # Configure peers in config.toml.
    PEERS="<comma-separated-peer-list>"

    #Set persistent peers in config.toml
    sed -i 's/persistent-peers = .*/persistent-peers = "'$PEERS'"/' ~/.sei/config/config.toml
    ```

    ##### Configure App Settings

    ```bash theme={"dark"}
    # Set minimum gas price (recommended; helps prevent spam transactions)
    # Mainnet enforces a chain-wide minimum of 0.02usei, so set at least that value
    # Use "0usei" only for local development or private networks
    sed -i -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0.02usei\"/" $HOME/.sei/config/app.toml

    # Tune mempool settings
    sed -i \
      -e 's/^keep-invalid-txs-in-cache = .*/keep-invalid-txs-in-cache = true/' \
      -e 's/^ttl-duration = .*/ttl-duration = "5s"/' \
      -e 's/^ttl-num-blocks = .*/ttl-num-blocks = 5/' \
      $HOME/.sei/config/config.toml

    # Set Concurrent Workers to 500 and enable occ
    sed -i -e "s/^#concurrency-workers *=.*/concurrency-workers = 500/" $HOME/.sei/config/app.toml
    sed -i -e "s/^occ-enabled *=.*/occ-enabled = true/" $HOME/.sei/config/app.toml
    ```

    <Info>
      In case of running an Archive Node, make sure to set your state-store settings to `ss-keep-recent = 0` with

      ```bash theme={"dark"}
      sed -i 's/^ss-keep-recent = [0-9]*/ss-keep-recent = 0/' ~/.sei/config/app.toml
      ```
    </Info>

    <Accordion title="Advanced Configuration">
      #### Archive Node Setup

      An archive node maintains the complete historical record of the chain. This requires disabling state sync and starting with a pre-existing database using a "snapshot".

      **1. Disable State Sync** — In \$HOME/.sei/config/config.toml , modify the \[statesync] section:

      ```toml theme={"dark"}
      # State sync configuration
      [statesync]
      enable = false
      ```

      **2. Configure Archive Node Peers** — To sync from the height your snapshot was created at, you need peers retaining a large amount of historical blocks. The node will require specific peers during initial sync, which can be changed at a later time.

      #### Mempool Configuration

      For optimal transaction handling and resource management, it is recommended to update the mempool settings in your `config.toml` file.

      <Info>
        Adjust these parameters if you encounter performance or resource issues on your specific hardware.
      </Info>

      ```toml theme={"dark"}
      # Mempool configuration settings
      [mempool]

      # Broadcast transactions to other nodes
      broadcast = true

      # Maximum number of transactions in the mempool
      size = 5000

      # Limit the total size of all txs in the mempool.
      max-txs-bytes = 10737418240

      # Size of the cache (used to filter duplicate transactions)
      cache-size = 10000

      # Do not remove invalid transactions from the cache
      keep-invalid-txs-in-cache = true

      # Maximum size of a single transaction
      max-tx-bytes = 2048576

      # Maximum size of a batch of transactions to send to a peer
      max-batch-bytes = 0

      # Maximum length of time a transaction can remain in the mempool
      ttl-duration = "3s"

      # Maximum number of blocks a transaction can remain in the mempool
      ttl-num-blocks = 5

      tx-notify-threshold = 0

      check-tx-error-blacklist-enabled = true

      check-tx-error-threshold = 50

      pending-size = 5000

      max-pending-txs-bytes = 1073741824

      pending-ttl-duration = "3s"

      pending-ttl-num-blocks = 5
      ```
    </Accordion>
  </Step>

  <Step title="Run Node">
    ##### Setting Up a systemd Service

    <Danger>If you see an error such as `panic: recovered: runtime error: integer divide by zero` it means you can’t start nodes straight from the genesis file. Instead, sync to the block tip via [state sync](/node/statesync) or using a [snapshot](/node/snapshot).</Danger>

    For production deployments, configure a systemd service to ensure your node restarts automatically:

    ```bash theme={"dark"}
    # Create the systemd service file
    sudo tee /etc/systemd/system/seid.service > /dev/null << EOF
    [Unit]
    Description=Sei Node
    After=network-online.target

    [Service]
    User=$USER
    ExecStart=$(which seid) start
    Restart=always
    RestartSec=3
    LimitNOFILE=65535

    [Install]
    WantedBy=multi-user.target
    EOF

    # Reload systemd, enable and start the service
    sudo systemctl daemon-reload
    sudo systemctl enable seid
    sudo systemctl start seid
    ```

    ##### Monitoring & Troubleshooting

    Check your node's status with these commands:

    ```bash theme={"dark"}
    # Check sync status
    seid status

    # Monitor logs in real-time
    journalctl -u seid -f -o cat

    # Check validator status (if running a validator)
    seid query staking validator $(seid keys show <your_key> --bech val -a)
    ```

    **Common Issues & Solutions**

    <CardGroup cols={2}>
      <Card horizontal title="Sync Issues">
        * Verify sufficient disk space
        * Ensure stable network connectivity
        * Confirm system time is synchronized
        * Consider using state sync for initial setup
      </Card>

      <Card horizontal title="Performance Problems">
        * Monitor system resources (CPU, RAM, I/O)
        * Evaluate disk performance and network bandwidth
        * Adjust mempool and peer settings if needed
      </Card>
    </CardGroup>
  </Step>
</Steps>

[View Complete Node Setup Guide](/node/node-operators)

## Node Resources

### Node Setup

<CardGroup cols={3}>
  <Card horizontal title="Node Operations Guide" icon="server" href="/node/node-operators">
    Complete guide to setting up and running a Sei node with hardware requirements and configuration steps.
  </Card>

  <Card horizontal title="Validator Operations Guide" icon="shield" href="/node/validators">
    Specialized instructions for validators, including staking, commission settings, and security best practices.
  </Card>

  <Card horizontal title="Default Configurations" icon="file-lines" href="/node/node-operators#default-configurations">
    Full reference for `app.toml`, `config.toml`, and `client.toml` shipped by the latest `seid` release.
  </Card>
</CardGroup>

### Advanced Operations

<CardGroup cols={3}>
  <Card horizontal title="Configuration & Monitoring" icon="gauge-simple-high" href="/node/advanced-config-monitoring">
    Optimize your node's performance with advanced settings and monitoring tools.
  </Card>

  <Card horizontal title="RocksDB Backend" icon="database" href="/node/rocksdb-backend">
    Run with RocksDB instead of the default backend.
  </Card>

  <Card horizontal title="Technical Reference" icon="terminal" href="/node/technical-reference">
    Detailed technical specifications, API endpoints, and commands for node operators.
  </Card>
</CardGroup>

---

URL: https://docs.sei.io/node/node-operators

# Sei Node Operations Guide

> Detailed guide for running and maintaining Sei nodes. Learn about configuration management, database maintenance, service management, and update procedures.

This guide covers the detailed operational aspects of running a Sei node,
including configuration management, maintenance procedures, and best practices
for stable and performant operations.

## Configuration Management

### Directory Structure

The Sei node configuration is stored in `$HOME/.sei/config/`:

```bash theme={"dark"}
$HOME/.sei/config/
├── app.toml          # Application configuration (gas fees, API settings, pruning, etc.)
├── config.toml       # Core Tendermint settings (network, consensus, and RPC)
├── client.toml       # CLI and client-related settings
├── genesis.json      # Chain genesis file, defines initial state
├── node_key.json     # Unique node identity key for peer-to-peer (P2P) networking
└── priv_validator_key.json  # Validator private signing key (if running as a validator)
```

The snippets below are opinionated tuning recommendations layered on top of
the defaults. For the *full* unmodified `app.toml`, `config.toml`, and
`client.toml` shipped by the latest tagged `seid` release, jump to
[Default Configurations](#default-configurations) at the bottom of this
section.

### Essential Configuration Parameters

#### Network Settings (config.toml)

```toml theme={"dark"}
[p2p]
# Public address other nodes use to dial in (host:port)
external-address = "your-public-ip:26656"
# Local address to listen for incoming P2P connections
laddr = "tcp://0.0.0.0:26656"
# Combined inbound + outbound peer limit. Default is 100; raise it for
# well-connected RPC nodes. (`max-num-inbound-peers` / `max-num-outbound-peers`
# from older Tendermint configs no longer apply.)
max-connections = 200
# Per-connection bandwidth caps in bytes/sec. Defaults are 20 MiB/s; raise
# only if your link can sustain it.
send-rate = 20971520
recv-rate = 20971520

[rpc]
# RPC listen address
laddr = "tcp://0.0.0.0:26657"
# Maximum number of simultaneous connections (HTTP + WS)
max-open-connections = 900
# Transaction confirmation timeout for /broadcast_tx_commit
timeout-broadcast-tx-commit = "10s"
```

#### Application Settings (app.toml)

```toml theme={"dark"}
# Minimum gas prices to prevent spam transactions
# (mainnet enforces a chain-wide minimum of 0.02usei)
minimum-gas-prices = "0.02usei"

# Block retention for /block, /block_results, etc., and the floor used by
# the receipt store's pruner. 0 disables block pruning.
min-retain-blocks = 100000

# Concurrent transaction execution workers. The default is set dynamically
# (2× CPU cores, capped at 128, minimum 10).
concurrency-workers = 10

# Optimistic Concurrency Control for parallel tx execution
occ-enabled = true

[api]
# Enable the REST/Cosmos API server (port 1317)
enable = true
max-open-connections = 1000

[state-commit]
# SeiDB state-commit (memiavl + FlatKV). Recommended on every node.
sc-enable = true

[state-store]
# Historical SS layer for queries. Required for any node serving RPC.
ss-enable = true
# 0 = keep everything; 100,000 is roughly 28 hours of pacific-1 history.
ss-keep-recent = 100000

[receipt-store]
# Storage backend for EVM transaction receipts (pebbledb or parquet).
rs-backend = "pebbledb"
```

### Default Configurations

The full unmodified `app.toml`, `config.toml`, and `client.toml` produced by
`seid init` against the latest tagged `seid` release. Use these as the
canonical reference for every available knob and its default value.

<Tabs>
  <Tab title="app.toml">
    Application-layer configuration: gas, API, gRPC, pruning, SeiDB, EVM, etc.

    ```toml theme={"dark"}
    # This is a TOML config file.
    # For more information, see https://github.com/toml-lang/toml

    ###############################################################################
    ###                           Base Configuration                            ###
    ###############################################################################

    # The minimum gas prices a validator is willing to accept for processing a
    # transaction. A transaction's fees must meet the minimum of any denomination
    # specified in this config (e.g. 0.25token1;0.0001token2).
    minimum-gas-prices = "0.01usei"

    # MinRetainBlocks defines the minimum block height offset from the current block
    # for pruning Tendermint blocks. Set to 0 to disable pruning. This only affects
    # Tendermint block pruning, not application state (see "pruning-*" configs).
    min-retain-blocks = 100000

    # ConcurrencyWorkers defines how many workers to run for concurrent transaction execution.
    # Default is dynamically set to 2x CPU cores, capped at 128, with a minimum of 10.
    concurrency-workers = 10

    # occ-enabled defines whether OCC is enabled or not for transaction execution
    occ-enabled = true

    # HaltHeight contains a non-zero block height at which a node will gracefully
    # halt and shutdown that can be used to assist upgrades and testing.
    #
    # Note: Commitment of state will be attempted on the corresponding block.
    halt-height = 0

    # HaltTime contains a non-zero minimum block time (in Unix seconds) at which
    # a node will gracefully halt and shutdown that can be used to assist upgrades
    # and testing.
    #
    # Note: Commitment of state will be attempted on the corresponding block.
    halt-time = 0

    # InterBlockCache enables inter-block caching.
    inter-block-cache = true

    # IndexEvents defines the set of events in the form {eventType}.{attributeKey},
    # which informs Tendermint what to index. If empty, all events will be indexed.
    #
    # Example:
    # ["message.sender", "message.recipient"]
    index-events = []

    # IAVLDisableFastNode enables or disables the fast node feature of IAVL.
    # Default is true.
    iavl-disable-fastnode = true

    # CompactionInterval sets (in seconds) the interval between forced levelDB
    # compaction. A value of 0 means no forced levelDB.
    # Default is 0.
    compaction-interval = 0

    # deprecated
    no-versioning = false

    # Whether to store orphan data (to-be-deleted data pointers) outside the main
    # application LevelDB
    separate-orphan-storage = false

    # if separate-orphan-storage is true, how many versions of orphan data to keep
    separate-orphan-versions-to-keep = 0

    # if separate-orphan-storage is true, how many orphans to store in each file
    num-orphan-per-file = 0

    # if separate-orphan-storage is true, where to store orphan data
    orphan-dir = ""

    ###############################################################################
    ###                        State Sync Configuration                         ###
    ###############################################################################

    # State sync snapshots allow other nodes to rapidly join the network without replaying historical
    # blocks, instead downloading and applying a snapshot of the application state at a given height.
    [state-sync]

    # snapshot-interval specifies the block interval at which local state sync snapshots are
    # taken (0 to disable). Must be a multiple of pruning-keep-every.
    snapshot-interval = 0

    # snapshot-keep-recent specifies the number of recent snapshots to keep and serve (0 to keep all).
    snapshot-keep-recent = 2

    # snapshot-directory sets the directory for where state sync snapshots are persisted.
    # default is empty which will then store under the app home directory same as before.
    snapshot-directory = ""

    ###############################################################################
    ###                       State Commit Configuration                        ###
    ###############################################################################

    [state-commit]
    # Enable defines if the SeiDB should be enabled to override existing IAVL db backend.
    sc-enable = true

    # Defines the SC store directory, if not explicitly set, default to application home directory
    sc-directory = ""

    # WriteMode defines how EVM data writes are routed between backends.
    # Valid values: cosmos_only, dual_write, split_write, evm_only
    # defaults to cosmos_only
    sc-write-mode = "cosmos_only"

    # ReadMode defines how EVM data reads are routed between backends.
    # Valid values: cosmos_only, evm_first, split_read
    # defaults to cosmos_only
    sc-read-mode = "cosmos_only"

    # EnableLatticeHash controls whether the FlatKV lattice hash participates
    # in the final app hash. Default: false.
    sc-enable-lattice-hash = false

    # Max concurrent historical proof queries (RPC /store path)
    sc-historical-proof-max-inflight = 1

    # Historical proof query rate limit in req/sec (<=0 disables rate limiting)
    sc-historical-proof-rate-limit = 1

    # Historical proof query burst size
    sc-historical-proof-burst = 1

    # AsyncCommitBuffer defines the size of asynchronous commit queue, this greatly improve block catching-up
    # performance, setting to 0 means synchronous commit.
    sc-async-commit-buffer = 100

    # KeepRecent defines how many state-commit snapshots (besides the latest one) to keep
    # defaults to 0 to only keep one current snapshot
    sc-keep-recent = 0

    # SnapshotInterval defines the block interval the snapshot is taken, default to 10000 blocks.
    sc-snapshot-interval = 10000

    # SnapshotMinTimeInterval defines the minimum time interval (in seconds) between snapshots.
    # This prevents excessive snapshot creation during catch-up and ensures snapshots don't overlap
    # (current snapshot creation takes 3+ hours). Default to 3600 seconds (1 hour).
    # Note: If you set a small sc-snapshot-interval (e.g., < 5000), you may want to reduce this value
    # to allow more frequent snapshots during normal operation.
    sc-snapshot-min-time-interval = 3600

    # SnapshotPrefetchThreshold defines the page cache residency threshold (0.0-1.0) to trigger snapshot prefetch.
    # Prefetch sequentially reads nodes/leaves files into page cache for faster cold-start replay.
    # Only active trees (evm/bank/acc/wasm) are prefetched, skipping sparse kv files to save memory.
    # Skips prefetch if more than threshold of pages already resident (e.g., 0.8 = 80%).
    # Defaults to 0.8
    sc-snapshot-prefetch-threshold = 0.8

    # Maximum snapshot write rate in MB/s (global across all trees). 0 = unlimited. Default 100.
    sc-snapshot-write-rate-mbps = 100

    ###############################################################################
    ###                        FlatKV (EVM) Configuration                       ###
    ###############################################################################

    [state-commit.flatkv]
    # Fsync controls whether PebbleDB writes (data DBs + metadataDB) use fsync.
    # WAL always uses NoSync (matching memiavl); crash recovery relies on
    # WAL catchup, which is idempotent. Default: false.
    fsync = false

    # AsyncWriteBuffer defines the size of the async write buffer for data DBs.
    # Set <= 0 for synchronous writes.
    async-write-buffer = 0

    # SnapshotInterval defines how often (in blocks) a PebbleDB checkpoint is taken.
    # 0 disables auto-snapshots. Default: 10000.
    snapshot-interval = 10000

    # SnapshotKeepRecent defines how many old snapshots to keep besides the latest one.
    # 0 = keep only the current snapshot. Default: 2.
    snapshot-keep-recent = 2

    ###############################################################################
    ###                         State Store Configuration                       ###
    ###############################################################################

    [state-store]
    # Enable defines whether the state-store should be enabled for storing historical data.
    # Supporting historical queries or exporting state snapshot requires setting this to true
    # This config only take effect when SeiDB is enabled (sc-enable = true)
    ss-enable = true

    # Defines the directory to store the state store db files
    # If not explicitly set, default to application home directory
    ss-db-directory = ""

    # DBBackend defines the backend database used for state-store.
    # Supported backends: pebbledb, rocksdb
    # defaults to pebbledb (recommended)
    ss-backend = "pebbledb"

    # AsyncWriteBuffer defines the async queue length for commits to be applied to State Store
    # Set <= 0 for synchronous writes, which means commits also need to wait for data to be persisted in State Store.
    # defaults to 100 for asynchronous writes
    ss-async-write-buffer = 100

    # KeepRecent defines the number of versions to keep in state store
    # Setting it to 0 means keep everything
    # Default to keep the last 100,000 blocks
    ss-keep-recent = 100000

    # PruneInterval defines the minimum interval in seconds + some random delay to trigger SS pruning.
    # It is recommended to trigger pruning less frequently with a large interval.
    # default to 600 seconds
    ss-prune-interval = 600

    # ImportNumWorkers defines the concurrency for state sync import
    # defaults to 1
    ss-import-num-workers = 1

    # EVMDBDirectory defines the directory for the optional EVM state-store DB(s).
    # If unset, defaults to <home>/data/evm_ss when EVM SS is enabled.
    evm-ss-db-directory = ""

    # EVMSplit controls whether EVM data is routed to a dedicated SS backend.
    # When false (default), EVM data lives in the Cosmos SS backend alongside
    # everything else. When true, EVM data is routed exclusively to the EVM SS
    # backend; non-EVM data stays in Cosmos SS. No fallback between backends.
    evm-ss-split = false

    # SeparateEVMSubDBs controls whether EVM data is split across per-type DBs.
    # When false, all EVM data stays in one DB using the current unified layout.
    # When true, data is routed to separate DBs while preserving the same evm key prefix format.
    evm-ss-separate-dbs = false

    ###############################################################################
    ###                        Receipt Store Configuration                      ###
    ###############################################################################

    [receipt-store]
    # Backend defines the receipt store backend.
    # Supported backends: pebble (aka pebbledb), parquet
    # defaults to pebbledb
    rs-backend = "pebbledb"

    # Defines the receipt store directory. If unset, defaults to <home>/data/receipt.db
    db-directory = ""

    # AsyncWriteBuffer defines the async queue length for commits to be applied to receipt store.
    # Applies only when rs-backend = "pebbledb"; parquet ignores this setting.
    # Set <= 0 for synchronous writes.
    # defaults to 100
    async-write-buffer = 100

    # PruneIntervalSeconds defines the interval in seconds to trigger pruning.
    # Receipt retention is controlled by the global min-retain-blocks flag.
    # defaults to 600 seconds
    prune-interval-seconds = 600

    ###############################################################################
    ###                            EVM Configuration                            ###
    ###############################################################################

    [evm]
    # controls whether an HTTP EVM server is enabled
    http_enabled = true
    http_port = 8545

    # controls whether a websocket server is enabled
    ws_enabled = true
    ws_port = 8546

    # ReadTimeout is the maximum duration for reading the entire
    # request, including the body.
    # Because ReadTimeout does not let Handlers make per-request
    # decisions on each request body's acceptable deadline or
    # upload rate, most users will prefer to use
    # ReadHeaderTimeout. It is valid to use them both.
    read_timeout = "30s"

    # ReadHeaderTimeout is the amount of time allowed to read
    # request headers. The connection's read deadline is reset
    # after reading the headers and the Handler can decide what
    # is considered too slow for the body. If ReadHeaderTimeout
    # is zero, the value of ReadTimeout is used. If both are
    # zero, there is no timeout.
    read_header_timeout = "30s"

    # WriteTimeout is the maximum duration before timing out
    # writes of the response. It is reset whenever a new
    # request's header is read. Like ReadTimeout, it does not
    # let Handlers make decisions on a per-request basis.
    write_timeout = "30s"

    # IdleTimeout is the maximum amount of time to wait for the
    # next request when keep-alives are enabled. If IdleTimeout
    # is zero, the value of ReadTimeout is used. If both are
    # zero, ReadHeaderTimeout is used.
    idle_timeout = "2m0s"

    # Maximum gas limit for simulation
    simulation_gas_limit = 10000000

    # Timeout for EVM call in simulation
    simulation_evm_timeout = "1m0s"

    # list of CORS allowed origins, separated by comma
    cors_origins = "*"

    # list of WS origins, separated by comma
    ws_origins = "*"

    # timeout for filters
    filter_timeout = "2m0s"

    # checkTx timeout for sig verify
    checktx_timeout = "5s"

    # controls whether to have txns go through one by one
    slow = false

    # Deny list defines list of methods that EVM RPC should fail fast, e.g ["debug_traceBlockByNumber"]
    deny_list = []

    # Legacy sei_* / sei2_* JSON-RPC (EVM HTTP only - not Cosmos REST on 1317).
    #
    # DEPRECATION: The sei_* and sei2_* JSON-RPC surfaces are deprecated and scheduled for removal. Do not
    # build new integrations on them; use eth_* / debug_* and documented replacements. HTTP 200;
    # gate errors use standard JSON-RPC error encoding (see evmrpc/AGENTS.md). Successful allowlisted
    # responses are unchanged; nodes may set HTTP header Sei-Legacy-RPC-Deprecation (see AGENTS.md).
    #
    # Only methods listed in enabled_legacy_sei_apis are allowed. Init defaults enable the three
    # address/Cosmos helpers; uncomment optional lines below to enable more legacy methods (include
    # sei2_* block methods at the end of the list if you need them).
    enabled_legacy_sei_apis = [
      "sei_getSeiAddress",
      "sei_getEVMAddress",
      "sei_getCosmosTx",

      # Optional legacy methods - uncomment to enable (same deprecation applies):
      # "sei_associate",
      # "sei_getBlockByHash",
      # "sei_getBlockByHashExcludeTraceFail",
      # "sei_getBlockByNumber",
      # "sei_getBlockByNumberExcludeTraceFail",
      # "sei_getBlockReceipts",
      # "sei_getBlockTransactionCountByHash",
      # "sei_getBlockTransactionCountByNumber",
      # "sei_getEvmTx",
      # "sei_getFilterChanges",
      # "sei_getFilterLogs",
      # "sei_getLogs",
      # "sei_getTransactionByBlockHashAndIndex",
      # "sei_getTransactionByBlockNumberAndIndex",
      # "sei_getTransactionByHash",
      # "sei_getTransactionCount",
      # "sei_getTransactionErrorByHash",
      # "sei_getTransactionReceipt",
      # "sei_getTransactionReceiptExcludeTraceFail",
      # "sei_getVMError",
      # "sei_newBlockFilter",
      # "sei_newFilter",
      # "sei_sign",
      # "sei_traceBlockByHashExcludeTraceFail",
      # "sei_traceBlockByNumberExcludeTraceFail",
      # "sei_uninstallFilter",
      #
      # Optional sei2_* block namespace (bank transfers in blocks; HTTP only):
      # "sei2_getBlockByHash",
      # "sei2_getBlockByHashExcludeTraceFail",
      # "sei2_getBlockByNumber",
      # "sei2_getBlockByNumberExcludeTraceFail",
      # "sei2_getBlockReceipts",
      # "sei2_getBlockTransactionCountByHash",
      # "sei2_getBlockTransactionCountByNumber",
    ]

    # max number of logs returned if block range is open-ended
    max_log_no_block = 10000

    # max number of blocks to query logs for
    max_blocks_for_log = 2000

    # max number of concurrent NewHead subscriptions
    max_subscriptions_new_head = 10000

    # MaxConcurrentTraceCalls defines the maximum number of concurrent debug_trace calls.
    # Set to 0 for unlimited.
    max_concurrent_trace_calls = 10

    # Max number of blocks allowed to look back for tracing
    # Set to -1 for unlimited lookback, which is useful for archive nodes.
    max_trace_lookback_blocks = 10000

    # Timeout for each trace call
    trace_timeout = "30s"

    # Enable the parallelized default debug_traceBlock* path.
    enable_parallelized_block_trace = false

    # WorkerPoolSize defines the number of workers in the worker pool.
    # Default: min(64, CPU cores × 2). Capped at 64 to prevent excessive goroutines on high-core machines.
    # Set to 0 to use the default.
    worker_pool_size = 8

    # WorkerQueueSize defines the size of the task queue in the worker pool.
    # Default: 1000 tasks. Set to 0 to use the default.
    worker_queue_size = 1000

    ###############################################################################
    ###                       Giga Executor Configuration                       ###
    ###############################################################################

    [giga_executor]
    # enabled controls whether to use the Giga executor (evmone-based) instead of geth's interpreter.
    # This is an experimental feature for improved EVM throughput.
    # Default: false
    enabled = false

    # occ_enabled controls whether to use OCC (Optimistic Concurrency Control) with the Giga executor.
    # When true, transactions are executed in parallel with conflict detection and retry.
    # Default: false
    occ_enabled = false

    ###############################################################################
    ###                       Admin Configuration (Auto-managed)                ###
    ###############################################################################
     
    [admin_server]
     
    # Enable the admin gRPC server for runtime log level control.
    admin_enabled = false
     
    # Listen address for the admin gRPC server. Must be a loopback address.
    admin_address = "127.0.0.1:9095"

    ###############################################################################
    ###                   Telemetry Configuration (Auto-managed)                ###
    ###############################################################################

    [telemetry]

    # Prefixed with keys to separate services.
    service-name = ""

    # Enabled enables the application telemetry functionality. When enabled,
    # an in-memory sink is also enabled by default. Operators may also enabled
    # other sinks such as Prometheus.
    enabled = true

    # Enable prefixing gauge values with hostname.
    enable-hostname = false

    # Enable adding hostname to labels.
    enable-hostname-label = false

    # Enable adding service to labels.
    enable-service-label = false

    # PrometheusRetentionTime, when positive, enables a Prometheus metrics sink.
    prometheus-retention-time = 7200

    # When both 'api.enable' and 'telemetry.enabled' are true, this node will expose
    # application metrics (custom Cosmos SDK metrics) on the API server endpoint along with the
    # Tendermint metrics (port 26660) which are always enabled.

    # GlobalLabels defines a global set of name/value label tuples applied to all
    # metrics emitted using the wrapper functions defined in telemetry package.
    #
    # Example:
    # [["chain_id", "cosmoshub-1"]]
    global-labels = []

    ###############################################################################
    ###                       API Configuration (Auto-managed)                  ###
    ###############################################################################

    [api]

    # Enable defines if the API server should be enabled.
    enable = true

    # Swagger defines if swagger documentation should automatically be registered.
    swagger = true

    # Address defines the API server to listen on.
    address = "tcp://0.0.0.0:1317"

    # MaxOpenConnections defines the number of maximum open connections.
    max-open-connections = 1000

    # RPCReadTimeout defines the Tendermint RPC read timeout (in seconds).
    rpc-read-timeout = 10

    # RPCWriteTimeout defines the Tendermint RPC write timeout (in seconds).
    rpc-write-timeout = 0

    # RPCMaxBodyBytes defines the Tendermint maximum response body (in bytes).
    rpc-max-body-bytes = 1000000

    # EnableUnsafeCORS defines if CORS should be enabled (unsafe - use it at your own risk).
    enabled-unsafe-cors = false

    ###############################################################################
    ###                     Rosetta Configuration (Auto-managed)                ###
    ###############################################################################

    [rosetta]

    # Enable defines if the Rosetta API server should be enabled.
    enable = false

    # Address defines the Rosetta API server to listen on.
    address = ":8080"

    # Network defines the name of the blockchain that will be returned by Rosetta.
    blockchain = "app"

    # Network defines the name of the network that will be returned by Rosetta.
    network = "network"

    # Retries defines the number of retries when connecting to the node before failing.
    retries = 3

    # Offline defines if Rosetta server should run in offline mode.
    offline = false

    ###############################################################################
    ###                       gRPC Configuration (Auto-managed)                 ###
    ###############################################################################

    [grpc]

    # Enable defines if the gRPC server should be enabled.
    enable = true

    # Address defines the gRPC server address to bind to.
    address = "0.0.0.0:9090"

    ###############################################################################
    ###                        gRPC Web Configuration (Auto-managed)            ###
    ###############################################################################

    [grpc-web]

    # GRPCWebEnable defines if the gRPC-web should be enabled.
    # NOTE: gRPC must also be enabled, otherwise, this configuration is a no-op.
    enable = true

    # Address defines the gRPC-web server address to bind to.
    address = "0.0.0.0:9091"

    # EnableUnsafeCORS defines if CORS should be enabled (unsafe - use it at your own risk).
    enable-unsafe-cors = false

    ###############################################################################
    ###                         Genesis Configuration (Auto-managed)            ###
    ###############################################################################

    # Genesis config allows configuring whether to stream from an genesis json file in streamed form
    [genesis]

    # stream-import specifies whether to the stream the import from the genesis json file. The genesis
    # file must be in stream form and exported in a streaming fashion.
    stream-import = false

    # genesis-stream-file specifies the path of the genesis json file to stream from.
    genesis-stream-file = ""

    ###############################################################################
    ###                    Legacy IAVL Settings (Auto-managed)                  ###
    ###############################################################################

    [iavl]
    # Pruning Strategies:
    # - default: Keep the recent 362880 blocks and prune is triggered every 10 blocks
    # - nothing: all historic states will be saved, nothing will be deleted (i.e. archiving node)
    # - everything: all saved states will be deleted, storing only the recent 2 blocks; pruning at every block
    # - custom: allow pruning options to be manually specified through 'pruning-keep-recent' and 'pruning-interval'
    # Pruning strategy is completely ignored when seidb is enabled
    pruning = "nothing"

    # These are applied if and only if the pruning strategy is custom, and seidb is not enabled
    pruning-keep-recent = "0"
    pruning-keep-every = "0"
    pruning-interval = "0"

    ###############################################################################
    ###                        WASM Configuration (Auto-managed)                ###
    ###############################################################################

    [wasm]
    # This is the maximum sdk gas (wasm and storage) that we allow for any x/wasm "smart" queries
    query_gas_limit = 300000
    # This is the number of wasm vm instances we keep cached in memory for speed-up
    # Warning: this is currently unstable and may lead to crashes, best to keep for 0 unless testing locally
    lru_size = 0

    ###############################################################################
    ###                     ETH Replay Configuration (Auto-managed)             ###
    ###############################################################################

    [eth_replay]
    eth_replay_enabled = false
    eth_rpc = "http://44.234.105.54:18545"
    eth_data_dir = "/root/.ethereum/chaindata"
    eth_replay_contract_state_checks = false

    ###############################################################################
    ###                   ETH Block Test Configuration (Auto-managed)           ###
    ###############################################################################

    [eth_blocktest]
    eth_blocktest_enabled = false
    eth_blocktest_test_data_path = "~/testdata/"

    ###############################################################################
    ###                    EVM Query Configuration (Auto-managed)               ###
    ###############################################################################

    [evm_query]
    evm_query_gas_limit = 300000

    ###############################################################################
    ###                 Light Invariance Configuration (Auto-managed)           ###
    ###############################################################################

    [light_invariance]
    supply_enabled = true
    ```
  </Tab>

  <Tab title="config.toml">
    Tendermint / consensus-layer configuration: P2P, RPC, mempool, consensus,
    state-sync, etc.

    ```toml theme={"dark"}
    # This is a TOML config file.
    # For more information, see https://github.com/toml-lang/toml

    # NOTE: Any path below can be absolute (e.g. "/var/myawesomeapp/data") or
    # relative to the home directory (e.g. "data"). The home directory is
    # "$HOME/.tendermint" by default, but could be changed via $TMHOME env variable
    # or --home cmd flag.

    #######################################################################
    ###                   Main Base Config Options                      ###
    #######################################################################

    # TCP or UNIX socket address of the ABCI application,
    # or the name of an ABCI application compiled in with the Tendermint binary
    proxy-app = "tcp://127.0.0.1:26658"

    # A custom human readable name for this node
    moniker = "docs-example"

    # Mode of Node: full | validator | seed
    # * validator node
    #   - all reactors
    #   - with priv_validator_key.json, priv_validator_state.json
    # * full node
    #   - all reactors
    #   - No priv_validator_key.json, priv_validator_state.json
    # * seed node
    #   - only P2P, PEX Reactor
    #   - No priv_validator_key.json, priv_validator_state.json
    mode = "full"

    # Database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb
    # * goleveldb (github.com/syndtr/goleveldb - most popular implementation)
    #   - pure go
    #   - stable
    # * cleveldb (uses levigo wrapper)
    #   - fast
    #   - requires gcc
    #   - use cleveldb build tag (go build -tags cleveldb)
    # * boltdb (uses etcd's fork of bolt - github.com/etcd-io/bbolt)
    #   - EXPERIMENTAL
    #   - may be faster is some use-cases (random reads - indexer)
    #   - use boltdb build tag (go build -tags boltdb)
    # * rocksdb (uses github.com/tecbot/gorocksdb)
    #   - EXPERIMENTAL
    #   - requires gcc
    #   - use rocksdb build tag (go build -tags rocksdb)
    # * badgerdb (uses github.com/dgraph-io/badger)
    #   - EXPERIMENTAL
    #   - use badgerdb build tag (go build -tags badgerdb)
    db-backend = "goleveldb"

    # Database directory
    db-dir = "data"

    # Output level for logging, including package level options
    log-level = "info"

    # Output format: 'plain' (colored text) or 'json'
    log-format = "text"

    ##### additional base config options #####

    # Path to the JSON file containing the initial validator set and other meta data
    genesis-file = "config/genesis.json"

    # Path to the JSON file containing the private key to use for node authentication in the p2p protocol
    node-key-file = "config/node_key.json"

    # Mechanism to connect to the ABCI application: socket | grpc
    abci = "socket"

    # If true, query the ABCI app on connecting to a new peer
    # so the app can decide if we should keep the connection or not
    filter-peers = false

    #######################################################################
    ###                 Advanced Configuration Options                  ###
    #######################################################################

    #######################################################
    ###       RPC Server Configuration Options          ###
    #######################################################
    [rpc]

    # TCP or UNIX socket address for the RPC server to listen on
    laddr = "tcp://0.0.0.0:26657"

    # A list of origins a cross-domain request can be executed from
    # Default value '[]' disables cors support
    # Use '["*"]' to allow any origin
    cors-allowed-origins = []

    # A list of methods the client is allowed to use with cross-domain requests
    cors-allowed-methods = ["HEAD", "GET", "POST", ]

    # A list of non simple headers the client is allowed to use with cross-domain requests
    cors-allowed-headers = ["Origin", "Accept", "Content-Type", "X-Requested-With", "X-Server-Time", ]

    # Activate unsafe RPC commands like /dial-seeds and /unsafe-flush-mempool
    unsafe = false

    # Maximum number of simultaneous connections (including WebSocket).
    # If you want to accept a larger number than the default, make sure
    # you increase your OS limits.
    # 0 - unlimited.
    # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
    # 1024 - 40 - 10 - 50 = 924 = ~900
    max-open-connections = 900

    # Maximum number of unique clientIDs that can /subscribe
    # If you're using /broadcast_tx_commit, set to the estimated maximum number
    # of broadcast_tx_commit calls per block.
    max-subscription-clients = 100

    # Maximum number of unique queries a given client can /subscribe to
    # If you're using a Local RPC client and /broadcast_tx_commit, set this
    # to the estimated maximum number of broadcast_tx_commit calls per block.
    max-subscriptions-per-client = 5

    # If true, disable the websocket interface to the RPC service.  This has
    # the effect of disabling the /subscribe, /unsubscribe, and /unsubscribe_all
    # methods for event subscription.
    #
    # EXPERIMENTAL: This setting will be removed in Tendermint v0.37.
    experimental-disable-websocket = false

    # The time window size for the event log. All events up to this long before
    # the latest (up to EventLogMaxItems) will be available for subscribers to
    # fetch via the /events method.  If 0 (the default) the event log and the
    # /events RPC method are disabled.
    event-log-window-size = "30s"

    # The maxiumum number of events that may be retained by the event log.  If
    # this value is 0, no upper limit is set. Otherwise, items in excess of
    # this number will be discarded from the event log.
    #
    # Warning: This setting is a safety valve. Setting it too low may cause
    # subscribers to miss events.  Try to choose a value higher than the
    # maximum worst-case expected event load within the chosen window size in
    # ordinary operation.
    #
    # For example, if the window size is 10 minutes and the node typically
    # averages 1000 events per ten minutes, but with occasional known spikes of
    # up to 2000, choose a value > 2000.
    event-log-max-items = 0

    # How long to wait for a tx to be committed during /broadcast_tx_commit.
    # WARNING: Using a value larger than 10s will result in increasing the
    # global HTTP write timeout, which applies to all connections and endpoints.
    # See https://github.com/tendermint/tendermint/issues/3435
    timeout-broadcast-tx-commit = "10s"

    # Maximum size of request body, in bytes
    max-body-bytes = 1000000

    # Maximum size of request header, in bytes
    max-header-bytes = 1048576

    # The path to a file containing certificate that is used to create the HTTPS server.
    # Might be either absolute path or path related to Tendermint's config directory.
    # If the certificate is signed by a certificate authority,
    # the certFile should be the concatenation of the server's certificate, any intermediates,
    # and the CA's certificate.
    # NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server.
    # Otherwise, HTTP server is run.
    tls-cert-file = ""

    # The path to a file containing matching private key that is used to create the HTTPS server.
    # Might be either absolute path or path related to Tendermint's config directory.
    # NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server.
    # Otherwise, HTTP server is run.
    tls-key-file = ""

    # pprof listen address (https://golang.org/pkg/net/http/pprof)
    pprof-laddr = ""

    # timeout for any read request
    timeout-read = "10s"

    #######################################################################
    ###           P2P Configuration Options                             ###
    #######################################################################
    [p2p]

    # Select the p2p internal queue
    queue-type = "simple-priority"

    # Address to listen for incoming connections
    laddr = "tcp://0.0.0.0:26656"

    # Address to advertise to peers for them to dial
    # If empty, will use the same port as the laddr,
    # and will introspect on the listener or use UPnP
    # to figure out the address. ip and port are required
    # example: 159.89.10.97:26656
    external-address = ""

    # Comma separated list of peers to be added to the peer store
    # on startup. Either BootstrapPeers or PersistentPeers are
    # needed for peer discovery
    bootstrap-peers = ""

    # Comma separated list of nodes to keep persistent connections to
    persistent-peers = ""

    # Comma separated list of nodes for block sync only
    blocksync-peers = ""

    # UPNP port forwarding
    upnp = false

    # Maximum number of connections (inbound and outbound).
    max-connections = 100

    # Rate limits the number of incoming connection attempts per IP address.
    max-incoming-connection-attempts = 100

    # Set true to enable the peer-exchange reactor
    pex = true

    # Comma separated list of peer IDs to keep private (will not be gossiped to other peers)
    # Warning: IPs will be exposed at /net_info, for more information https://github.com/tendermint/tendermint/issues/3055
    private-peer-ids = ""

    # Toggle to disable guard against peers connecting from the same ip.
    allow-duplicate-ip = false

    # Peer connection configuration.
    handshake-timeout = "10s"
    dial-timeout = "3s"

    # Time to wait before flushing messages out on the connection
    # TODO: Remove once MConnConnection is removed.
    flush-throttle-timeout = "100ms"

    # Maximum size of a message packet payload, in bytes
    # TODO: Remove once MConnConnection is removed.
    # WARNING: coordinate before changing this default; impacts network interoperability
    max-packet-msg-payload-size = 1000000

    # Rate at which packets can be sent, in bytes/second
    # TODO: Remove once MConnConnection is removed.
    send-rate = 20971520

    # Rate at which packets can be received, in bytes/second
    # TODO: Remove once MConnConnection is removed.
    recv-rate = 20971520

    # List of node IDs, to which a connection will be (re)established, dropping an existing peer if any existing limit has been reached
    unconditional-peer-ids = ""

    #######################################################################
    ###          Mempool Configuration Options                          ###
    #######################################################################
    [mempool]

    # recheck has been moved from a config option to a global
    # consensus param in v0.36
    # See https://github.com/tendermint/tendermint/issues/8244 for more information.

    # Set true to broadcast transactions in the mempool to other nodes
    broadcast = true

    # Maximum number of transactions in the mempool
    size = 5000

    # Limit the total size of all txs in the mempool.
    # This only accounts for raw transactions (e.g. given 1MB transactions and
    # max-txs-bytes=5MB, mempool will only accept 5 transactions).
    max-txs-bytes = 1073741824

    # Size of the cache (used to filter transactions we saw earlier) in transactions
    cache-size = 10000

    # Size of the cache duplicate tx keys for tracking metrics
    duplicate-txs-cache-size = "100000"

    # Do not remove invalid transactions from the cache (default: false)
    # Set to true if it's not possible for any invalid transaction to become valid
    # again in the future.
    keep-invalid-txs-in-cache = false

    # Maximum size of a single transaction.
    # NOTE: the max size of a tx transmitted over the network is {max-tx-bytes}.
    max-tx-bytes = 1048576

    # Maximum size of a batch of transactions to send to a peer
    # Including space needed by encoding (one varint per transaction).
    # XXX: Unused due to https://github.com/tendermint/tendermint/issues/5796
    max-batch-bytes = 0

    # ttl-duration, if non-zero, defines the maximum amount of time a transaction
    # can exist for in the mempool.
    #
    # Note, if ttl-num-blocks is also defined, a transaction will be removed if it
    # has existed in the mempool at least ttl-num-blocks number of blocks or if it's
    # insertion time into the mempool is beyond ttl-duration.
    ttl-duration = "5s"

    # ttl-num-blocks, if non-zero, defines the maximum number of blocks a transaction
    # can exist for in the mempool.
    #
    # Note, if ttl-duration is also defined, a transaction will be removed if it
    # has existed in the mempool at least ttl-num-blocks number of blocks or if
    # it's insertion time into the mempool is beyond ttl-duration.
    ttl-num-blocks = 10

    tx-notify-threshold = 0

    check-tx-error-blacklist-enabled = true

    check-tx-error-threshold = 50

    pending-size = 5000

    max-pending-txs-bytes = 1073741824

    pending-ttl-duration = "0s"

    pending-ttl-num-blocks = 0

    # Defines the percentage of transactions with the lowest priority hint
    # (expressed as a percentage in the range [0.0, 1.0]) that will be
    # dropped from the mempool once the configured utilisation threshold
    # is reached.
    drop-priority-threshold = 0.1

    # Defines the mempool utilisation level (expressed as a percentage in
    # the range [0.0, 1.0]) above which transactions will be selectively
    # dropped based on their priority hint.
    #
    # For example, if this parameter is set to 0.8, then once the mempool reaches
    # 80% capacity, transactions with priority hints below drop-priority-threshold
    # percentile will be dropped to make room for new transactions.
    drop-utilisation-threshold = 1

    # Defines the size of the reservoir for keeping track
    # of the distribution of transaction priorities in the mempool.
    #
    # This is used to determine the priority threshold below which transactions will
    # be dropped when the mempool utilisation exceeds drop-priority-threshold.
    #
    # The reservoir is a statistically representative sample of transaction
    # priorities in the mempool, and is used to estimate the priority distribution
    # without needing to store all transaction priorities.
    #
    # A larger reservoir size will yield a more accurate estimate of the priority
    # distribution, but will consume more memory.
    #
    # The default value of 10,240 is a reasonable compromise between accuracy and
    # memory usage for most use cases. It takes approximately 80KB of memory storing
    # int64 transaction priorities.
    #
    # See DropUtilisationThreshold and DropPriorityThreshold.
    drop-priority-reservoir-size = 10240

    #######################################################################
    ###         State Sync Configuration Options                        ###
    #######################################################################
    [statesync]
    # State sync rapidly bootstraps a new node by discovering, fetching, and restoring a state machine
    # snapshot from peers instead of fetching and replaying historical blocks. Requires some peers in
    # the network to take and serve state machine snapshots. State sync is not attempted if the node
    # has any local state (LastBlockHeight > 0). The node will have a truncated block history,
    # starting from the height of the snapshot.
    enable = false

    # State sync uses light client verification to verify state. This can be done either through the
    # P2P layer or RPC layer. Set this to true to use the P2P layer. If false (default), RPC layer
    # will be used.
    use-p2p = false

    # If using RPC, at least two addresses need to be provided. They should be compatible with net.Dial,
    # for example: "host.example.com:2125"
    rpc-servers = ""

    # The hash and height of a trusted block. Must be within the trust-period.
    trust-height = 0
    trust-hash = ""

    # The trust period should be set so that Tendermint can detect and gossip misbehavior before
    # it is considered expired. For chains based on the Cosmos SDK, one day less than the unbonding
    # period should suffice.
    trust-period = "168h0m0s"

    # Backfill sequentially fetches after state sync completes, verifies and stores light blocks in reverse order.
    # backfill-blocks means it will keep reverse fetching up to backfill-blocks number of blocks behind state sync position
    # backfill-duration means it will keep fetching up to backfill-duration old time
    # The actual backfill process will take at backfill-blocks as priority:
    # - If backfill-blocks is set, use backfill-blocks to backfill
    # - If backfill-blocks is not set to be greater than 0, use backfill-duration to backfill
    backfill-blocks = "0"
    backfill-duration = "0s"

    # Time to spend discovering snapshots before initiating a restore.
    discovery-time = "15s"

    # Temporary directory for state sync snapshot chunks, defaults to os.TempDir().
    # The synchronizer will create a new, randomly named directory within this directory
    # and remove it when the sync is complete.
    temp-dir = ""

    # Whether to use local snapshot only for state sync or not.
    # If this is true, then state sync will look for existing snapshots
    # which are located in the snapshot-dir configured in app.toml (default to [home-dir]/data/snapshots)
    use-local-snapshot = false

    # The timeout duration before re-requesting a chunk, possibly from a different
    # peer (default: 15 seconds).
    chunk-request-timeout = "15s"

    # The number of concurrent chunk and block fetchers to run (default: 4).
    fetchers = "2"

    verify-light-block-timeout = "1m0s"

    blacklist-ttl = "5m0s"

    #######################################################################
    ###         Consensus Configuration Options                         ###
    #######################################################################
    [consensus]

    wal-file = "data/cs.wal/wal"

    # How many blocks to look back to check existence of the node's consensus votes before joining consensus
    # When non-zero, the node will panic upon restart
    # if the same consensus key was used to sign {double-sign-check-height} last blocks.
    # So, validators should stop the state machine, wait for some blocks, and then restart the state machine to avoid panic.
    double-sign-check-height = 0

    # EmptyBlocks mode and possible interval between empty blocks
    create-empty-blocks = true
    create-empty-blocks-interval = "0s"

    # Only gossip hashes, not the actual data
    gossip-tx-key-only = "true"

    # Reactor sleep duration parameters
    peer-gossip-sleep-duration = "100ms"
    peer-query-maj23-sleep-duration = "2s"

    ### Unsafe Timeout Overrides ###

    # These fields provide temporary overrides for the Timeout consensus parameters.
    # Use of these parameters is strongly discouraged. Using these parameters may have serious
    # liveness implications for the validator and for the chain.
    #
    # These fields will be removed from the configuration file in the v0.37 release of Tendermint.
    # For additional information, see ADR-74:
    # https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-074-timeout-params.md

    # This field provides an unsafe override of the Propose timeout consensus parameter.
    # This field configures how long the consensus engine will wait for a proposal block before prevoting nil.
    # If this field is set to a value greater than 0, it will take effect.
    unsafe-propose-timeout-override = "0s"

    # This field provides an unsafe override of the ProposeDelta timeout consensus parameter.
    # This field configures how much the propose timeout increases with each round.
    # If this field is set to a value greater than 0, it will take effect.
    unsafe-propose-timeout-delta-override = "0s"

    # This field provides an unsafe override of the Vote timeout consensus parameter.
    # This field configures how long the consensus engine will wait after
    # receiving +2/3 votes in a round.
    # If this field is set to a value greater than 0, it will take effect.
    unsafe-vote-timeout-override = "0s"

    # This field provides an unsafe override of the VoteDelta timeout consensus parameter.
    # This field configures how much the vote timeout increases with each round.
    # If this field is set to a value greater than 0, it will take effect.
    unsafe-vote-timeout-delta-override = "0s"

    # This field provides an unsafe override of the Commit timeout consensus parameter.
    # This field configures how long the consensus engine will wait after receiving
    # +2/3 precommits before beginning the next height.
    # If this field is set to a value greater than 0, it will take effect.
    unsafe-commit-timeout-override = "0s"

    # This field provides an unsafe override of the BypassCommitTimeout consensus parameter.
    # This field configures if the consensus engine will wait for the full Commit timeout
    # before proceeding to the next height.
    # If this field is set to true, the consensus engine will proceed to the next height
    # as soon as the node has gathered votes from all of the validators on the network.
    # unsafe-bypass-commit-timeout-override = <nil>

    #######################################################################
    ###   Transaction Indexer Configuration (Auto-managed)              ###
    #######################################################################
    [tx-index]

    # The backend database list to back the indexer.
    # If list contains "null" or "", meaning no indexer service will be used.
    #
    # The application will set which txs to index. In some cases a node operator will be able
    # to decide which txs to index based on configuration set in the application.
    #
    # Options:
    #   1) "null" (default) - no indexer services.
    #   2) "kv" - a simple indexer backed by key-value storage (see DBBackend)
    #   3) "psql" - the indexer services backed by PostgreSQL.
    # When "kv" or "psql" is chosen "tx.height" and "tx.hash" will always be indexed.
    indexer = ["kv"]

    # The PostgreSQL connection configuration, the connection format:
    #   postgresql://<user>:<password>@<host>:<port>/<db>?<opts>
    psql-conn = ""

    #######################################################################
    ###       Instrumentation Configuration (Auto-managed)             ###
    #######################################################################
    [instrumentation]

    # When true, Prometheus metrics are served under /metrics on
    # PrometheusListenAddr.
    # Check out the documentation for the list of available metrics.
    prometheus = false

    # Address to listen for Prometheus collector(s) connections
    prometheus-listen-addr = ":26660"

    # Maximum number of simultaneous connections.
    # If you want to accept a larger number than the default, make sure
    # you increase your OS limits.
    # 0 - unlimited.
    max-open-connections = 3

    # Instrumentation namespace
    namespace = "tendermint"

    #######################################################################
    ###       Priv Validator Configuration (Auto-managed)              ###
    #######################################################################
    [priv-validator]

    # Path to the JSON file containing the private key to use as a validator in the consensus protocol
    key-file = "config/priv_validator_key.json"

    # Path to the JSON file containing the last sign state of a validator
    state-file = "data/priv_validator_state.json"

    # TCP or UNIX socket address for Tendermint to listen on for
    # connections from an external PrivValidator process
    # when the listenAddr is prefixed with grpc instead of tcp it will use the gRPC Client
    laddr = ""

    # Path to the client certificate generated while creating needed files for secure connection.
    # If a remote validator address is provided but no certificate, the connection will be insecure
    client-certificate-file = ""

    # Client key generated while creating certificates for secure connection
    client-key-file = ""

    # Path to the Root Certificate Authority used to sign both client and server certificates
    root-ca-file = ""

    #######################################################################
    ###       SelfRemediation Configuration (Auto-managed)             ###
    #######################################################################
    [self-remediation]

    # If the node has no p2p peers available then trigger a restart
    # Set to 0 to disable
    p2p-no-peers-available-window-seconds = 0

    # If node has no peers for statesync after a period of time then restart
    # Set to 0 to disable
    statesync-no-peers-available-window-seconds = 0

    # Threshold for how far back the node can be behind the current block height before triggering a restart
    # Set to 0 to disable
    blocks-behind-threshold = 0

    # How often to check if node is behind
    blocks-behind-check-interval = 60

    # Cooldown between each restart
    restart-cooldown-seconds = 600
    ```
  </Tab>

  <Tab title="client.toml">
    CLI and client defaults used by `seid` itself (chain id, keyring backend,
    output format, node endpoint).

    ```toml theme={"dark"}
    # This is a TOML config file.
    # For more information, see https://github.com/toml-lang/toml

    ###############################################################################
    ###                           Client Configuration                            ###
    ###############################################################################

    # The network chain ID
    chain-id = "pacific-1"
    # The keyring's backend, where the keys are stored (os|file|kwallet|pass|test|memory)
    keyring-backend = "os"
    # CLI output format (text|json)
    output = "text"
    # <host>:<port> to Tendermint RPC interface for this chain
    node = "tcp://localhost:26657"
    # Transaction broadcasting mode (sync|async|block)
    broadcast-mode = "sync"
    ```
  </Tab>
</Tabs>

## Database Management

### Architecture

Sei stores chain data through **SeiDB**, a two-layer design that replaces the
legacy single-database IAVL store with separate hot- and historical-data tiers:

1. **State Commit (SC)** — the active chain state used for transaction
   execution and to compute the per-block app hash. Cosmos modules sit on a
   memory-mapped Merkle tree (`memiavl`) ported from Cronos. EVM state can
   additionally be routed through **FlatKV**, an EVM-tuned PebbleDB store
   with per-type sub-databases (`account`, `code`, `storage`, `legacy`,
   `metadata`). Routing is controlled by `sc-write-mode` / `sc-read-mode`
   and defaults to memiavl-only — FlatKV is only opened when one of those
   modes is set to a non-default value.
2. **State Store (SS)** — versioned raw key/value pairs used for historical
   queries. Required for any node that serves RPC. The default backend is
   **PebbleDB**; **RocksDB** is available for iteration-heavy workloads such
   as archive nodes or RPC nodes that run a lot of `debug_trace*` (see the
   [RocksDB Backend Guide](/node/rocksdb-backend) for build instructions).

The legacy IAVL backend is still selectable via `sc-enable = false` but is
deprecated and slated for removal — new deployments and existing nodes
should run on SeiDB.

### SeiDB Configuration

The full set of knobs is in the auto-generated
[Default Configurations](#default-configurations) above. The block below
covers the values most node operators tune in practice.

```toml theme={"dark"}
[state-commit]
# Enable SeiDB. Disable to fall back to legacy IAVL.
sc-enable = true

# Async commit queue. Larger values improve catch-up; 0 = synchronous.
sc-async-commit-buffer = 100

# How many memiavl snapshots to keep besides the latest one.
# 0 = current snapshot only. Set to 1 if you serve IBC light-client queries
# so relayers can verify against an older snapshot height.
sc-keep-recent = 1

# Take a state-commit snapshot every N blocks.
sc-snapshot-interval = 10000

# Minimum wall-clock interval (seconds) between snapshots; prevents overlap
# during catch-up. Lower this if you set sc-snapshot-interval below ~5000.
sc-snapshot-min-time-interval = 3600

# Cap on snapshot write throughput across all trees (MB/s). 0 = unlimited.
sc-snapshot-write-rate-mbps = 100

# EVM data routing between the Cosmos memiavl tree and FlatKV.
# Default: cosmos_only / cosmos_only — all EVM state lives in memiavl. See
# the Giga Storage section below for the dual_write + split_read setup.
sc-write-mode = "cosmos_only"
sc-read-mode = "cosmos_only"
sc-enable-lattice-hash = false

[state-commit.flatkv]
# FlatKV is the EVM-optimized commit store (PebbleDB). It is only opened
# when sc-write-mode is dual_write or split_write — otherwise these
# settings have no effect. WAL crash recovery is idempotent, so fsync
# stays off by default.
fsync = false
async-write-buffer = 0
snapshot-interval = 10000
snapshot-keep-recent = 2

[state-store]
# Historical SS layer. Validators can disable this to save disk; any node
# serving RPC must keep it on.
ss-enable = true

# pebbledb (default) or rocksdb (faster iteration, archive-friendly).
ss-backend = "pebbledb"

ss-async-write-buffer = 100
# Versions to retain. 0 = keep everything (archive-style). 100,000 ≈ 28h.
ss-keep-recent = 100000
# Pruning interval, plus a small random jitter, to avoid colliding with
# snapshot creation.
ss-prune-interval = 600

# Optional EVM SS routing — same semantics as the SC modes above. Leave on
# cosmos_only unless you have completed the Giga SS Store migration.
evm-ss-write-mode = "cosmos_only"
evm-ss-read-mode = "cosmos_only"
evm-ss-separate-dbs = false

[receipt-store]
# pebbledb (default) or parquet. Receipts are pruned together with blocks
# according to min-retain-blocks above.
rs-backend = "pebbledb"
async-write-buffer = 100
prune-interval-seconds = 600
```

Setting small (more frequent) pruning intervals may collide with
snapshot creation. Too-large (less frequent) intervals mean pruning takes
longer overall, which can cause missed blocks and excessive resync time.

### Giga Storage and Giga Executor

These are two **separate** opt-in features that ship in newer `seid`
releases. Both default to off; only enable them deliberately and after
following the relevant migration guide.

**Giga Storage** repartitions SeiDB so EVM state lives in its own
databases at both the SC and SS layers, freeing non-EVM modules from EVM
write amplification.

<Info>For step-by-step instructions — including the full state-sync flow, startup verification, safety checks, and rollback — see the [Giga SS Store Migration Guide](/node/giga-storage-migration). The snippet below is just the resulting `app.toml` shape.</Info>

```toml theme={"dark"}
[state-commit]
sc-write-mode = "dual_write"   # write EVM data to memiavl AND FlatKV
sc-read-mode = "split_read"    # read EVM data from FlatKV
sc-enable-lattice-hash = true  # required for split-mode app-hash equality

[state-store]
evm-ss-write-mode = "split_write"
evm-ss-read-mode = "split_read"
```

Enabling Giga Storage requires a fresh state sync — flipping the EVM SS
modes on a node with existing data fails the startup safety checks because
the new EVM SS DB starts empty while Cosmos SS already has history. The
full procedure is in the
[Giga SS Store Migration Guide](/node/giga-storage-migration) and is
currently supported on **RPC nodes only**; validators and archive nodes are
not yet covered.

**Giga Executor** is independent of Giga Storage. It swaps the EVM
interpreter from go-ethereum's geth to an evmone-based executor for
higher throughput, with optional OCC parallelism on top:

```toml theme={"dark"}
[giga_executor]
# Use the evmone-based executor instead of geth's interpreter. Experimental.
enabled = false
# Run Giga-executed txs in parallel with Optimistic Concurrency Control.
occ_enabled = false
```

### Database Maintenance

The database is typically stable and can be left alone, although some attention
may be required:

```bash theme={"dark"}
# Check database size
du -sh $HOME/.sei/data/

# Confirm correct file paths as per your own setup before proceeding.
# Back up the data directory BEFORE wiping it:
cp -r $HOME/.sei/data/ $HOME/sei-backup-$(date +%Y%m%d)/

# Your keys and config live in $HOME/.sei/config and are NOT removed by the
# wipe below, but keep them safe regardless:
# - `node_key.json`: Preserves node identity to maintain peer connections.
# - `priv_validator_key.json`: Critical for validators; losing this key results in double signing risks.
# - `config.toml` & `app.toml`: Retains node-specific configuration.
# - `genesis.json`: Required for correct chain initialization.

# Wipe database for a fresh resync (destructive — deletes all chain data
# except priv_validator_state.json)
find $HOME/.sei/data/ -mindepth 1 ! -name 'priv_validator_state.json' -delete && rm -rf $HOME/.sei/wasm
```

<Warning>The wipe command above deletes the entire local database (everything except `priv_validator_state.json`) and the `wasm` folder. It does not compact data in place — after running it, the node must be re-synced from a [snapshot](/node/snapshot) or via [state sync](/node/statesync) before it can serve traffic again.</Warning>

## Service Management

### Systemd Commands

```bash theme={"dark"}
# Check service status
systemctl status seid

# Start service
systemctl start seid

# Stop service
systemctl stop seid

# Restart service
systemctl restart seid

# View logs in real time
journalctl -fu seid -o cat
```

### Log Management

Prevent logs from consuming excessive disk space by enabling rotation:

```bash theme={"dark"}
sudo tee /etc/logrotate.d/sei > /dev/null << EOF
/var/log/sei/*.log {
    daily
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 sei sei
    sharedscripts
    postrotate
        systemctl reload seid
    endscript
}
EOF
```

## Update Procedures

### Minor Updates

For minor updates that are non-consensus-breaking:

```bash theme={"dark"}
# Stop node
sudo systemctl stop seid

# Update binary
cd sei-chain
git fetch --all
git checkout [new-version]
make install

# Restart node
sudo systemctl restart seid
```

### Major Updates

For major upgrades that introduce state-breaking changes:

1. Wait for the designated upgrade block height \[this can be seen in the upgrade
   proposal under 'plan']
2. The node will halt automatically.
3. Update/replace the binary
4. Restart the node.

```bash theme={"dark"}
# After node halts
cd sei-chain
git pull
git checkout [new-version]
make install
sudo systemctl restart seid
```

<Tip>
  Build the upgrade before the halt-height so you can quickly replace it
  with minimal downtime.
</Tip>

## Performance Optimization

Performance optimizations can yield different results depending on your system's
hardware, workload, and network conditions. Before implementing any changes,
research and test them in a controlled environment to ensure they align with
your specific configuration and requirements. Always back up important data
before making modifications.

### Memory Management (sysctl tuning)

Optimizing memory management settings can help improve performance and
stability, particularly for high-load nodes. These settings control swap usage
and the handling of dirty (unwritten) pages in RAM.

```bash theme={"dark"}
vm.swappiness = 1  # Reduce swapping to disk, ensuring RAM is used efficiently before relying on slower swap space
vm.dirty_background_ratio = 3  # The percentage of system memory that can be filled with "dirty" pages before background writing begins
vm.dirty_ratio = 10  # The maximum percentage of system memory that can be filled with "dirty" pages before a full flush is triggered
vm.dirty_expire_centisecs = 300  # Time (in hundredths of a second) before dirty data is written to disk
vm.dirty_writeback_centisecs = 100  # Frequency (in hundredths of a second) at which the system writes "dirty" pages to disk
```

### Network Stack Optimization

Tuning the network stack can enhance packet processing efficiency and
throughput, particularly for nodes handling a large number of peers and high
transaction volume.

```bash theme={"dark"}
net.core.somaxconn = 32768  # max connections in queued
net.core.netdev_max_backlog = 32768  # packets allowed in queue before dropping incoming packets
net.ipv4.tcp_max_syn_backlog = 16384  # outstanding SYN requests (half-open connections) allowed before dropping new connections
net.core.rmem_max = 16777216  # receive buffer size for network sockets
net.core.wmem_max = 16777216  # send buffer size for network sockets
```

### Storage Optimization

Optimizing storage settings can significantly reduce write latency and improve
database performance, especially for nodes using NVMe SSDs.

```bash theme={"dark"}
echo "none" > /sys/block/nvme0n1/queue/scheduler  # disable I/O scheduler to reduce latency
blockdev --setra 4096 /dev/nvme0n1  # readahead value to optimize sequential reads
```

## Backup and Recovery

### Regular Backups

Automate backups to avoid data loss:

```bash theme={"dark"}
#!/bin/bash
BACKUP_DIR="/backup/sei"
DATE=$(date +%Y%m%d)

# Stop service
systemctl stop seid

# Create backup
tar czf $BACKUP_DIR/sei-backup-$DATE.tar.gz $HOME/.sei/

# Restart service
systemctl start seid
```

### Recovery Procedure

Restoring from backup in case of corruption or accidental deletion:

```bash theme={"dark"}
# Stop node
systemctl stop seid

# Remove corrupted data
rm -rf $HOME/.sei/data/

# Restore from backup
tar xzf sei-backup-[date].tar.gz -C /

# Restart node
systemctl start seid
```

## Security Considerations

* Use firewalls and rate-limiting to prevent attacks
* Keep your system and node software updated
* Secure SSH access with key-based authentication
* Protect validator keys with offline storage or hardware security modules
  (HSMs)

For more in-depth system and configuration guidelines, refer to the [Advanced
Configuration and Monitoring Guide](/node/advanced-config-monitoring).

---

URL: https://docs.sei.io/node/seictl

# Configure Nodes with seictl

> Install and use the seictl CLI to patch Sei node configuration and genesis files safely with merge-patch workflows.

`seictl` is a purpose-built CLI that helps Sei node patch configuration TOML files (`app.toml`, `client.toml`, `config.toml`) and JSON genesis files.

<Info>You can find the `seictl` GitHub repository [here](https://github.com/sei-protocol/seictl) </Info>

## Features

* **Configuration Management**: Patch Sei daemon configuration files (`app.toml`, `client.toml`, `config.toml`)
* **Genesis Management**: Apply merge patches to genesis JSON files
* **Universal Patching**: Apply merge patches to any TOML or JSON file
* **Smart Target Detection**: Automatically detects which configuration file to modify based on patch content
* **Flexible Output**: Write to stdout, a specific file, or modify files in-place
* **Atomic Writes**: Safe file modifications using atomic write operations
* **Merge Patch Algorithm**: Intelligently merges patches with existing configurations

## Installation

### Pre-built Binaries (Recommended)

Pre-built binaries are available for Linux, macOS, and Windows. Download the latest release from
the [releases page](https://github.com/sei-protocol/seictl/releases).

#### Quick Install

<Accordion title="Linux (x86_64)">
  ```bash theme={"dark"}
  curl -LO https://github.com/sei-protocol/seictl/releases/latest/download/seictl_Linux_x86_64.tar.gz
  tar -xzf seictl_Linux_x86_64.tar.gz
  sudo mv seictl /usr/local/bin/
  ```
</Accordion>

<Accordion title="Linux (ARM64)">
  ```bash theme={"dark"}
  curl -LO https://github.com/sei-protocol/seictl/releases/latest/download/seictl_Linux_arm64.tar.gz
  tar -xzf seictl_Linux_arm64.tar.gz
  sudo mv seictl /usr/local/bin/
  ```
</Accordion>

<Accordion title="Linux (ARMv7)">
  ```bash theme={"dark"}
  curl -LO https://github.com/sei-protocol/seictl/releases/latest/download/seictl_Linux_armv7.tar.gz
  tar -xzf seictl_Linux_armv7.tar.gz
  sudo mv seictl /usr/local/bin/
  ```
</Accordion>

<Accordion title="macOS (Apple Silicon)">
  ```bash theme={"dark"}
  curl -LO https://github.com/sei-protocol/seictl/releases/latest/download/seictl_Darwin_arm64.tar.gz
  tar -xzf seictl_Darwin_arm64.tar.gz
  sudo mv seictl /usr/local/bin/
  ```
</Accordion>

<Accordion title="macOS (Intel)">
  ```bash theme={"dark"}
  curl -LO https://github.com/sei-protocol/seictl/releases/latest/download/seictl_Darwin_x86_64.tar.gz

  tar -xzf seictl_Darwin_x86_64.tar.gz
  sudo mv seictl /usr/local/bin/
  ```
</Accordion>

<Accordion title="Windows (x86_64)">
  ```powershell theme={"dark"}
  # Download from: https://github.com/sei-protocol/seictl/releases/latest/download/seictl_Windows_x86_64.zip
  # Extract and add to PATH
  ```
</Accordion>

#### Verify Installation

```bash theme={"dark"}
seictl --version
```

#### Verify Download (Optional)

All releases include a `checksums.txt` file for verification, e.g.:

```bash theme={"dark"}
# Download checksums
curl -LO https://github.com/sei-protocol/seictl/releases/latest/download/checksums.txt

# Verify (Linux/macOS)
sha256sum -c checksums.txt 2>&1 | grep seictl_Linux_x86_64.tar.gz
```

### Build from Source

If you prefer to build from source or need a specific configuration:

#### Prerequisites

* Go 1.24.5 or higher

#### Build

```bash theme={"dark"}
git clone https://github.com/sei-protocol/seictl.git
cd seictl
go build -o seictl
```

### Install via Go

```bash theme={"dark"}
go install github.com/sei-protocol/seictl@latest
```

## Usage

```
seictl [global options] command [command options] [arguments...]
```

### Global Options

* `--home <path>`: Sei home directory (default: `~/.sei`, can be set via `SEI_HOME` environment variable)

## Commands

### Patch Command

#### `patch`

Apply a merge-patch to any TOML or JSON file. This is a universal patching command that works with any file format, not
just Sei-specific configurations.

```bash theme={"dark"}
seictl patch --target <file-path> [patch-file]
```

**Options:**

* `--target <path>`: Path to the TOML or JSON file to patch (required)
* `-o, --output <path>`: Write output to specified file
* `-i, --in-place-rewrite`: Modify the target file in-place

**Examples:**

```bash theme={"dark"}
# Patch any TOML file
seictl patch --target /path/to/config.toml patch.toml

# Patch any JSON file from stdin
echo '{"new_key": "value"}' | seictl patch --target /path/to/data.json

# Patch and save to a new file
seictl patch --target myconfig.toml patch.toml -o modified.toml

# Patch and modify in-place
seictl patch --target settings.json patch.json -i
```

**Note:** The file extension (`.toml` or `.json`) is used to determine the format automatically.

### Genesis Commands

#### `genesis patch`

Apply a merge-patch to the Sei genesis JSON file.

```bash theme={"dark"}
seictl genesis patch [patch-file]
```

**Options:**

* `-o, --output <path>`: Write output to specified file
* `-i, --in-place-rewrite`: Modify the genesis file in-place

**Examples:**

```bash theme={"dark"}
# Patch from file and output to stdout
seictl genesis patch patch.json

# Patch from stdin
echo '{"chain_id": "atlantic-2"}' | seictl genesis patch

# Patch and save to a new file
seictl genesis patch patch.json -o genesis-modified.json

# Patch and modify the original file in-place
seictl genesis patch patch.json -i
```

### Config Commands

#### `config patch`

Apply a merge-patch to a Sei configuration TOML file.

```bash theme={"dark"}
seictl config [--target <app|client|config>] patch [patch-file]
```

**Options:**

* `--target <type>`: Specify which configuration file to patch (`app`, `client`, or `config`)
  * If not specified, the target is automatically detected based on the patch content
* `-o, --output <path>`: Write output to specified file
* `-i, --in-place-rewrite`: Modify the configuration file in-place

**Examples:**

```bash theme={"dark"}
# Patch with auto-detection
seictl config patch patch.toml

# Explicitly specify the target config
seictl config --target app patch patch.toml

# Patch from stdin and output to stdout
echo 'minimum-gas-prices = "0.02usei"' | seictl config patch

# Patch and modify in-place
seictl config --target app patch patch.toml -i

# Patch and save to specific location
seictl config patch patch.toml -o /path/to/output.toml
```

## Configuration Targets

The `config` command can work with three different configuration files:

### `app.toml`

Application-level configuration including:

* Gas prices and block settings
* State management (state-sync, state-commit, state-store)
* EVM configuration
* Telemetry and monitoring
* API, gRPC, and Rosetta endpoints
* IAVL and WASM settings

### `client.toml`

Client-level configuration including:

* Chain ID
* Keyring backend
* Output format
* Node endpoint
* Broadcast mode

### `config.toml`

Node-level configuration including:

* Proxy app and database settings
* Logging configuration
* RPC and P2P settings
* Mempool and consensus parameters
* State sync and block sync
* Transaction indexing

## Merge Patch Behavior

The merge patch algorithm works as follows:

1. **Nested merging**: Patches are merged recursively into nested structures
2. **Null deletion**: Setting a value to `null` removes that key from the configuration
3. **Addition**: New keys in the patch are added to the configuration
4. **Replacement**: Existing scalar values are replaced with patch values

**Example:**

Original:

```toml theme={"dark"}
[api]
enable = true
address = "tcp://0.0.0.0:1317"
```

Patch:

```toml theme={"dark"}
[api]
address = "tcp://0.0.0.0:1318"
swagger = true
```

Result:

```toml theme={"dark"}
[api]
enable = true
address = "tcp://0.0.0.0:1318"
swagger = true
```

## Examples

<Accordion title="Update Minimum Gas Prices">
  ```bash theme={"dark"}
  echo 'minimum-gas-prices = "0.02usei"' | seictl config patch -i
  ```
</Accordion>

<Accordion title="Enable API Endpoint">
  ```bash theme={"dark"}
  cat > patch.toml << EOF
  [api]
  enable = true
  address = "tcp://0.0.0.0:1317"
  EOF

  seictl config --target app patch patch.toml -i
  ```
</Accordion>

<Accordion title="Modify Genesis Chain ID">
  ```bash theme={"dark"}
  echo '{"chain_id": "pacific-1"}' | seictl genesis patch -i
  ```
</Accordion>

<Accordion title="Update Multiple Configuration Sections">
  ```bash theme={"dark"}
  cat > patch.toml << EOF
  minimum-gas-prices = "0.02usei"

  [telemetry]
  enabled = true
  prometheus-retention-time = 60

  [api]
  enable = true
  swagger = true
  EOF

  seictl config patch patch.toml -i
  ```
</Accordion>

<Accordion title="Patch a Custom TOML Configuration">
  ```bash theme={"dark"}
  # Patch any TOML file outside the Sei directory structure
  cat > custom-patch.toml << EOF
  [database]
  host = "localhost"
  port = 5432
  EOF

  seictl patch --target /etc/myapp/config.toml custom-patch.toml -i
  ```
</Accordion>

<Accordion title="Patch a Custom JSON Data File">
  ```bash theme={"dark"}
  # Modify any JSON file
  echo '{"version": "2.0", "debug": true}' | seictl patch --target /path/to/settings.json -i
  ```
</Accordion>

<Accordion title="Using Custom Sei Home Directory">
  ```bash theme={"dark"}
  # Via environment variable
  export SEI_HOME=/custom/path/.sei
  seictl config patch patch.toml

  # Via flag
  seictl --home /custom/path/.sei config patch patch.toml
  ```
</Accordion>

## Command Comparison

### When to Use Each Command

* **`patch`**: Use for patching any arbitrary TOML or JSON file on your system. Requires explicit `--target` path.
* **`genesis patch`**: Use specifically for Sei genesis files. Automatically uses `$HOME/.sei/config/genesis.json`.
* **`config patch`**: Use specifically for Sei configuration files with automatic target detection. Automatically uses
  files in `$HOME/.sei/config/`.

## File Locations

By default, `seictl` looks for configuration files in the following locations:

* Genesis: `$HOME/.sei/config/genesis.json`
* App config: `$HOME/.sei/config/app.toml`
* Client config: `$HOME/.sei/config/client.toml`
* Node config: `$HOME/.sei/config/config.toml`

Where `$HOME` is the value of the `--home` flag or the `SEI_HOME` environment variable.

## Safety Features

* **Atomic Writes**: All file modifications use atomic write operations (write to temp file, then rename)
* **Permission Preservation**: In-place modifications preserve original file permissions
* **Format Validation**: Validates file extensions before processing (must be `.toml` or `.json`)
* **Target Validation**: Prevents accidental modification of wrong configuration files
* **Auto-detection Safety**: Refuses to proceed if patch could apply to multiple targets
* **Early Validation**: Checks file format and existence before reading patch data

---

URL: https://docs.sei.io/node/statesync

# Join the network using StateSync

> Detailed guide for using statesync to join the network

Follow this guide to join an existing network through statesync. To quickly spin up a fresh full node and join in the network, it's recommended to sync through state sync.

## State Sync

State sync allows a new node to join a network by fetching a snapshot of the application state at a recent height instead of fetching and replaying all historical blocks. This can reduce the time needed to sync with the network from days to minutes.

## Clean Up

If you are not starting a node from fresh, then you need to do some backups and clean ups.

<Info>Note: This step is not needed for fresh nodes.</Info>

Assuming your sei home directory is `$HOME/.sei`, back up `priv_validator_key.json` and `priv_validator_state.json`:

```bash theme={"dark"}
cp $HOME/.sei/data/priv_validator_state.json $HOME/priv_validator_state.json
cp $HOME/.sei/config/priv_validator_key.json $HOME/priv_validator_key.json
```

Reset the state:

```bash theme={"dark"}
seid tendermint unsafe-reset-all --home $HOME/.sei
```

Finally, remove the existing data and wasm folders and restore the `priv_validator_state.json`:

```bash theme={"dark"}
rm -rf $HOME/.sei/data/*
rm -rf $HOME/.sei/wasm
cp $HOME/priv_validator_state.json $HOME/.sei/data/priv_validator_state.json
```

## Statesync script

Set up the RPC servers for primary and secondary endpoints. You can use one of these RPC endpoints for Statesyning

For `STATE_SYNC_RPC`, pick:

* mainnet (pacific-1): `https://sei-rpc.polkachu.com:443` or `https://rpc.sei-apis.com:443`
* testnet (atlantic-2): `https://sei-testnet-rpc.polkachu.com:443` or `https://rpc-testnet.sei-apis.com:443`

For `STATE_SYNC_PEER`, pick the below as `persistent-peers`:

* mainnet (pacific-1):

```bash theme={"dark"}
3be6b24cf86a5938cce7d48f44fb6598465a9924@p2p.state-sync-0.pacific-1.seinetwork.io:26656,b21279d7092fde2e41770832a1cacc7d0051e9dc@p2p.state-sync-1.pacific-1.seinetwork.io:26656,616c05e9ba24acc89c0de630b5e3adbedaebb478@p2p.state-sync-2.pacific-1.seinetwork.io:26656
```

* testnet (atlantic-2):

```bash theme={"dark"}
b2664ccaa84a04b67683093fefb802b172ead6d1@sei-a2-rpc.p2p.brocha.in:30612,babc3f3f7804933265ec9c40ad94f4da8e9e0017@testnet-seed.rhinostake.com:11956
```

The script sets up `trust_height` and `trust_hash` automatically. Each statesync snapshot is created at a certain block height. The script uses the best practice here and sets the trust height to be earlier than the latest snapshot block height to avoid backward verifications.

Script that you can use:

```bash title="state_sync.sh" theme={"dark"}
#!/bin/bash

# Prompt for the State Sync RPC Endpoint and store it in STATE_SYNC_RPC
echo -n State Sync RPC Endpoint:
read STATE_SYNC_RPC
echo

# Prompt for the State Sync Peer and store it in STATE_SYNC_PEER
echo -n State Sync Peer:
read STATE_SYNC_PEER
echo

# Create a backup directory for keys
mkdir -p $HOME/key_backup

# Backup the validator key and state files
cp $HOME/.sei/config/priv_validator_key.json $HOME/key_backup
cp $HOME/.sei/data/priv_validator_state.json $HOME/key_backup

# Create a backup directory for the entire .sei configuration
mkdir -p $HOME/.sei_backup

# Copy existing config, data, and wasm directories to the backup directory
cp -r $HOME/.sei/config $HOME/.sei_backup/
cp -r $HOME/.sei/data $HOME/.sei_backup/
cp -r $HOME/.sei/wasm $HOME/.sei_backup/ 2>/dev/null || true  # ignore error if wasm doesn't exist

# Create a temp directory on the main disk  and set the path in config.toml
mkdir -p /home/ubuntu/statesync-temp
sed -i 's|temp-dir = ""|temp-dir = "/home/ubuntu/statesync-temp"|' ~/.sei/config/config.toml

# Fetch the latest block height from the State Sync RPC endpoint
LATEST_HEIGHT=$(curl -s $STATE_SYNC_RPC/block | jq -r .block.header.height)
# Calculate the trust height (rounded down to the nearest 100,000)
BLOCK_HEIGHT=$(( (LATEST_HEIGHT / 100000) * 100000 ))
# Fetch the block hash at the trust height
TRUST_HASH=$(curl -s "$STATE_SYNC_RPC/block?height=$BLOCK_HEIGHT" | jq -r .block_id.hash)

# Update the config.toml file to enable state sync with the appropriate settings
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true| ; \
s|^(rpc-servers[[:space:]]+=[[:space:]]+).*$|\1\"$STATE_SYNC_RPC,$STATE_SYNC_RPC\"| ; \
s|^(trust-height[[:space:]]+=[[:space:]]+).*$|\1$BLOCK_HEIGHT| ; \
s|^(trust-hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"|" $HOME/.sei/config/config.toml

# Set the persistent peers in the config.toml file to the specified State Sync Peer
sed -i.bak -e "s|^persistent-peers *=.*|persistent-peers = \"$STATE_SYNC_PEER\"|" \
  $HOME/.sei/config/config.toml
```

Finally start the daemon:

```bash theme={"dark"}
sudo systemctl start seid
```

## Troubleshooting statesync

**Q:** I can't connect to the state sync url.

**A:** Try another statesync url in that case and inform us in the [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk).

**Q:** The statesync finishes, but immediately get `AppHash` errors upon regular block syncing:

**A:** Make sure that you use the latest version of the chain node when you state-sync.

**Q:** The statesync randomly stops.

**A:** State-sync can be flaky at times, just try again. Please give it around 4-5 tries. Join our [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk) for help if you have any issues.

---

URL: https://docs.sei.io/node/snapshot

# Join the network using Snapshots

> Detailed guide for using snapshots to join the network

<Warning>Before you resync a node using snapshots, make sure that in case of a successful resync that you *under no circumstance* double sign blocks at previous heights with your validator. Failure to do so will cause tombstoning of your validator.</Warning>

Follow this guide to join an existing network through **snapshot sync**. To quickly spin up a fresh full node and join the network, it's recommended to restore from a snapshot instead of replaying all historical blocks.

## Snapshot Sync

Snapshot sync allows a new node to join a network by downloading a recent, compressed copy of the entire application state and extracting it directly into the data directory. This reduces the initial sync time from days to minutes.

## Snapshot Providers

You can select from various providers for downloading snapshots:

* Polkachu: [Mainnet Snapshots](https://www.polkachu.com/tendermint_snapshots/sei) | [Testnet Snapshots](https://www.polkachu.com/testnets/sei/snapshots)
* Imperator.co
* Stakeme
* kjnodes

<iframe src="https://seistream.app/labs?page=snapshots" width="100%" height="600" style={{ border: 'none', borderRadius: '8px' }} title="Sei Snapshot Providers" />

## Clean Up & Preparation

If you are **not** starting a node from fresh, perform the following backups and clean‑ups first.

<Info>Note: This step is not needed for fresh nodes.</Info>

1. **Stop the service**

   ```bash theme={"dark"}
   sudo systemctl stop seid
   ```

2. **Backup Validator State** (Critical for Validators)
   Assuming your sei home directory is `$HOME/.sei`, back up `priv_validator_key.json` and `priv_validator_state.json`:

   ```bash theme={"dark"}
   cp $HOME/.sei/data/priv_validator_state.json $HOME/priv_validator_state.json
   cp $HOME/.sei/config/priv_validator_key.json $HOME/priv_validator_key.json
   ```

3. **Reset the State**

   ```bash theme={"dark"}
   seid tendermint unsafe-reset-all --home $HOME/.sei
   ```

4. **Remove Data and Wasm**
   ```bash theme={"dark"}
   rm -rf $HOME/.sei/data
   rm -rf $HOME/.sei/wasm
   ```

<Warning>All snapshots also include the `wasm` folder. Make sure to copy over the `wasm` folder as well, the node cannot successfully sync without it.</Warning>

## Download & Restore

<Info>The following commands are generic examples. Please verify the `SNAPSHOT_URL` and extraction command from your chosen provider above.</Info>

### Prerequisites

Ensure you have the necessary tools installed (e.g., `lz4`, `aria2`, `pv`, `wget`).

```bash theme={"dark"}
sudo apt update
sudo apt install curl lz4 wget aria2 pv -y
```

### Download and Extract

1. **Set the Snapshot URL**
   Replace `<SNAPSHOT_URL>` with the link from your chosen provider.

   ```bash theme={"dark"}
   SNAPSHOT_URL="<PASTE_SNAPSHOT_URL_HERE>"
   ```

2. **Download and Extract**
   Most providers compress the `data` and `wasm` directory directly. The following command streams the download and extracts it into `$HOME/.sei`.

   ```bash theme={"dark"}
   curl -L $SNAPSHOT_URL | lz4 -c -d | tar -x -C $HOME/.sei
   ```

   **Alternative: Parallel Download with aria2**

   For faster downloads, especially with large snapshots, you can use `aria2c` which supports parallel connections:

   ```bash theme={"dark"}
   # Download with 16 parallel connections
   aria2c -x 16 -s 16 -o snapshot.tar.lz4 $SNAPSHOT_URL

   # Extract after download completes
   lz4 -c -d snapshot.tar.lz4 | tar -x -C $HOME/.sei

   # Clean up the downloaded file
   rm snapshot.tar.lz4
   ```

   You can also use `pv` to monitor extraction progress:

   ```bash theme={"dark"}
   pv snapshot.tar.lz4 | lz4 -c -d | tar -x -C $HOME/.sei
   ```

   <Info>The `-x 16` flag sets the maximum connections per server, and `-s 16` splits the file into 16 segments for parallel downloading. You can adjust these values based on your network conditions.</Info>

   <Warning>**Variation Warning**: Some providers might wrap the data in a folder or use different compression. - If the snapshot is a `.tar.gz`, use `tar -xzf`. - If the snapshot contains a root folder (e.g. `sei/data`), you might need to adjust the `-C` target or use `--strip-components`. - Always check the provider's specific page for exact commands.</Warning>

3. **Restore Validator State**

   ```bash theme={"dark"}
   cp $HOME/priv_validator_state.json $HOME/.sei/data/priv_validator_state.json
   ```

4. **Enable SeiDB**
   Make sure to enable `sei-db` in your config if it's not already enabled:

   ```bash theme={"dark"}
   sed -i.bak -E "/^\[state-commit\]/,/^\[.*\]/ s|^(sc-enable[[:space:]]*=[[:space:]]*).*$|\1true| ; /^\[state-store\]/,/^\[.*\]/ s|^(ss-enable[[:space:]]*=[[:space:]]*).*$|\1true|" $HOME/.sei/config/app.toml
   ```

5. **Restart the Node**

   ```bash theme={"dark"}
   sudo systemctl start seid
   ```

6. **Monitor Logs**
   ```bash theme={"dark"}
   sudo journalctl -fu seid
   ```

## Troubleshooting

**Q: I can't download a snapshot.**
A: Try another time later as these snapshots are refreshed regularly and inform us in the [Sei Tech Chat](https://t.me/+KZdhZ1eE-G01NmZk).

**Q: The snapshot finishes, but I immediately get `AppHash` errors upon regular block syncing.**
A: Make sure that you use the latest version of the node software. This usually means the snapshot version doesn't match your node version, or the snapshot is corrupted. Ensure you are using the correct binary version for the block height of the snapshot.

**Q: "No space left on device"**
A: Snapshots require significant disk space to download and extract. Ensure you have enough free space (check with `df -h`).

---

URL: https://docs.sei.io/node/node-types

# Node Types

> Learn about different types of Sei nodes, their purposes, commonly used ports, and systemd configuration.

There are a few node types that can be run on Sei network which serve a variety of purposes. These include:

* RPC / full nodes: these nodes are generally used for querying data or interacting with the chain. They maintain some state but not since genesis. The default settings will run RPC / full nodes.

* Archive / full Nodes: maintain full state of the blockchain from genesis. Generally requires large disks (10 TB+ minimum). To enable this type of node, set `min-retain-blocks=0` and `pruning="nothing"` in your `app.toml`.

* State Sync Nodes: provide snapshot data for other nodes to use to bootstrap onto the chain. To enable this type of node, set `enable=true` under the `[statesync]` section in config.toml.

* Validator Nodes provide security to the chain by proposing and signing blocks. To enable this type of node, set `mode=validator` in `config.toml`. Note that because Sei is proof-of-stake, you must have enough delegation to join the active set.

## Commonly Used Ports

Seid uses the following TCP ports. Toggle their settings to match your environment.

* `26656`: The default port for the P2P communication. This port is used to communicate with other nodes and must be open to join a network.
* `26657`: The default port for the RPC interface. Because this port is used for querying and sending transactions, it must be open for serving queries from `seid`.
* `1317`: The default port for interacting with the Seid API server for HTTP RESTful requests. This allows applications and services to interact with the `seid` instance through RPC.
* `9090`: The default port for gRPC communication. This is used for high-performance communication with the node.
* `8545`: The default port for EVM HTTP RPC. This port is used for Ethereum JSON-RPC calls and must be open if you want to interact with EVM-compatible applications.
* `8546`: The default port for EVM WebSocket RPC. This port provides real-time communication for EVM applications that require WebSocket connections.
* `26660`: The default port for interacting with the Prometheus database, which can be used to monitor the environment. In the default configuration, this port is not open.

These ports are all customizable in `$HOME/.sei/config/config.toml` and `$HOME/.sei/config/app.toml`.

## Systemd File Template

```toml theme={"dark"}
[Unit]
Description=Sei Node
After=network.target

[Service]
User=<USER>
Type=simple
ExecStart=<PATH_TO_SEID>/seid start --chain-id <Network>
Restart=always

# wait 30 seconds before restarting the service after it has failed.

RestartSec=30

# wait up to 30 seconds for the service to stop gracefully when it is being stopped.

TimeoutStopSec=30

# send the SIGINT signal (equivalent to pressing Ctrl-C) to the service process when it is being stopped

# giving it a chance to shut down gracefully.

KillSignal=SIGINT
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
```

---

URL: https://docs.sei.io/node/troubleshooting

# Troubleshooting

> Detailed guide for troubleshooting node problems.

export const RandomPeers = ({format = 'bash', network = 'mainnet', count = 5}) => {
  const PEERS = {
    mainnet: ['d53ab7681ed0df3d3249fc0132df7c3a131c9c1a@45.250.253.40:51656', '4ee8aea5bb58e9038d72e74322e3bba755287398@202.8.8.183:11956', '81409623ae4da3ec7b400cf640dea0b0999a964b@57.128.230.96:51556', '61a5be64b5215786fe5da712584678d0626636b5@87.249.137.71:51556', 'f83c536f43df9a5d900cd3c2f702c04d7dddc7b5@136.243.67.45:11956', 'b8d600a2f568576b5a2df5ee649cf9b809389064@162.19.62.176:26756', '57860b18ed3e1bbe8901ba73f2e63c7e6fe8b3d3@57.129.54.81:26656', '04fc6bba6c5c33034811612dca31c7adda24b299@91.134.60.37:16856', 'de64b779c7f4091e6f1765f5ca4c46f9d3011732@65.108.70.106:46656', '3be6b24cf86a5938cce7d48f44fb6598465a9924@p2p.state-sync.pacific-1.seinetwork.io:26656', '70e0c91b83b5ed1beaca798267f2debdf97dac10@18.156.6.83:26656', 'dd6b1ae002a15c1c8a38e05660f49a93c75d4159@148.251.181.225:26656'],
    testnet: ['71beea83970431f55816eee5f066a611a1dc80f7@p2p.state-sync.atlantic-2.seinetwork.io:26656', '65c257f9275beb1b99ca169ef89743c034b15db0@3.76.192.224:26656', '33588592e477c5238ff2a5d8dc765f85790ef853@23.109.47.225:26656', 'babc3f3f7804933265ec9c40ad94f4da8e9e0017@testnet-seed.rhinostake.com:11956', '8542cd7e6bf9d260fef543bc49e59be5a3fa9074@seed.publicnode.com:56656']
  };
  const pickRandom = (arr, n) => {
    const shuffled = [...arr];
    for (let i = shuffled.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
    }
    return shuffled.slice(0, Math.min(n, arr.length));
  };
  const CopyIcon = ({className}) => <svg role="img" aria-label="Copy" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
      <path d="M7 7m0 2.667a2.667 2.667 0 0 1 2.667 -2.667h8.666a2.667 2.667 0 0 1 2.667 2.667v8.666a2.667 2.667 0 0 1 -2.667 2.667h-8.666a2.667 2.667 0 0 1 -2.667 -2.667z" />
      <path d="M4.012 16.737a2.005 2.005 0 0 1 -1.012 -1.737v-10c0 -1.1 .9 -2 2 -2h10c.75 0 1.158 .385 1.5 1" />
    </svg>;
  const CheckIcon = ({className}) => <svg role="img" aria-label="Copied" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
      <path d="M5 12l5 5l10 -10" />
    </svg>;
  const ShuffleIcon = ({className}) => <svg role="img" aria-label="Shuffle" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
      <path d="M16 3h5v5" />
      <path d="M4 20l16.2 -16.2" />
      <path d="M21 16v5h-5" />
      <path d="M15 15l6 6" />
      <path d="M4 4l5 5" />
    </svg>;
  const pool = PEERS[network] ?? [];
  const [peers, setPeers] = useState(() => pool.slice(0, count));
  const [copied, setCopied] = useState(false);
  const shuffle = () => {
    setPeers(pickRandom(pool, count));
  };
  useEffect(() => {
    shuffle();
  }, [network, count]);
  if (pool.length === 0) {
    return <div className="not-prose w-full">
        <pre className="m-0 p-3 rounded-md bg-neutral-100 dark:bg-neutral-800 text-sm opacity-70" style={{
      fontFamily: 'var(--sei-font-mono)'
    }}>
          No peers configured for network “{network}”.
        </pre>
      </div>;
  }
  const peerString = peers.join(',');
  const displayText = format === 'toml' ? `persistent_peers = "${peerString}"` : `PEERS="${peerString}"`;
  const handleCopy = async () => {
    try {
      await navigator.clipboard.writeText(displayText);
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    } catch {}
  };
  return <div className="not-prose w-full">
      <div className="relative">
        <pre className="m-0 px-4 py-3 pr-28 rounded-lg bg-neutral-100 dark:bg-neutral-900 text-[12.5px] leading-[1.55] whitespace-pre-wrap break-all border border-neutral-200 dark:border-neutral-700 text-neutral-900 dark:text-neutral-100" style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>
          <code style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>{displayText}</code>
        </pre>
        <div className="absolute top-2 right-2 flex items-center gap-1.5">
          <button type="button" onClick={shuffle} aria-label="Shuffle peers" title="Shuffle" className="inline-flex items-center gap-1 px-2 py-1 rounded-md text-[11px] font-semibold border border-neutral-300 dark:border-neutral-600 bg-white/80 dark:bg-neutral-800/80 text-neutral-700 dark:text-neutral-200 hover:bg-white dark:hover:bg-neutral-800 transition-colors">
            <ShuffleIcon />
            Shuffle
          </button>
          <button type="button" onClick={handleCopy} aria-label="Copy peers" title="Copy to clipboard" className="inline-flex items-center gap-1 px-2 py-1 rounded-md text-[11px] font-semibold border border-neutral-300 dark:border-neutral-600 bg-white/80 dark:bg-neutral-800/80 text-neutral-700 dark:text-neutral-200 hover:bg-white dark:hover:bg-neutral-800 transition-colors">
            {copied ? <>
                <CheckIcon className="text-green-600" />
                Copied
              </> : <>
                <CopyIcon />
                Copy
              </>}
          </button>
        </div>
      </div>
    </div>;
};

Understanding common errors and their solutions helps maintain a healthy node
operation.

## Common Error Codes

Here are the most frequent errors you might encounter and their solutions:

### Consensus Errors

When you encounter consensus errors, quick and appropriate action is essential:

```text theme={"dark"}
Error: "Consensus failure - height halted"
Solution: Check for network upgrades or chain halts
Command: seid status
```

```text theme={"dark"}
Error: "Private validator file not found"
Solution: Restore validator key or check file permissions
Location: $HOME/.sei/config/priv_validator_key.json
```

```text theme={"dark"}
Error: "Duplicate signature"
Solution: IMMEDIATELY STOP NODE - potential double signing risk
Action: Check validator operation on other machines
```

### Network Errors

Network errors can prevent your node from participating in consensus:

```text theme={"dark"}
Error: "Dial tcp connection refused"
Solution: Check network connectivity and firewall rules
Commands:
  - netstat -tulpn | grep seid
  - ufw status
```

```text theme={"dark"}
Error: "No peers available"
Solution: Verify peer connections and network config
Commands:

- curl localhost:26657/net_info
```

### Database Errors

Database corruption can require immediate attention:

```text theme={"dark"}
Error: "Database is corrupted"
Solution: Reset database or restore from backup
Commands:
  - seid tendermint unsafe-reset-all
  - cp -r backup/data $HOME/.sei/
```

### Diagnostic Commands

These commands help you investigate issues and monitor your node:

```bash theme={"dark"}
# Check node synchronization
seid status

# Check validator status
seid query staking validator $(seid tendermint show-validator)

# Monitor real-time logs
journalctl -fu seid -o cat

# View system resource usage
top -p $(pgrep seid)
```

## AppHash Mismatch Errors

If you encounter an AppHash mismatch, you'll need to capture the state for comparison with a known good version:

```bash theme={"dark"}
# For SeiDB (most non-archive nodes):
git clone https://github.com/sei-protocol/sei-db.git
cd sei-db/tools
make install
systemctl stop seid
seidb dump-iavl -d $HOME/.sei/data/committer.db -o /home/ubuntu/iavl-dump
systemctl restart seid

# For Legacy IAVL DB:
seid debug dump-iavl <latest height>
```

Always include the app hash, commit hash, and block height from your logs when reporting issues.

### Identifying AppHash Errors

AppHash errors typically appear in logs as:

```text theme={"dark"}
ERR wrong Block.Header.AppHash. Expected [EXPECTED_HASH], got [ACTUAL_HASH]
block_id={"hash":"...","parts":{"hash":"...","total":1}} height=[HEIGHT]
```

**Common Causes:**

* Using incorrect node version during sync (ensure you're on the latest version)
* Corrupted or incorrectly applied snapshots
* Database inconsistencies from improper shutdowns
* Syncing with outdated or incompatible peers

**Resolution Steps:**

1. **Stop the node immediately.**

2. **Try a node rollback first:**, see [here](/node/troubleshooting#node-rollback)

3. **If rollback fails, restore from a fresh snapshot:**

   * Download a recent snapshot from trusted providers (Polkachu, PublicNode)
   * Ensure you're using the correct node version
   * Verify peer configurations are up to date

4. **Restart the node and monitor logs for continued errors**

### Peer Connection Issues as AppHash Red Herrings

**Important Note:** Peer connection failures are often symptoms of underlying AppHash errors, not the root cause.

When you see extensive peer connection errors like:

```text theme={"dark"}
ERR failed to handshake with peer
ERR failed to send request for peers
ERR peer handshake failed endpoint={} err=EOF
```

**Don't focus solely on fixing peer connections first.** Instead:

1. **Scan your logs carefully** for AppHash errors that may appear intermittently
2. **Look for the actual error pattern:**
   ```text theme={"dark"}
   ERR wrong Block.Header.AppHash. Expected [HASH], got [HASH]
   ```
3. **Check if your node is stuck** at a specific height despite peer connection attempts

**Why This Happens:**

* AppHash mismatches prevent proper block validation
* Node cannot advance to new blocks due to state inconsistency
* Peers may reject connections from nodes with corrupted state
* Network appears to be the problem when it's actually a local state issue

**Debugging Approach:**

1. **First, check for AppHash errors** in your logs (search for "wrong Block.Header.AppHash")
2. **If AppHash errors are found**, treat this as the primary issue
3. **Only focus on peer connection fixes** if no AppHash errors exist

This approach can save hours of debugging time by addressing the root cause rather than symptoms.

### Peer Connection and Handshake Issues

**Identifying Peer Issues:**

Look for these error patterns in your logs:

```text theme={"dark"}
ERR failed to handshake with peer err="expected to connect with peer \"[EXPECTED_ID]\", got \"[ACTUAL_ID]\""
ERR failed to send request for peers err="no available peers to send a PEX request to (retrying)"
ERR peer handshake failed endpoint={} err=EOF module=p2p
```

**Common Causes:**

* Outdated peer configurations with mismatched node IDs
* Network infrastructure changes on peer side
* Firewall blocking connections on port 26656
* DNS resolution issues

**Resolution Steps:**

1. **Update peer configurations** with current node IDs:

   <RandomPeers network="mainnet" format="toml" />

2. **Verify network connectivity:**

   ```bash theme={"dark"}
   # Test connection to peer endpoints
   nc -zv p2p.state-sync-0.pacific-1.seinetwork.io 26656

   # Check if port 26656 is open for inbound connections
   netstat -tulpn | grep :26656
   ```

3. **Check current peer status:**
   ```bash theme={"dark"}
   curl http://localhost:26657/net_info | jq '.result.peers | length'
   curl http://localhost:26657/lag_status | jq .
   ```

### Sync Performance Issues

**Identifying Sync Problems:**

Monitor these indicators:

```bash theme={"dark"}
# Check sync status and lag
curl http://localhost:26657/lag_status | jq .

# Monitor if height is progressing
curl http://localhost:26657/status | jq '.result.sync_info'
```

**Common Solutions:**

1. **Increase packet payload size** for large block processing:

   ```toml theme={"dark"}
   # In config.toml [p2p] section
   max-packet-msg-payload-size = 1024000  # Increase from default 102400
   ```

2. **Optimize mempool settings** in `config.toml`:

   ```toml theme={"dark"}
   # In [mempool] section
   keep-invalid-txs-in-cache = true
   ttl-duration = "5s"
   ttl-num-blocks = 5
   ```

3. **If node gets stuck at specific height:**
   * Try restarting the node
   * If restart doesn't help, perform rollback
   * Consider taking a fresh snapshot

**Warning Signs to Watch For:**

* Current height not increasing over time
* Increasing lag between current height and max peer height
* Repeated timeout errors in logs
* Mempool size consistently reaching limits

## Crash and Panic Debugging

For crashes, panics, or nil pointer exceptions:

* Capture at least 1,000 lines of logs leading up to the crash
* Or collect 15 minutes of log data, whichever provides more context
* Include the full stack trace if available

### Logging Configuration

Proper logging configuration is essential for debugging and monitoring:

```toml theme={"dark"}
# In config.toml
# Set appropriate log level
log_level = "debug"  # Use "trace" for maximum detail

# Choose log format
log_format = "json"  # Use "plain" for human-readable logs
```

Configure log rotation to manage storage effectively:

```bash theme={"dark"}
# Example logrotate configuration
sudo tee /etc/logrotate.d/seid << EOF
/var/log/seid/*.log {
    daily
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 sei sei
    sharedscripts
    postrotate
        systemctl reload seid
    endscript
}
EOF
```

Enable core dumps for crash analysis:

```bash theme={"dark"}
# Set unlimited core dump size
ulimit -c unlimited

# Configure core dump location
echo "/tmp/core.%e.%p" > /proc/sys/kernel/core_pattern
```

## Other common Issues and Fixes

1. **Sync Problems**

   * Check available disk space (`df -h`)
   * Ensure proper peer connections (`curl http://localhost:26657/net_info`)
   * Verify firewall settings (port 26656 open)

2. **Performance Issues**

   * Monitor system resources (`htop` or `iotop`)
   * Check disk I/O performance (`iostat`)
   * Analyze network traffic (`iftop`)

3. **Database Issues**

   * Run database integrity checks using:

     ```bash theme={"dark"}
     seid debug dump-db | grep -i error
     ```

     If errors are detected, consider restoring from a recent backup.

   * Consider pruning excessive historical data by adjusting `ss-keep-recent` in
     `app.toml` or running:

     ```bash theme={"dark"}
     seid tendermint unsafe-reset-all --home $HOME/.sei --keep-addr-book
     ```

     Alternatively, manually remove old state snapshots to free up space:

     ```bash theme={"dark"}
     rm -rf $HOME/.sei/data/snapshots/*
     ```

## Node Rollback

To rollback a node from an AppHashed state, you need to stop the node first.
Do this in your preferred way.

Next, do a rollback with:

```bash theme={"dark"}
seid rollback
```

Then, restart the node.

In case you see the following error while trying to rollback:

```bash theme={"dark"}
failed to initialize database: resource temporarily unavailable
```

This means that you did not shutdown the node properly. Try to shutdown or kill the `seid` process directly in that case. If this doesn't help, restart your machine.

Then try the rollback steps again.

---

URL: https://docs.sei.io/node/swagger

# Swagger API Documentation

> Learn how to enable and access Swagger API documentation for your Sei node. Configure the swagger endpoint in app.toml and view interactive API docs.

## Swagger Docs Endpoint

To enable the Swagger docs endpoint, you need to update api.swagger value to true in the `app.toml` file:

```toml theme={"dark"}

[api]

# Swagger defines if swagger documentation should automatically be registered.

swagger = true
```

Once the node is restarted, the Swagger docs will be available at `http://<node-ip>:<port>/swagger/` (e.g. `http://localhost:1317/swagger/`).

The default API port is `1317`. Ensure the API server is enabled in your `app.toml` under the `[api]` section by setting `enable = true`.

---

URL: https://docs.sei.io/node/validators

# Sei Validator Operations Guide

> Learn how to set up and maintain a validator node on Sei Network, including hardware security configuration, key management, monitoring practices, and governance participation requirements.

This document covers the complete lifecycle of a validator node, from initial setup through ongoing operations and maintenance. Understanding these concepts is crucial for maintaining a reliable and secure validator operation.

## Understanding Validator Responsibilities

A validator in the Sei network serves several critical functions. As a validator, you are responsible for:

* Participating in consensus by proposing and validating blocks
* Maintaining high uptime and performance to avoid slashing
* Managing delegator relationships and maintaining transparent operations
* Participating in governance and network upgrades

## Initial Setup

### Initialize node

Before key management and registration, initialize your node with validator mode so that RPC and P2P bind to localhost (recommended for validator security):

```bash theme={"dark"}
seid init <moniker> --chain-id <chain-id> --mode validator
```

The default init mode is **full**, which binds RPC and P2P to all interfaces (`0.0.0.0`). For validator (and seed) nodes, use `--mode validator` or `--mode seed` so that RPC and P2P listen on localhost only. Genesis is written automatically for known networks; no separate download is required.

### Key Management

The security of your validator begins with proper key management. Your validator requires several distinct keys:

```bash theme={"dark"}
# Validator consensus key - Used for signing blocks
seid tendermint show-validator

# Operator key - Used for managing validator operations
seid keys add operator
```

These keys serve different purposes and should be managed with appropriate security measures. The consensus key, stored in `priv_validator_key.json`, is particularly critical as it's used to sign blocks and could result in slashing if compromised or mishandled.

### Hardware Security Module (HSM) Integration

For production validators, using an HSM is strongly recommended to protect your consensus key. Here's how to configure an HSM with your validator:

<Accordion title="HSM Configuration Steps">
  ```bash theme={"dark"}
  # Install required libraries
  sudo apt-get install opensc pkcs11-utils

  # Configure YubiHSM2
  yubihsm-connector -d

  # Generate key in HSM
  yubihsm-shell

  # Configure seid to use HSM
  tee "$HOME/.sei/config/priv_validator_config.json" << EOF
  {
      "chain_id": "pacific-1",
      "key_type": "yubihsm",
      "state_file": "$HOME/.sei/data/priv_validator_state.json",
      "hsm_serial": "YOUR_HSM_SERIAL",
      "hsm_key_id": "YOUR_KEY_ID"
  }
  EOF
  ```
</Accordion>

### Validator Registration

Before registering your validator, ensure your node is fully synced with the network. The creation of a validator is a crucial step that requires careful consideration of commission parameters.

The examples below use `pacific-1` (mainnet); use `atlantic-2` for testnet.

```bash theme={"dark"}
seid tx staking create-validator \
    --amount=1000000usei \
    --pubkey=$(seid tendermint show-validator) \
    --moniker="choose_moniker" \
    --chain-id=pacific-1 \
    --commission-rate="0.10" \
    --commission-max-rate="0.20" \
    --commission-max-change-rate="0.01" \
    --min-self-delegation="1" \
    --gas="auto" \
    --gas-adjustment="1.5" \
    --gas-prices="0.02usei" \
    --from=operator
```

The commission parameters require strategic consideration:

* `commission-rate`: Your initial commission rate, which should be competitive while ensuring operational sustainability
* `commission-max-rate`: An upper limit that can never be exceeded, setting a permanent cap on your commission
* `commission-max-change-rate`: Maximum daily commission change, limiting how quickly you can adjust rates

## Monitoring and Alerting

**Please refer to the [Advanced Operations](/node/advanced-config-monitoring) section for details around monitoring + alerting for your validator, price feeder and other nodes.**

## Security Practices

### Network Security

Validators may choose to implement a sentry node architecture to protect the block signing node (the validator). This setup helps prevent DDoS attacks on your validator node by creating a layer of defensive proxies:

```bash theme={"dark"}
# Validator node config.toml
[p2p]
pex = false
persistent_peers = "sentry_node_id@sentry_node_ip:26656"
private_peer_ids = ""
addr_book_strict = false

# Sentry node config.toml
[p2p]
pex = true
persistent_peers = "validator_node_id@ip:port"
private_peer_ids = "validator_node_id"
addr_book_strict = true
#optional
unconditional_peer_ids = "validator_node_id"
```

### Key Management Practices

Implement secure key backup procedures. Remember to choose the storage media carefully! Mechanical / flash based storage can fail unexpectedly, and cloud storage should **never** be used.

By default, the wallet key files are stored in your `/.sei` directory root, and the signer/consensus key in `/.sei/config`. Not only the `priv_validator_key.json`, but the wallet `.info` and `.address` file should also be saved.

Example script to encrypt backups of key files:

<Accordion title="Key Backup Script">
  ```bash theme={"dark"}
  #!/bin/bash
  # Create encrypted backup of validator keys
  BACKUP_DIR="/secure/validator/backup"
  DATE=$(date +%Y%m%d)

  # Backup validator key
  tar czf - $HOME/.sei/config/priv_validator_key.json | \
      gpg --symmetric --cipher-algo AES256 \
      -o $BACKUP_DIR/validator_key_$DATE.tar.gz.gpg

  # Backup keyring
  tar czf - $HOME/.sei/keyring-file | \
      gpg --symmetric --cipher-algo AES256 \
      -o $BACKUP_DIR/keyring_$DATE.tar.gz.gpg

  # Create SHA256 checksums
  sha256sum $BACKUP_DIR/*.gpg > $BACKUP_DIR/checksums_$DATE.txt
  ```
</Accordion>

## Maintenance Procedures

### Planned Maintenance

When performing planned maintenance, to minimize potential impact:

* Notify delegators (recommended at least 24h in advance)

Consider posting to:

* Shared development team/validators comms channels
* Social media channels
* Validator website

Don't forget to stop the service!

```bash theme={"dark"}
# Gracefully stop the node
sudo systemctl stop seid

# Perform maintenance tasks

# Restart services
sudo systemctl start seid
```

### Emergency Procedures

Create and maintain an emergency response plan for various scenarios:

#### Consult with your fellow validators or a member of the Sei Labs or Foundation team directly for advice

## Governance Participation

As a validator, active participation in governance is required. Governance is the primary tool with which adjustments to various chain parameters are made.
Another critical role for validators is to review, and ultimately approve or reject proposed software upgrades to the network.

Governance proposals may be submitted by anyone willing to provide the mandatory (refundable) deposit, and can be voted on by any network user. Only votes by accounts delegating \$SEI at the end of the voting period for a given proposal will be given weight.

Proposals currently on chain can be queried at any given time:

```bash theme={"dark"}
# List active proposals
seid query gov proposals --status voting_period

# Vote on a proposal
seid tx gov vote 1 yes \
    --from operator \
    --chain-id pacific-1 \
    --gas auto \
    --gas-prices 0.02usei
```

## Recovery Procedures

### Critical Warning: Double-Signing Prevention

<Danger>Double-signing is a severe violation that results in permanent validator tombstoning (irreversible jailing).</Danger>

Never run your validator keys on more than one machine simultaneously. If your primary validator goes offline:

1. DO NOT start another validator with the same keys
2. Either recover the original machine or properly migrate keys with absolute certainty the original is offline
3. If unsure about the state of your original validator, seek support before proceeding

The safe approach to recovery is:

1. Diagnose why the original validator is offline
2. If the original validator cannot be recovered, verify it is offline and powered down
3. Only then proceed with key migration to a new machine

### Validator Recovery

When you need to recover your validator on a new machine, follow these steps carefully:

```bash theme={"dark"}
# 1. Set up new machine with Sei node
# 2. Copy secured backup files
# 3. Restore validator key
gpg -d validator_key_backup.tar.gz.gpg | tar xzf -
# 4. Restore keyring
gpg -d keyring_backup.tar.gz.gpg | tar xzf -
# 5. Start services
sudo systemctl start seid
```

After recovery, verify your validator's status and performance:

```bash theme={"dark"}
# Check validator status
seid status
# Verify signing is working
seid query slashing signing-info $(seid tendermint show-validator)
```

This guide provides a foundation for operating a Sei validator. Remember that validator operation requires constant attention to security, performance, and network participation. Stay engaged with the Sei community and keep updated with network developments.

---

URL: https://docs.sei.io/node/advanced-config-monitoring

# Sei Node Advanced Configuration & Monitoring

> Optimize your Sei node's performance with advanced system configurations, monitoring setup with Prometheus and Grafana, and effective alerting strategies for maintaining reliable node operations.

## Optimizing System Configuration

There are a virtually unlimited number of unique individual setups that cannot be covered in this document. As well, even similar builds and configurations can behave differently due to external factors, so your results may vary.

Here are some general guidelines to use as a starting point. Be cautious, make incremental changes, testing and observing before moving forward.
Always focus on only one specific area at a time - avoid making changes to memory, storage, and CPU configs all at once. Diagnosing potential problems becomes nearly impossible otherwise.

### Memory Management

The following settings in `/etc/sysctl.conf` can optimize memory usage and disk I/O patterns:

```bash theme={"dark"}
# Minimize swapping
vm.swappiness = 1

# Control disk write behavior
vm.dirty_background_ratio = 3
vm.dirty_ratio = 10
vm.dirty_expire_centisecs = 300
vm.dirty_writeback_centisecs = 100
```

Apply changes: `sudo sysctl -p`

### Network Stack

The following settings in `/etc/sysctl.conf` may improve network performance:

```bash theme={"dark"}
# Increase connection handling capacity
net.core.somaxconn = 32768
net.core.netdev_max_backlog = 32768
net.ipv4.tcp_max_syn_backlog = 16384

# Optimize buffer sizes
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 87380 16777216
```

### Storage Configuration

For NVMe drives, optimize I/O scheduling:

Storage Optimization Commands

```bash theme={"dark"}
# Set IO scheduler
echo "none" > /sys/block/nvme0n1/queue/scheduler

# Set read-ahead buffer
blockdev --setra 4096 /dev/nvme0n1

# Set IO priority in systemd service
sudo tee -a /etc/systemd/system/seid.service << EOF
[Service]
IOSchedulingClass=realtime
IOSchedulingPriority=2
EOF

# Configure disk mount options
sudo tee -a /etc/fstab << EOF
/dev/nvme0n1p1 /data ext4 defaults,noatime,nosuid,nodev,noexec,commit=60 0 0
EOF
```

## Infrastructure Monitoring

Monitoring is one of the most critical components of network infrastructure. performance tuning, and alerting configuration for Cosmos-SDK/Tendermint nodes.

### Prometheus Setup

First, install Prometheus:

```bash theme={"dark"}
wget https://github.com/prometheus/prometheus/releases/download/v2.42.0/prometheus-2.42.0.linux-amd64.tar.gz
tar xvf prometheus-2.42.0.linux-amd64.tar.gz
```

Example Prometheus configuration:

```yaml theme={"dark"}
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'sei_node'
    static_configs:
      - targets: ['node1_ip:port']
    metrics_path: /metrics
  - job_name: 'node'
    static_configs:
      - targets: ['node2_ip:port']
```

### Grafana Integration

Install and configure Grafana:

```bash theme={"dark"}
sudo apt install -y apt-transport-https software-properties-common
sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"
sudo apt update && sudo apt-get install grafana
```

<Accordion title="Sample Grafana Dashboard JSON">
  ```json theme={"dark"}
  {
  	"annotations": {
  		"list": [
  			{
  				"builtIn": 1,
  				"datasource": "-- Grafana --",
  				"enable": true,
  				"hide": true,
  				"iconColor": "rgba(0, 211, 255, 1)",
  				"name": "Annotations & Alerts",
  				"type": "dashboard"
  			}
  		]
  	},
  	"editable": true,
  	"gnetId": null,
  	"graphTooltip": 0,
  	"id": 1,
  	"links": [],
  	"panels": [
  		{
  			"alerting": {},
  			"aliasColors": {},
  			"bars": false,
  			"dashLength": 10,
  			"dashes": false,
  			"datasource": null,
  			"fieldConfig": {
  				"defaults": {
  					"custom": {}
  				},
  				"overrides": []
  			},
  			"fill": 1,
  			"fillGradient": 0,
  			"gridPos": {
  				"h": 8,
  				"w": 12,
  				"x": 0,
  				"y": 0
  			},
  			"hiddenSeries": false,
  			"id": 2,
  			"legend": {
  				"avg": false,
  				"current": false,
  				"max": false,
  				"min": false,
  				"show": true,
  				"total": false,
  				"values": false
  			},
  			"lines": true,
  			"linewidth": 1,
  			"nullPointMode": "null",
  			"options": {
  				"alertThreshold": true
  			},
  			"percentage": false,
  			"pluginVersion": "7.2.0",
  			"pointradius": 2,
  			"points": false,
  			"renderer": "flot",
  			"seriesOverrides": [],
  			"spaceLength": 10,
  			"stack": false,
  			"steppedLine": false,
  			"targets": [
  				{
  					"expr": "tendermint_consensus_height",
  					"interval": "",
  					"legendFormat": "",
  					"refId": "A"
  				}
  			],
  			"thresholds": [],
  			"timeRegions": [],
  			"title": "Block Height",
  			"tooltip": {
  				"shared": true,
  				"sort": 0,
  				"value_type": "individual"
  			},
  			"type": "graph",
  			"xaxis": {
  				"buckets": null,
  				"mode": "time",
  				"name": null,
  				"show": true,
  				"values": []
  			},
  			"yaxes": [
  				{
  					"format": "short",
  					"label": null,
  					"logBase": 1,
  					"max": null,
  					"min": null,
  					"show": true
  				},
  				{
  					"format": "short",
  					"label": null,
  					"logBase": 1,
  					"max": null,
  					"min": null,
  					"show": true
  				}
  			],
  			"yaxis": {
  				"align": false,
  				"alignLevel": null
  			}
  		}
  	],
  	"schemaVersion": 26,
  	"style": "dark",
  	"tags": [],
  	"templating": {
  		"list": []
  	},
  	"time": {
  		"from": "now-6h",
  		"to": "now"
  	},
  	"timepicker": {},
  	"timezone": "",
  	"title": "Sei Node Metrics",
  	"uid": "sei_metrics",
  	"version": 1
  }
  ```
</Accordion>

### Alert Management

Install Alertmanager:

```bash theme={"dark"}
wget https://github.com/prometheus/alertmanager/releases/download/v0.25.0/alertmanager-0.25.0.linux-amd64.tar.gz
tar xvf alertmanager-0.25.0.linux-amd64.tar.gz
```

<Accordion title="Create Alert Rules Configuration">
  ```yaml theme={"dark"}
  groups:
    - name: validator_alerts
      rules:
        - alert: NodeDown
          expr: up == 0
          for: 5m
          labels:
            severity: critical
          annotations:
            summary: 'Node {{ $labels.instance }} down'

        - alert: BlockProductionSlow
          expr: rate(tendermint_consensus_height[5m]) < 0.1
          for: 5m
          labels:
            severity: warning
          annotations:
            summary: 'Block production is slow on {{ $labels.instance }}'
        - alert: ValidatorMissedBlocks
          expr: increase(tendermint_consensus_validator_missed_blocks[1h]) > 0
          labels:
            severity: critical
          annotations:
            summary: 'Validator missing blocks'

        - alert: ValidatorJailed
          expr: tendermint_consensus_validator_status == 0
          labels:
            severity: critical
          annotations:
            summary: 'Validator has been jailed'

        - alert: ConsensusStalled
          expr: tendermint_consensus_height_status == 0
          for: 5m
          labels:
            severity: critical
          annotations:
            summary: 'Consensus has stalled'
  ```
</Accordion>

## Log Management

### Loki Setup

Using Loki for log aggregation:

```bash theme={"dark"}
wget https://github.com/grafana/loki/releases/download/v2.8.0/loki-linux-amd64.zip
unzip loki-linux-amd64.zip
```

<Accordion title="Promtail Configuration">
  ```yaml theme={"dark"}
  server:
    http_listen_port: 9080

  positions:
    filename: /tmp/positions.yaml

  clients:
    - url: http://localhost:3100/loki/api/v1/push

  scrape_configs:
    - job_name: sei_logs
      static_configs:
        - targets:
            - localhost
          labels:
            job: seid_logs
            __path__: /var/log/seid/*.log
  ```
</Accordion>

### Log Rotation

Configure logrotate to manage log files:

```bash theme={"dark"}
sudo tee /etc/logrotate.d/sei << EOF
/var/log/sei/*.log {
    daily
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 sei sei
    sharedscripts
    postrotate
        systemctl reload seid
    endscript
}
EOF
```

## Security Configuration

### Network Security

UFW firewall configuration:

```bash theme={"dark"}
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 26656/tcp comment 'Sei P2P'
sudo ufw allow 26657/tcp comment 'Sei RPC'
sudo ufw allow 9090/tcp comment 'Sei gRPC'
sudo ufw enable
```

### Rate Limiting

<Accordion title="Example Nginx Configuration with Rate Limiting">
  ```nginx theme={"dark"}
  http {
      limit_req_zone $binary_remote_addr zone=sei_rpc:10m rate=10r/s;

      server {
          listen 26657;
          location / {
              limit_req zone=sei_rpc burst=20 nodelay;
              proxy_pass http://localhost:26657;
          }
      }
  }
  ```
</Accordion>

## Validator-Specific Monitoring

### Status Query

Query validator status through SDK:

```bash theme={"dark"}
seid query staking validator $(seid keys show --bech val -a <validator_keyfile_name>)
```

Query through REST API:

```sh theme={"dark"}
curl -s "http://localhost:1317/cosmos/staking/v1beta1/validators/<valoper_address>"
```

<Accordion title="Validator &#x22;Status&#x22; Query Script">
  ```sh theme={"dark"}
  #!/bin/bash

  MONIKER="$1"
  API_URL="http://localhost:1317/cosmos/staking/v1beta1/validators?pagination.limit=500"

  echo "Querying validators from $API_URL..."

  VALIDATOR_DATA=$(curl -s "$API_URL" | jq -c --arg MONIKER "$MONIKER" '.validators[] | select(.description.moniker == $MONIKER)')

  if [[ -z "$VALIDATOR_DATA" ]]; then
      echo "❌ No validator found with moniker: $MONIKER"
      exit 1
  fi

  echo "Validator details:"
  echo "$VALIDATOR_DATA" | jq '.'
  ```
</Accordion>

### Critical Metrics

Monitor these validator-specific metrics:

```bash theme={"dark"}
# Check signing status
seid query slashing signing-info $(seid tendermint show-validator)

# Check current delegations
seid query staking delegations-to $(seid keys show -a $VALIDATOR_KEY)
```

## Backup Management

<Accordion title="Complete Automated Backup Script">
  ```bash theme={"dark"}
  #!/bin/bash
  BACKUP_DIR="/backup/sei"
  DATE=$(date +%Y%m%d)
  NODE_HOME="/root/.sei"

  # Create backup directory
  mkdir -p $BACKUP_DIR

  # Stop service
  systemctl stop seid

  # Backup configuration
  tar czf $BACKUP_DIR/sei-config-$DATE.tar.gz $NODE_HOME/config

  # Backup data directory
  tar czf $BACKUP_DIR/sei-data-$DATE.tar.gz $NODE_HOME/data

  # Backup key files
  tar czf $BACKUP_DIR/sei-keys-$DATE.tar.gz $NODE_HOME/keyring-file

  # Start service
  systemctl start seid

  # Remove backups older than 7 days
  find $BACKUP_DIR -type f -mtime +7 -name '*.tar.gz' -delete

  # Log backup completion
  echo "Backup completed successfully on $(date)" >> $BACKUP_DIR/backup.log
  ```
</Accordion>

## Host System Monitoring

### Resource Usage Tracking

Install and configure node\_exporter:

```bash theme={"dark"}
wget https://github.com/prometheus/node_exporter/releases/download/v1.5.0/node_exporter-1.5.0.linux-amd64.tar.gz
tar xvf node_exporter-1.5.0.linux-amd64.tar.gz
```

Add to Prometheus configuration:

```yaml theme={"dark"}
scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets: ['localhost:9100']
```

## Performance Testing

<Accordion title="Example Benchmark Script using `eth_getLogs`">
  ```js theme={"dark"}
  import { ethers } from 'ethers';

  // Configuration
  const EVM_RPC_URL = 'http://localhost:8545'; // EVM RPC endpoint to test
  const CONTRACT_ADDRESS = '0x0000000000000000000000000000000000001002'; // replace with very active contract for best results
  const INITIAL_BLOCK_RANGE = 50; // range of blocks to query using 'eth_getLogs'
  const RANGE_INCREMENT = 10; // additional blocks to query each consecutive round
  const MAX_TESTS = 50; // total number of rounds for testing

  // Store metrics for final analysis
  const metrics = [];

  function getResponseSize(logs) {
    return Buffer.byteLength(JSON.stringify(logs), 'utf8');
  }

  function formatBytes(bytes) {
    if (bytes === 0) return '0 B';
    const k = 1024;
    const sizes = ['B', 'KB', 'MB', 'GB'];
    const i = Math.floor(Math.log(bytes) / Math.log(k));
    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
  }

  function padString(str, length) {
    return String(str).padEnd(length);
  }

  function analyzeResults(metrics) {
    console.log('\nPerformance Analysis');
    console.log('='.repeat(50));

    // Filter out queries with no logs for meaningful statistics
    const queriesWithLogs = metrics.filter((m) => m.logsCount > 0);
    const totalQueries = metrics.length;

    console.log(`\nGeneral Statistics:`);
    console.log(`Total Queries Run: ${totalQueries}`);
    console.log(`Queries with Logs: ${queriesWithLogs.length}`);
    console.log(`Empty Responses: ${totalQueries - queriesWithLogs.length}`);

    if (queriesWithLogs.length > 0) {
      const avgResponseTime = queriesWithLogs.reduce((acc, m) => acc + m.responseTime, 0) / queriesWithLogs.length;
      const avgLogsPerQuery = queriesWithLogs.reduce((acc, m) => acc + m.logsCount, 0) / queriesWithLogs.length;
      const maxLogs = Math.max(...queriesWithLogs.map((m) => m.logsCount));
      const maxLogsQuery = queriesWithLogs.find((m) => m.logsCount === maxLogs);

      console.log(`\nPerformance Metrics:`);
      console.log(`Average Response Time (with logs): ${avgResponseTime.toFixed(2)}ms`);
      console.log(`Average Logs per Query: ${avgLogsPerQuery.toFixed(2)}`);
      console.log(`Maximum Logs in Single Query: ${maxLogs}`);
      if (maxLogsQuery) {
        console.log(`- At Range Size: ${maxLogsQuery.rangeSize} blocks`);
        console.log(`- Response Time: ${maxLogsQuery.responseTime}ms`);
        console.log(`- Efficiency: ${maxLogsQuery.logsPerMs.toFixed(3)} logs/ms`);
      }

      // Identify optimal range size based on logs/ms
      const bestEfficiency = queriesWithLogs.reduce((best, m) => (m.logsPerMs > best.logsPerMs ? m : best));
      console.log(`\nOptimal Performance:`);
      console.log(`Best Efficiency: ${bestEfficiency.logsPerMs.toFixed(3)} logs/ms`);
      console.log(`- At Range Size: ${bestEfficiency.rangeSize} blocks`);
      console.log(`- Retrieved ${bestEfficiency.logsCount} logs in ${bestEfficiency.responseTime}ms`);
    }
  }

  async function testEthGetLogs() {
    const provider = new ethers.JsonRpcProvider(EVM_RPC_URL);

    try {
      const latestBlock = await provider.getBlockNumber();
      console.log(`Latest block: ${latestBlock} (0x${latestBlock.toString(16)})`);

      let currentToBlock = latestBlock;
      let currentRange = INITIAL_BLOCK_RANGE;
      let testCount = 0;

      // Column headers with fixed widths
      console.log('\nBlock Range         Time  Logs    Size     B/ms   Logs/ms  KB/Log  Range');
      console.log('='.repeat(80));

      while (testCount < MAX_TESTS && currentToBlock > 0) {
        const fromBlock = Math.max(0, currentToBlock - currentRange);

        try {
          const startTime = Date.now();
          const filter = {
            fromBlock: fromBlock,
            toBlock: currentToBlock,
            address: CONTRACT_ADDRESS
          };

          const logs = await provider.getLogs(filter);

          const endTime = Date.now();
          const responseTime = endTime - startTime;
          const logsCount = logs.length;
          const responseSize = getResponseSize(logs);

          // Calculate metrics
          const bytesPerMs = (responseSize / responseTime).toFixed(1);
          const logsPerMs = (logsCount / responseTime).toFixed(3);
          const kbPerLog = logsCount > 0 ? (responseSize / 1024 / logsCount).toFixed(2) : 'N/A';

          // Store metrics for analysis
          metrics.push({
            rangeSize: currentRange,
            responseTime,
            logsCount,
            responseSize,
            bytesPerMs: parseFloat(bytesPerMs),
            logsPerMs: parseFloat(logsPerMs),
            kbPerLog: kbPerLog !== 'N/A' ? parseFloat(kbPerLog) : 0
          });

          // Format block range
          const rangeDisplay = `${fromBlock.toString(16)}-${currentToBlock.toString(16)}`;

          // Log with fixed column widths
          console.log(padString(rangeDisplay, 17) + padString(responseTime, 6) + padString(logsCount, 8) + padString(formatBytes(responseSize), 9) + padString(bytesPerMs, 8) + padString(logsPerMs, 9) + padString(kbPerLog, 8) + currentRange);

          if (logsCount === 10000) {
            console.log(`\nWarning: Hit 10000 log limit at range ${currentRange}`);
          }

          currentToBlock = fromBlock - 1;
          currentRange += RANGE_INCREMENT;
          testCount++;
        } catch (error) {
          console.log(`Error at range ${currentRange}: ${error.message}`);
          currentRange = Math.max(INITIAL_BLOCK_RANGE, currentRange - RANGE_INCREMENT);
          currentToBlock = fromBlock - 1;
          testCount++;
        }

        await new Promise((resolve) => setTimeout(resolve, 1000));
      }

      // Perform final analysis
      analyzeResults(metrics);
    } catch (error) {
      console.error('Failed to initialize or get latest block:', error);
      process.exit(1);
    }
  }

  // Run the test
  testEthGetLogs();
  ```
</Accordion>

For specific customizations or additional metrics, consult the Sei
technical communities in [Telegram](https://t.me/+ZN-NcvOWStQwMzk0) or
[Discord](https://discord.gg/sei).

---

URL: https://docs.sei.io/node/rocksdb-backend

# RocksDB Backend Setup & Performance

> Build and enable the RocksDB backend for seid to significantly improve iteration-heavy operations and traceBlock latency, especially on long-history RPC and archive nodes.

## Overview

As Sei nodes accumulate more history and state data, iteration-heavy operations—like those performed during `traceBlock` calls—can become significantly slower. This is especially true for archive or RPC nodes where the state store contains millions of versions.

To address this, Sei supports **RocksDB** as an alternative backend to PebbleDB. RocksDB provides native **multi-version concurrency control (MVCC)** and **column family support**, which leads to substantial iteration performance improvements as history grows.

## Why RocksDB?

PebbleDB lacks native MVCC support, meaning Sei must manually encode versions into keys. This retrofit approach causes iteration time to grow linearly with the amount of stored history. As a result:

* Archive nodes with large state stores experience **slower debug trace latency**.
* Each key lookup may require scanning multiple key versions.
* Iterations (e.g., over Oracle or EVM module keys) become increasingly expensive over time.

By contrast, **RocksDB** supports native user-defined timestamps and optimized column families for versioned data access. This means:

* Iterations over keys at a single version are **much faster**.
* Historical data growth has **minimal effect on iteration cost**.
* The performance advantage **amplifies with larger node history**.

In Sei’s benchmarks, RocksDB achieved up to **10–30× faster traceBlock iteration times** compared to PebbleDB, with even greater benefits observed on archive nodes.

## Example: TraceBlock Latency Comparison

The following chart compares iteration (trace time) performance between **PebbleDB** and **RocksDB** over a 3 million block history:

<img src="https://mintcdn.com/seilabs/szEAtr1JphlH_mVc/assets/pebbledb-vs-rocksdb.png?fit=max&auto=format&n=szEAtr1JphlH_mVc&q=85&s=dc793f31c52e9b1d9baea5e406351fb2" alt="PebbleDB vs RocksDB Trace Times" width="738" height="372" data-path="assets/pebbledb-vs-rocksdb.png" />

*Trace Times: Pebble vs Rocks (3M history): RocksDB shows a significantly flatter latency curve as state grows, while PebbleDB’s iteration times increase sharply for older blocks.*

## Setup Instructions

RocksDB only needs to be built once. After that, you can install `seid` with RocksDB support directly.

### Prerequisites

Ensure your system includes the following packages:

```bash theme={"dark"}
sudo apt-get update
sudo apt-get install -y build-essential pkg-config cmake git zlib1g-dev \
    libbz2-dev libsnappy-dev liblz4-dev libzstd-dev libjemalloc-dev \
    libgflags-dev liburing-dev
```

### Build & Install

Refer to the Sei `Makefile` [here](https://github.com/sei-protocol/sei-chain/blob/main/Makefile#L116) for the official targets.

```bash theme={"dark"}
# Step 1: Build RocksDB (one-time setup)
make build-rocksdb

# Step 2: Install seid with RocksDB backend
make install-rocksdb
```

Once installed, your `seid` binary will be built with RocksDB backend support:

```bash theme={"dark"}
seid version
# should include "rocksdbBackend" build tag
```

### Configuration

After installation, update your configuration file to enable the RocksDB backend:

```bash theme={"dark"}
~/.sei/config/app.toml
```

Set

```toml theme={"dark"}
ss-backend = "rocksdb"
```

### Node Setup Notes

* RPC Nodes — must perform a state sync when spinning up a new node configured with RocksDB.
* Archive Nodes — currently, RocksDB is not supported for existing data unless syncing from genesis. A migration route from PebbleDB to RocksDB is being developed and will be shared soon.

## Summary

| Feature                       | PebbleDB           | RocksDB                               |
| ----------------------------- | ------------------ | ------------------------------------- |
| MVCC Support                  | No                 | ✅ Native via user-defined timestamps  |
| Column Families               | No                 | ✅ Yes                                 |
| Iteration Speed (Large State) | Slows with history | ✅ Up to 30× faster                    |
| Installation                  | Default            | One-time build (`make build-rocksdb`) |

## TL;DR

* RocksDB backend drastically improves trace iteration and historical query performance.
* Install once, then run:

```bash theme={"dark"}
make install-rocksdb
```

* Update \~/.sei/config/app.toml to use RocksDB:

```toml theme={"dark"}
ss-backend = "rocksdb"
```

* RPC nodes require state sync; archive nodes must currently sync from genesis
* Expect **10–30× faster** trace latencies, especially on archive nodes or long-history setups.

---

URL: https://docs.sei.io/node/giga-storage-migration

# Giga SS Store Migration Guide

> Migrate a Sei RPC node to Giga SS Store: split EVM state into a dedicated state-store backend so non-EVM modules stop paying EVM write amplification.

Giga SS Store is the next step in Sei's storage evolution on top of [SeiDB](/node/node-operators#architecture).
It splits the hot EVM state into its own dedicated state-store (SS) database
so the node can scale toward the **\~150k TPS** target throughput, and so
non-EVM modules stop paying write amplification for EVM state.

After migration the SS layer is repartitioned into two cooperating stores:

| Layer                                    | Cosmos backend                       | EVM backend                                      |
| ---------------------------------------- | ------------------------------------ | ------------------------------------------------ |
| **SC** (State Commit, app hash)          | `memiavl`                            | FlatKV                                           |
| **SS** (State Store, historical queries) | single MVCC DB (PebbleDB or RocksDB) | dedicated EVM SS MVCC DB(s) under `data/evm_ss/` |

Only the **SS** layer changes for this migration. SC layer config is untouched
and `memiavl` remains the authoritative source for the app hash, so this is
invisible to the network.

<Info>This guide tracks the canonical procedure in [`docs/migration/giga_store_migration.md`](https://github.com/sei-protocol/sei-chain/blob/main/docs/migration/giga_store_migration.md) inside `sei-chain`. Open an issue there if anything here drifts.</Info>

## Prerequisites

<Warning>This migration is supported on **RPC nodes only**. Validator nodes and archive nodes are not supported by this flow yet — do not run it against either.</Warning>

* A `seid` build with the `evm-ss-split` flag wired in (Sei v6.5 or later). Older
  releases used per-key `evm-ss-write-mode` / `evm-ss-read-mode` toggles; if your
  `app.toml` still has those keys, upgrade `seid` before continuing.
* `sc-enable = true` and `ss-enable = true` in `app.toml`. Both must stay enabled.
* A trusted RPC endpoint to state-sync from (chain ID and trust-height source).
* Disk headroom for two SS databases. The EVM split does not duplicate data, but
  during migration both the old and the new layouts may briefly coexist on disk.

The migration **requires a full state sync**. There is no in-place migration
path and no live "dual-write then split" workflow — the state sync wipes the
local data directory and imports a fresh snapshot into the new layout.

## Benefits

* EVM reads are served exclusively from a dedicated EVM SS database.
* Non-EVM modules no longer pay write amplification for EVM state.
* A backend change (PebbleDB ↔ RocksDB) can be combined with the same state
  sync, since `ss-backend` drives both the Cosmos SS MVCC DB and every EVM SS
  sub-DB.

## What's different about EVM SS

EVM SS is **point-query only by design** (`Get` / `Has`). Iteration is
explicitly disabled on the EVM backend for performance: the hot EVM read path
is tuned for direct key lookups, and cross-bucket scans would defeat the
per-type sub-DB layout. Any EVM read that needs iteration must stay on the
Cosmos SS side.

## Migration Steps

### Step 1: Update `app.toml`

Apply the following settings in `~/.sei/config/app.toml`:

```toml copy theme={"dark"}
[state-commit]
# State commit is untouched by this migration.
sc-enable = true

[state-store]
ss-enable = true

# DBBackend for the Cosmos SS MVCC DB and for every EVM SS sub-DB.
# Supported: pebbledb, rocksdb. Default pebbledb.
ss-backend = "pebbledb"

# Route EVM state to the dedicated EVM SS backend.
# When false (default), EVM state lives in the Cosmos SS backend alongside
# everything else. When true, EVM data is routed exclusively to the EVM SS
# backend; non-EVM data stays in Cosmos SS. No fallback between backends.
evm-ss-split = true
```

If you want to switch SS backend in the same step:

* **PebbleDB → RocksDB**: set `ss-backend = "rocksdb"`, build `seid` with
  `-tags rocksdbBackend`, and install RocksDB per the
  [RocksDB Backend Guide](/node/rocksdb-backend). `ss-backend` drives both the
  Cosmos SS MVCC DB and every EVM SS sub-DB, so a single setting flips both.
* No data migration tool is needed across backends — the state sync populates
  the new layout.

### Step 2: State sync into the new layout

Giga SS Store is fully compatible with the existing state-snapshot format. On
import, the composite state store routes each snapshot node based on the
importing node's `evm-ss-split`:

* With `evm-ss-split = true`, EVM snapshot nodes go only into EVM SS and
  non-EVM nodes go only into Cosmos SS.
* The import path normalizes legacy `evm_flatkv` snapshot nodes to `evm`, so
  snapshots produced by either the old or new FlatKV module are accepted.

Both stores end up fully populated at the snapshot height, so the node can
start serving reads immediately.

The full state-sync flow is documented in the
[Statesync guide](/node/statesync). The minimal shape for this migration:

```bash copy theme={"dark"}
export TRUST_HEIGHT_DELTA=10000
export MONIKER="<moniker>"
export CHAIN_ID="<chain_id>"
export PRIMARY_ENDPOINT="<rpc_endpoint>"
export SEID_HOME="$HOME/.sei"

# 1. Stop seid
sudo systemctl stop seid

# 2. Back up files you need to preserve and wipe local state
cp $SEID_HOME/data/priv_validator_state.json /tmp/priv_validator_state.json
cp $SEID_HOME/config/priv_validator_key.json   /tmp/priv_validator_key.json
cp $SEID_HOME/config/genesis.json              /tmp/genesis.json
rm -rf $SEID_HOME/data/*
rm -rf $SEID_HOME/wasm
rm -rf $SEID_HOME/config/priv_validator_key.json
rm -rf $SEID_HOME/config/genesis.json
rm -rf $SEID_HOME/config/config.toml

# 3. Re-init, re-apply config.toml and app.toml (set Step 1 values again)
seid init --chain-id "$CHAIN_ID" "$MONIKER"

# 4. Resolve trust height/hash and persistent peers against PRIMARY_ENDPOINT,
#    then update config.toml. See /node/statesync for the full snippet.

# 5. Restore the backed-up files
cp /tmp/priv_validator_state.json $SEID_HOME/data/priv_validator_state.json
cp /tmp/priv_validator_key.json   $SEID_HOME/config/priv_validator_key.json
cp /tmp/genesis.json              $SEID_HOME/config/genesis.json

# 6. Start seid
sudo systemctl restart seid
```

<Warning>Make sure `priv_validator_key.json` is in safe storage before deleting it from the config directory. Loss of this key is unrecoverable for a validator and is not relevant to RPC-only nodes — but if you're following this from the wrong checklist you'll find out the hard way.</Warning>

### Step 3: Verify the new layout

Once the state sync completes and the node starts producing blocks, confirm
Giga SS Store is active in two places.

**Startup logs.** All three lines should appear:

```text theme={"dark"}
"SeiDB SS is enabled"                       # with the configured `backend`
"SeiDB EVM StateStore optimization is enabled"  # with the `separateDBs` label
"EVM state store enabled"                   # with `dir` and `separateDBs` labels
```

**EVM RPC.** `debug_traceBlockByNumber` is the cleanest end-to-end check —
it forces the node to read EVM state out of the new EVM SS backend:

```bash copy theme={"dark"}
curl -s -X POST http://127.0.0.1:8545 \
  -H 'Content-Type: application/json' \
  --data '{"jsonrpc":"2.0","method":"debug_traceBlockByNumber","params":["latest",{}],"id":1}'
```

The response should contain a `"result"` field rather than an RPC error.

## Safety checks

`seid` runs three DB-state checks at startup and refuses to launch if the EVM
SS and Cosmos SS DBs are inconsistent. They specifically catch the footgun of
flipping `evm-ss-split` from `false` to `true` without state syncing.

1. **EVM SS directory missing or empty** (before the EVM SS is opened). When
   `evm-ss-split = true`, the composite state store refuses to proceed if
   Cosmos SS already has committed history but the EVM SS directory
   (`data/evm_ss/` by default) does not exist or is empty. Failing before
   the sub-DBs are opened means a rejected config does not leave a confusing
   empty `data/evm_ss/` behind.
2. **EVM SS DB empty post-open, pre-recovery.** Belt-and-suspenders for (1)
   when the directory exists but its DBs are empty. The WAL only covers the
   last `KeepRecent` blocks, so replay cannot rebuild a fresh EVM SS from
   scratch.
3. **Mismatched earliest versions, post-recovery.** If the two DBs were
   populated from different snapshots (or pruned independently), historical
   reads would be inconsistent. A non-zero earliest-version divergence
   aborts startup.

If any check fires, the correct fix is either (a) complete the state sync
described above, or (b) set `evm-ss-split = false` and restart. If
`data/evm_ss/` is stale from a failed attempt, remove it before state syncing.

## Rollback

To roll back:

1. Set `evm-ss-split = false` in `app.toml`.
2. Restart the node. The EVM SS DB under `data/evm_ss/` is no longer opened
   but stays on disk until manually removed.

To fully reclaim the disk used by EVM SS, stop the node and delete
`data/evm_ss/` after reverting the setting.

<Warning>Cleanly rolling back to `evm-ss-split = false` requires another state sync. Under `evm-ss-split = true`, EVM writes go only to the EVM SS DB, so Cosmos SS will not have those writes. Restarting with `evm-ss-split = false` stops opening the EVM SS DB, but EVM-state queries will miss anything written after the Giga state sync until you re-state-sync without the split.</Warning>

## FAQ

### Where do the data files live after migrating?

* Cosmos SS data lives under the same directory as before, typically
  `data/pebbledb/` for the default `pebbledb` backend.
* EVM SS data lives under `data/evm_ss/`.
* SC data (`memiavl` + FlatKV) is untouched by this migration.

### Does Giga SS Store change the app hash or consensus?

No. The SC layer is unchanged, so `memiavl` remains the authoritative source
for the app hash. Giga SS Store is a per-node SS change that is invisible to
the network.

### Can I migrate a validator node with this guide?

Not yet. This migration guide is for RPC nodes only.

### Can I migrate an archive node with this guide?

Not yet. Archive-node migration is out of scope for this guide.

### Can I toggle back to `evm-ss-split = false` after enabling it?

Yes, but cleanly rolling back requires another state sync — see the
[Rollback](#rollback) section above.

### Why can't I just flip `evm-ss-split = true` on a running node?

Because `evm-ss-split = true` requires the EVM SS DB to already contain the
full history that Cosmos SS has. A live flip would leave the EVM SS DB empty
while the composite store refuses to fall back to Cosmos SS, which would
translate into missing EVM state at query time. The safety checks above
block this scenario at startup.

### Does Giga SS Store support historical proofs?

No, same as SeiDB. SS stores raw KVs and does not reconstruct IAVL-style
proofs.

---

URL: https://docs.sei.io/node/technical-reference

# Sei Technical Reference

> Access detailed command syntax, configuration parameters, and troubleshooting procedures for node operators and validators running Sei network infrastructure.

This guide serves as a comprehensive reference for Sei node operators and
validators, providing detailed command syntax, configuration parameters, and
troubleshooting procedures. For API documentation, please refer to our API
Documentation section.

## Command Line Interface Reference

The `seid` binary provides extensive functionality for managing your Sei node.
Understanding these commands is essential for effective node operation and
troubleshooting.

### Node Management Commands

These commands help you control and monitor your node's operation:

<Danger>
  If you see an error such as `panic: recovered: runtime error: integer divide by zero` it means you can’t start nodes straight from the genesis file. Instead, sync to the block tip via [state sync](/node/statesync) or using a [snapshot](/node/snapshot).
</Danger>

```bash theme={"dark"}
# Start the node
seid start [flags]

# Show node status
seid status

# Show validator consensus key
seid tendermint show-validator

# Query node information
seid query node info
```

### Key Management

Proper key management is crucial for security. These commands help you manage
your keys effectively:

```bash theme={"dark"}
# Create new key
seid keys add <name> [flags]

# List all keys
seid keys list

# Delete key
seid keys delete <name>

# Export key (encrypted)
seid keys export <name>

# Import key
seid keys import <name> <keyfile>

# Show key address
seid keys show <name> -a
```

### Transaction Commands

These commands allow you to interact with the blockchain:

```bash theme={"dark"}
# Send tokens
seid tx bank send <from-key> <to-address> <amount>usei [flags]

# Delegate tokens
seid tx staking delegate <validator-addr> <amount>usei --from <delegator-key>

# Withdraw rewards
seid tx distribution withdraw-rewards <validator-addr> --from <delegator-key>

# Edit validator
seid tx staking edit-validator [flags] --from <validator-key>
```

## Configuration Parameters

Understanding configuration parameters is essential for optimizing your node's
performance and security.

### App.toml Parameters

The app.toml file controls application-specific settings:

<Accordion title="Complete app.toml Configuration">
  ```toml theme={"dark"}
  # Minimum gas prices for transaction acceptance
  minimum-gas-prices = "0.02usei"

  # API configuration
  [api]
  enable = true
  swagger = true
  address = "tcp://0.0.0.0:1317"
  max-open-connections = 1000

  # State sync configuration
  [state-sync]
  snapshot-interval = 1000
  snapshot-keep-recent = 2

  # Memory management
  [mempool]
  size = 5000
  max-txs-bytes = 1073741824
  cache-size = 10000

  # State store configuration
  [state-store]
  ss-enable = true
  ss-backend = "pebbledb"
  ss-keep-recent = 100000
  ss-prune-interval = 600
  ```
</Accordion>

### Config.toml Parameters

The config.toml file controls the core consensus engine and networking:

<Accordion title="Complete config.toml Configuration">
  ```toml theme={"dark"}
  # P2P Configuration
  [p2p]
  laddr = "tcp://0.0.0.0:26656"
  external-address = ""
  seeds = ""
  persistent_peers = ""
  upnp = false
  max_num_inbound_peers = 40
  max_num_outbound_peers = 10
  allowed_pools = ""
  max_packet_msg_payload_size = 10240
  handshake_timeout = "20s"
  dial_timeout = "3s"

  # RPC Configuration
  [rpc]
  laddr = "tcp://0.0.0.0:26657"
  cors_allowed_origins = []
  cors_allowed_methods = ["HEAD", "GET", "POST"]
  cors_allowed_headers = ["Origin", "Accept", "Content-Type", "X-Requested-With", "X-Server-Time"]
  max_open_connections = 900
  timeout_broadcast_tx_commit = "10s"

  # Consensus Configuration
  [consensus]
  wal_file = "data/cs.wal/wal"
  timeout_propose = "3s"
  timeout_propose_delta = "500ms"
  timeout_prevote = "1s"
  timeout_prevote_delta = "500ms"
  timeout_precommit = "1s"
  timeout_precommit_delta = "500ms"
  timeout_commit = "1s"
  double_sign_check_height = 0
  ```
</Accordion>

## Network Parameters

Understanding network parameters helps you operate your node effectively.

### Chain Parameters

These parameters define the network's behavior:

```text theme={"dark"}
Block Time: ~400ms target
Max Validators: 40
Unbonding Period: 21 days
Minimum Self Delegation: 1 SEI

Slashing Parameters:
  - signed_blocks_window:        108,000 blocks
  - min_signed_per_window:       5%   (validator must sign ≥5% of blocks in the window)
  - downtime_jail_duration:      10 minutes
  - slash_fraction_downtime:     0%   (no stake slash; jail only)
  - slash_fraction_double_sign:  0%   (no stake slash; double-signing still triggers
                                       permanent tombstoning)
```

<Info>
  These values reflect the current on-chain parameters. Query them directly with `seid query staking params` and `seid query slashing params` for the source of truth. Per-validator settings (e.g. commission rate, commission max change rate) are configured per validator and are not chain-level parameters.
</Info>

## File Locations

Understanding the purpose and location of important files helps with maintenance
and troubleshooting:

```text theme={"dark"}
$HOME/.sei/
├── config/
│   ├── app.toml         # Application configuration
│   ├── client.toml      # Client configuration
│   ├── config.toml      # Tendermint configuration
│   ├── genesis.json     # Chain genesis file
│   ├── node_key.json    # Node identity key
│   └── priv_validator_key.json  # Validator signing key
├── data/
│   ├── application.db   # Application state
│   ├── blockstore.db    # Block data
│   ├── cs.wal/         # Consensus write-ahead logs
│   ├── evidence.db     # Evidence of misbehavior
│   ├── state.db        # Tendermint state
│   └── tx_index.db     # Transaction index
└── keyring-file/       # Local key storage
```

This reference guide provides essential technical information for operating Sei
nodes and validators. For API documentation and other detailed specifications,
please refer to the respective sections in our documentation set.

---

URL: https://docs.sei.io/ai

# Build on Sei with AI

> AI tools for building on Sei — from knowledge injection that makes your AI assistant Sei-aware, to live blockchain tooling that lets it act on-chain.

AI coding assistants are powerful — but they weren't trained on Sei's specifics. Without context, they'll give you generic Ethereum answers: wrong gas patterns, missing dual-address handling, outdated package names, and assumptions about finality that don't hold on a 400ms chain.

Sei provides two complementary tools to fix this.

## Two tools, two roles

<CardGroup cols={2}>
  <Card title="sei-skill" icon="brain" href="/ai/sei-skill">
    **Knowledge injection.** Teaches your AI assistant everything about Sei — architecture, precompiles, wallet patterns, gas behavior, and ecosystem — so every answer it gives is Sei-specific from the start.
  </Card>

  <Card title="MCP Server" icon="plug" href="/ai/mcp-server">
    **Live blockchain access.** Gives your AI assistant tools to read and write on-chain: query balances, send transactions, interact with contracts, and monitor network state in real time.
  </Card>
</CardGroup>

Use them together: sei-skill makes your assistant think in Sei, the MCP Server lets it act on Sei.

## Build AI agents on Sei

<CardGroup cols={3}>
  <Card title="Cambrian Agent Kit" icon="robot" href="/ai/cambrian-agent-kit">
    SDK for building autonomous AI agents with DeFi integrations — staking, lending, swaps, liquidity — powered by LangChain.
  </Card>

  <Card title="Agentic Wallets" icon="wallet" href="/ai/agentic-wallets">
    Wallet infrastructure designed for AI agents: programmable signing, session keys, and policy controls.
  </Card>

  <Card title="x402 Payments" icon="credit-card" href="/ai/x402">
    HTTP-native micropayments so agents can pay per-inference for LLM APIs, data feeds, and other monetized services.
  </Card>
</CardGroup>

---

URL: https://docs.sei.io/ai/sei-skill

# Agent Skills

> A knowledge base that makes AI coding assistants Sei-aware — covering contracts, frontend, and ecosystem with Sei-specific facts baked in.

<Info>sei-skill is open source. Contribute at [github.com/sei-protocol/sei-skill](https://github.com/sei-protocol/sei-skill)</Info>

sei-skill is a structured knowledge base for AI coding assistants. Install it once and your assistant — Claude Code, Cursor, Copilot, Windsurf, or any other — will answer Sei questions with Sei-specific accuracy instead of generic Ethereum defaults.

## Why this matters

AI assistants are trained on broad Ethereum knowledge, not Sei's specifics. Without sei-skill, they'll confidently give you wrong answers:

| Without sei-skill                   | With sei-skill                                                                                                                                                    |
| ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `maxFeePerGas` in transactions      | Legacy `gasPrice` (Sei doesn't use EIP-1559 basefee)                                                                                                              |
| "Finality takes \~12 confirmations" | Instant finality — 1 confirmation is final                                                                                                                        |
| SSTORE costs 20,000 gas             | SSTORE costs 72,000 gas — the same on mainnet and testnet (governance-adjustable on-chain parameter; [reference](/evm/differences-with-ethereum#sstore-gas-cost)) |
| `PREVRANDAO` for randomness         | PREVRANDAO is not random on Sei — use Pyth VRF or Chainlink VRF                                                                                                   |
| Generic ERC-20 patterns             | Sei precompiles, pointer contracts, dual-address UX                                                                                                               |
| `@sei-js/evm` imports               | `@sei-js/precompiles` (the current package name)                                                                                                                  |

## Three knowledge domains

sei-skill covers three areas. You can install all three or just the ones you need.

**Contracts** — EVM smart contract development on Sei:

* Foundry and Hardhat setup for Sei networks
* All Sei precompiles (Staking, Governance, Bank, Distribution, JSON, P256)
* Pointer contracts for cross-VM asset bridging
* Gas optimization, OCC parallel execution awareness
* Account abstraction (ERC-4337), contract upgradeability
* Verification workflows on Seiscan
* Security patterns and common errors

**Frontend** — dApp UI development:

* Wagmi + Viem setup with Sei chain config
* Wallet integration (Sei Global Wallet, MetaMask, Compass, Ledger, EIP-6963)
* Dual-address UX (`sei1...` ↔ `0x...` from the same key)
* Fast-finality patterns for 400ms blocks
* RainbowKit and ConnectKit integration

**Ecosystem** — infrastructure and integrations:

* RPC endpoints (public, community, paid SaaS)
* Bridges (LayerZero V2, Wormhole, Axelar, CCTP)
* Oracles (Chainlink, Pyth, API3, RedStone)
* Indexers (The Graph, Goldsky, Dune, Moralis)
* DeFi protocols (DragonSwap, Yei, Takara, Saphyre)
* Validators, node operations, grants

## Quick install

```bash theme={"dark"}
git clone https://github.com/sei-protocol/sei-skill
cd sei-skill
./install.sh
```

This installs to `~/.claude/skills/sei/` by default (Claude Code). For other AI assistants, see the [Installation Guide](/ai/sei-skill/install).

## Next steps

<CardGroup cols={2}>
  <Card title="Installation Guide" icon="download" href="/ai/sei-skill/install">
    Install for Claude Code, Cursor, Copilot, Windsurf, and more. Choose your variant.
  </Card>

  <Card title="Example Prompts" icon="message" href="/ai/sei-skill/prompts">
    See what better answers look like — prompts across contracts, frontend, and ecosystem.
  </Card>
</CardGroup>

---

URL: https://docs.sei.io/ai/sei-skill/install

# sei-skill Installation

> Install sei-skill for Claude Code, Cursor, GitHub Copilot, Windsurf, and other AI coding assistants.

## Prerequisites

```bash theme={"dark"}
git clone https://github.com/sei-protocol/sei-skill
cd sei-skill
```

## Install by agent

<Tabs>
  <Tab title="Claude Code">
    The default install targets Claude Code, placing the skill in `~/.claude/skills/sei/`:

    ```bash theme={"dark"}
    ./install.sh
    ```

    The skill loads automatically in every Claude Code session. To verify it's active, ask: *"What is the SSTORE gas cost on Sei testnet?"*
  </Tab>

  <Tab title="Codex">
    ```bash theme={"dark"}
    ./install.sh --agent codex
    ```

    Installs to `AGENTS.md` in your project root. Codex CLI reads this file automatically.
  </Tab>

  <Tab title="Cursor">
    ```bash theme={"dark"}
    ./install.sh --agent cursor
    ```

    Installs to `.cursor/rules/sei.mdc` in your project. Cursor picks it up automatically as a rule file.
  </Tab>

  <Tab title="GitHub Copilot">
    ```bash theme={"dark"}
    ./install.sh --agent copilot
    ```

    Installs to `.github/copilot-instructions.md`. Copilot uses this file as custom instructions for the repository.
  </Tab>

  <Tab title="Windsurf">
    ```bash theme={"dark"}
    ./install.sh --agent windsurf
    ```

    Installs to `.windsurf/rules/sei.md`. Windsurf's Cascade reads this automatically.
  </Tab>

  <Tab title="Aider">
    ```bash theme={"dark"}
    ./install.sh --agent aider
    ```

    Installs to `~/.aider/sei.md`. Aider loads it as persistent context.
  </Tab>

  <Tab title="OpenHands">
    ```bash theme={"dark"}
    ./install.sh --agent openhands
    ```

    Installs to `.openhands/SKILL.md` in your project.
  </Tab>

  <Tab title="Gemini">
    ```bash theme={"dark"}
    ./install.sh --agent gemini
    ```

    Installs to `GEMINI.md` in your project root.
  </Tab>
</Tabs>

## Variants

The full skill covers all three domains (contracts, frontend, ecosystem). If you only need one area, install a variant to keep context lean:

| Variant        | Command                            | Best for                      |
| -------------- | ---------------------------------- | ----------------------------- |
| Full (default) | `./install.sh`                     | General Sei development       |
| Contracts      | `./install.sh --variant contracts` | Smart contract engineers      |
| Frontend       | `./install.sh --variant frontend`  | dApp and UI developers        |
| Ecosystem      | `./install.sh --variant ecosystem` | Infra, integrations, research |

Combine with `--agent` to target a specific assistant:

```bash theme={"dark"}
./install.sh --agent cursor --variant contracts
```

## Advanced options

**Install to a project directory** (instead of `~/.claude/`):

```bash theme={"dark"}
./install.sh --project
```

**Flatten to a single markdown file** — useful for pasting into any chat interface or custom context:

```bash theme={"dark"}
./install.sh --flatten --output ./sei-context.md
```

**Custom output path:**

```bash theme={"dark"}
./install.sh --output /path/to/custom/location
```

## Verify it's working

After installing, test with a Sei-specific question that trips up unaugmented assistants:

* *"What gas price should I use for transactions on Sei?"*
* *"Is PREVRANDAO a safe source of randomness on Sei?"*
* *"What's the difference between `sei1...` and `0x...` addresses?"*

A Sei-aware assistant will give accurate, specific answers to all three.

---

URL: https://docs.sei.io/ai/sei-skill/prompts

# sei-skill Example Prompts

> Prompts that unlock Sei-specific guidance from your AI assistant after installing sei-skill.

Once sei-skill is installed, your AI assistant has accurate, up-to-date context on everything Sei. These prompts show what that looks like in practice — questions that would get generic (wrong) Ethereum answers without the skill, and accurate Sei-specific answers with it.

## Contracts

```
Set up Foundry for Sei testnet
```

```
Deploy a Solidity contract to Sei mainnet and verify it on Seiscan
```

```
How do I call the Staking precompile from Solidity to delegate SEI?
```

```
Why does SSTORE cost more on Sei than on Ethereum, and how should I budget gas for storage writes?
```

```
How do I use the Bank precompile to query a native denom balance?
```

```
Load test my contract against the OCC parallel execution scheduler
```

```
Set up a UUPS upgradeable proxy for my Sei contract
```

```
Use ERC-4337 account abstraction on Sei with Pimlico
```

```
How do I create a pointer contract so my ERC-20 is accessible as a CW20?
```

```
Optimize gas for a contract that does many SSTORE writes
```

```
What's a safe source of randomness on Sei? Can I use PREVRANDAO?
```

```
Migrate my Ethereum contract to Sei — what do I need to change?
```

## Frontend

```
Set up Wagmi v2 with Sei mainnet and testnet chain configs
```

```
How do I integrate Sei Global Wallet for social login in my dApp?
```

```
Why should I use gasPrice instead of maxFeePerGas on Sei?
```

```
Display both the EVM address and Sei native address for a connected wallet
```

```
Connect to Sei with MetaMask, Compass, and Ledger using EIP-6963
```

```
Set up RainbowKit on Sei
```

```
How do I handle Sei's 400ms block time in my UI? When is a transaction final?
```

```
Read a precompile from a React component using useReadContract
```

```
Set up wagmi useWriteContract for delegating SEI to a validator
```

## Ecosystem

```
What are reliable RPC endpoints for Sei mainnet with failover?
```

```
How do I bridge USDC to Sei using LayerZero V2?
```

```
Integrate Pyth price feeds in my Sei contract
```

```
Index Sei events with Goldsky subgraph
```

```
What DeFi protocols are live on Sei that I can integrate with?
```

```
How do I apply for a Sei Foundation grant?
```

```
Set up a Sei full node with state sync
```

```
How do I become a Sei validator?
```

```
Submit a governance proposal on Sei via CLI
```

## Architecture

```
Explain how Sei's OCC parallel execution works and how it affects contract design
```

```
What is Twin Turbo Consensus and how does it achieve sub-second finality?
```

```
How does the dual-address system work — when do I need to associate addresses?
```

```
What changed in SeiDB and why does it matter for state-heavy contracts?
```

```
Is CosmWasm still supported on Sei?
```

---

URL: https://docs.sei.io/ai/mcp-server

# MCP Server

> Enable AI assistants to interact with Sei networks through natural language using the Model Context Protocol

The Sei Model Context Protocol (MCP) Server enables AI assistants to interact with Sei networks through natural language. Built on the [Model Context Protocol](https://modelcontextprotocol.io/) standard, it provides seamless blockchain integration for AI coding assistants.

<Info>The Sei MCP Server is open source. Contribute at [github.com/sei-protocol/sei-js](https://github.com/sei-protocol/sei-js/tree/main/packages/mcp-server)</Info>

## What is MCP?

The Model Context Protocol is an open standard that connects AI systems with external tools and data sources. It enables:

* Real-time data access from external services
* Function execution and operations
* Context preservation across interactions
* Specialized capabilities beyond base training

The Sei MCP Server leverages this protocol to bring blockchain functionality directly to your AI assistant.

## Capabilities

| Category           | Features                                                   |
| ------------------ | ---------------------------------------------------------- |
| Account Management | Wallet addresses • Balance queries • Contract verification |
| Token Operations   | SEI transfers • ERC20/721/1155 support • Token approvals   |
| Blockchain Data    | Block information • Transaction details • Network status   |
| Smart Contracts    | State queries • Function execution • Event logs            |
| Networks           | Mainnet • Testnet                                          |

## Setup Guide

<Tabs>
  <Tab title="Cursor">
    ### Cursor Setup

    <Steps>
      <Step title="Open Settings">
        Navigate to `Cursor → Settings → Cursor Settings → MCP`
      </Step>

      <Step title="Configure Server">
        Click **"Add new Global MCP server"** and add this configuration to `mcp.json`:

        ```json theme={"dark"}
        {
          "mcpServers": {
            "sei-mcp-server": {
              "command": "npx",
              "args": ["-y", "@sei-js/mcp-server"],
              "env": {
                "PRIVATE_KEY": "your_private_key_here"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Restart">
        Restart Cursor to activate the MCP server. You'll see a notification when it's ready.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Windsurf">
    ### Windsurf Setup

    <Steps>
      <Step title="Open Settings">
        Navigate to `Windsurf → Settings → Windsurf Settings → Cascade`
      </Step>

      <Step title="Add Configuration">
        Add the Sei MCP Server to your configuration:

        ```json theme={"dark"}
        {
          "mcpServers": {
            "sei": {
              "command": "npx",
              "args": ["-y", "@sei-js/mcp-server"],
              "env": {
                "PRIVATE_KEY": "your_private_key_here"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Activate">
        Save and restart Windsurf. The server loads automatically.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Desktop">
    ### Claude Desktop Setup

    <Steps>
      <Step title="Install Claude">
        Download [Claude Desktop](https://claude.ai/download) from Anthropic.
      </Step>

      <Step title="Edit Configuration">
        Open **Settings** → **Developer** → **Edit Config** and add:

        ```json theme={"dark"}
        {
          "mcpServers": {
            "sei": {
              "command": "npx",
              "args": ["-y", "@sei-js/mcp-server"],
              "env": {
                "PRIVATE_KEY": "your_private_key_here"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Restart">
        Save and restart Claude Desktop to enable Sei tools.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude CLI">
    ### Claude CLI Setup

    <Steps>
      <Step title="Install CLI">
        ```bash theme={"dark"}
        npm install -g @anthropic-ai/claude-code
        ```
      </Step>

      <Step title="Add Server">
        ```bash theme={"dark"}
        claude mcp add sei-mcp-server npx @sei-js/mcp-server
        ```
      </Step>

      <Step title="Start Session">
        ```bash theme={"dark"}
        claude
        ```

        The Sei MCP Server activates automatically in your session.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Private Key Setup

<Warning>**Security Notice**: Generate a dedicated wallet for MCP operations. Never use your main wallet's private key.</Warning>

Export your private key from your wallet:

* Look for "Export Private Key" or "Show Private Key" in wallet settings
* Ensure the key starts with `0x`
* Fund the wallet with small amounts for testing

## Features

The Sei MCP Server enables your AI assistant to:

### Blockchain Operations

* Query account balances and transaction history
* Execute token transfers
* Interact with smart contracts
* Monitor network status

### Coming Soon

* Documentation search and explanation
* @sei-js library integration
* Boilerplate generation
* DeFi protocol interactions

## Available Tools

### Core Operations

| Tool                           | Purpose                 | Example                     |
| ------------------------------ | ----------------------- | --------------------------- |
| `get_address_from_private_key` | Retrieve wallet address | "What's my wallet address?" |
| `get_balance`                  | Check SEI balance       | "Check balance of 0x123..." |
| `transfer_sei`                 | Send SEI tokens         | "Send 1 SEI to 0x456..."    |
| `is_contract`                  | Verify contract address | "Is 0x789... a contract?"   |

### Token Management

| Tool                     | Purpose        | Example                     |
| ------------------------ | -------------- | --------------------------- |
| `get_token_info`         | Token metadata | "Get USDC token info"       |
| `get_token_balance`      | Token balance  | "Check my USDC balance"     |
| `transfer_token`         | Token transfer | "Send 100 USDC to 0x123..." |
| `approve_token_spending` | Token approval | "Approve DEX for USDC"      |

### NFT Operations

| Tool                  | Purpose                | Example                     |
| --------------------- | ---------------------- | --------------------------- |
| `get_nft_info`        | NFT metadata           | "Show NFT #123 details"     |
| `check_nft_ownership` | Ownership verification | "Who owns NFT #456?"        |
| `transfer_nft`        | NFT transfer           | "Send NFT #789 to 0xABC..." |
| `get_nft_balance`     | Collection balance     | "How many NFTs do I own?"   |

### Blockchain Data

| Tool                  | Purpose                 | Example                 |
| --------------------- | ----------------------- | ----------------------- |
| `get_chain_info`      | Network information     | "Show Sei mainnet info" |
| `get_block_by_number` | Block details by number | "Get block 12345"       |
| `get_latest_block`    | Latest block details    | "Get latest block"      |
| `get_transaction`     | Transaction data        | "Show tx 0xTXID..."     |
| `read_contract`       | Contract state          | "Read DEX reserves"     |

## AI Prompts

Pre-configured prompts for common tasks:

<div className="grid grid-cols-1 md:grid-cols-2 gap-4 my-6">
  <div className="bg-white dark:bg-neutral-800/50  p-4 border border-neutral-200 dark:border-neutral-700">
    <h4 className="font-medium text-purple-600 dark:text-purple-400 mb-1">my\_wallet\_address</h4>
    <p className="text-sm text-neutral-600 dark:text-neutral-400">Get your wallet address</p>
  </div>

  <div className="bg-white dark:bg-neutral-800/50  p-4 border border-neutral-200 dark:border-neutral-700">
    <h4 className="font-medium text-purple-600 dark:text-purple-400 mb-1">explore\_block</h4>
    <p className="text-sm text-neutral-600 dark:text-neutral-400">Analyze block data</p>
  </div>

  <div className="bg-white dark:bg-neutral-800/50  p-4 border border-neutral-200 dark:border-neutral-700">
    <h4 className="font-medium text-purple-600 dark:text-purple-400 mb-1">analyze\_transaction</h4>
    <p className="text-sm text-neutral-600 dark:text-neutral-400">Transaction details</p>
  </div>

  <div className="bg-white dark:bg-neutral-800/50  p-4 border border-neutral-200 dark:border-neutral-700">
    <h4 className="font-medium text-purple-600 dark:text-purple-400 mb-1">analyze\_address</h4>
    <p className="text-sm text-neutral-600 dark:text-neutral-400">Address analysis</p>
  </div>
</div>

## Usage Examples

<div className="space-y-4 my-6">
  <div className="bg-white dark:bg-neutral-800/50  p-4 border-l-4 border-purple-500">
    <p className="text-sm font-medium text-purple-600 dark:text-purple-400 mb-1">Query Balance</p>
    <p className="text-neutral-700 dark:text-neutral-300">"What's my SEI balance?"</p>
    <p className="text-sm text-neutral-600 dark:text-neutral-400 mt-2">→ Returns wallet balance and address</p>
  </div>

  <div className="bg-white dark:bg-neutral-800/50  p-4 border-l-4 border-purple-500">
    <p className="text-sm font-medium text-purple-600 dark:text-purple-400 mb-1">Send Transaction</p>
    <p className="text-neutral-700 dark:text-neutral-300">"Send 1 SEI to 0x742d35Cc6634C0532925a3b844Bc454e4438f44e"</p>
    <p className="text-sm text-neutral-600 dark:text-neutral-400 mt-2">→ Executes transfer and returns transaction hash</p>
  </div>

  <div className="bg-white dark:bg-neutral-800/50  p-4 border-l-4 border-purple-500">
    <p className="text-sm font-medium text-purple-600 dark:text-purple-400 mb-1">Contract Analysis</p>
    <p className="text-neutral-700 dark:text-neutral-300">"Is 0x3894085ef7ff0f0aedf52e2a2704928d1ec074f1 a contract?"</p>
    <p className="text-sm text-neutral-600 dark:text-neutral-400 mt-2">→ Identifies contract type and metadata</p>
  </div>
</div>

## Resource URIs

Access blockchain data through standardized URIs:

```bash theme={"dark"}
# Network data
evm://sei/chain
evm://sei-testnet/chain

# Block information
evm://sei/block/latest
evm://sei/block/12345

# Transactions
evm://sei/tx/0xabc123...
evm://sei/tx/0xabc123.../receipt

# Token data
evm://sei/token/0x3894085ef7ff0f0aedf52e2a2704928d1ec074f1
evm://sei/token/0x389.../balanceOf/0x742d...

# NFT data
evm://sei/nft/0xNFT_ADDRESS/123
evm://sei/nft/0xNFT_ADDRESS/123/isOwnedBy/0x742d...
```

## Configuration

### Environment Setup

```bash theme={"dark"}
# .env file
PRIVATE_KEY=0x_your_private_key_here

# Optional (coming soon)
CUSTOM_RPC_URL=https://your-rpc.com
CUSTOM_CHAIN_ID=1329
```

### HTTP Server Mode

For web applications:

```bash theme={"dark"}
# Start HTTP server
npx @sei-js/mcp-server --http

# Connect from web app
const eventSource = new EventSource('http://localhost:3001/sse');
```

## Security Guidelines

<Warning>
  **Security Guidelines:**

  1. **Use a dedicated wallet** - Create a new wallet specifically for MCP
  2. **Minimal funding** - Only add funds needed for testing
  3. **Environment variables** - Never hardcode private keys
  4. **Monitor activity** - Regularly check transaction history

  **For production:**

  * Implement transaction limits
  * Use multi-signature wallets
  * Add contract whitelisting
  * Enable rate limiting
</Warning>

## Troubleshooting

**Connection issues**: Verify Node.js 18+ is installed and restart your AI assistant.

**Private key errors**: Ensure key format starts with `0x` and wallet has sufficient funds.

**Cursor: The model returned an error. Try disabling the MCP servers, or switch models**: Disable "Auto" in the model
menu and select a specific model e.g. `claude-4-sonnet`

---

URL: https://docs.sei.io/ai/cambrian-agent-kit

# Cambrian Agent Kit Ecosystem Tutorial

> Learn to build powerful, autonomous AI agents and agentic chatbots on the SEI blockchain with DeFi protocol integrations including Takara, Silo, Citrex, and Symphony.

## Overview

Cambrian Agent Kit is a developer SDK for building powerful, autonomous AI agents and agentic chatbots on the SEI blockchain. It lets you interact with DeFi protocols (Takara, Silo, Citrex, Symphony), manage SEI tokens and NFTs, and seamlessly integrate AI workflows. In this tutorial, you'll learn how to set up the kit, run your first agent, and use it for real DeFi use cases—customized for your needs. To understand more and deep dive into how it works under the hood, please refer to the [Cambrian Agent Kit Documentation](https://deepwiki.com/CambrianAgents/sei-agent-kit/1-overview).

## Supported Features

The SEI Agent Kit supports a comprehensive set of features for blockchain agent development:

* Token Operations: Complete SEI ERC-20 and ERC-721 token management
* DeFi Protocol Integration: Seamless interaction with SEI's DeFi ecosystem
* Swap Functionality: Token swapping through Symphony aggregator
* Liquidity Management: Add and remove liquidity with DragonSwap
* Lending & Borrowing: Interact with Takara protocol for lending operations
* Staking Operations: Stake and unstake SEI tokens with Silo
* LangChain Integration: Build AI agents with LangChain and LangGraph

## What this guide teaches you:

This tutorial guides you through:

* **Setup**: Install and configure the Agent Kit, connect your wallet and API keys.
* **Core Concepts**: Understand agents, supported protocols, and how these components fit together.
* **End-to-End Examples**: You'll run practical code to:
  * Check your token/NFT balances.
  * Swap tokens using Symphony.
  * Stake/unstake SEI in Silo.
  * Lend/borrow with Takara.
  * Trade perps with Citrex.
* **Customization**: Learn to adapt the kit for your own protocol or workflow.

<Info>
  **Some Use Cases:**

  * **Autonomous DeFi Agents**: Agents that can automatically manage token positions, provide liquidity, or engage in lending activities
  * **AI-Assisted Wallets**: Conversational interfaces for blockchain operations
  * **Financial Assistant Agents**: AI agents that can analyze market conditions and execute trades
  * **Portfolio Management Agents**: Automated management of crypto asset portfolios
</Info>

## Hands-on Tutorial

### 1. Prerequisites

* Node.js & npm installed
* SEI wallet private key
* OpenAI API key (for AI integrations)
* **Minimum SEI balance**: Ensure you have sufficient SEI for gas

### 2. Project Setup

```bash theme={"dark"}
git clone https://github.com/CambrianAgents/sei-agent-kit.git
cd sei-agent-kit
cp .env.example .env   # Fill in your keys!
npm install
```

Edit `.env`:

```env theme={"dark"}
OPENAI_API_KEY=your_openai_api_key
SEI_PRIVATE_KEY=your_wallet_private_key
RPC_URL=https://evm-rpc.sei-apis.com
```

<Warning>
  **Important Security Notes:**

  * **Never share your private key**: Your private key controls your funds
</Warning>

### 3. Running Your First Agent

```bash theme={"dark"}
npm run test
```

The following is the output and interaction with the Cambrian Agent:

```bash theme={"dark"}
npm run test

> sei-agent-kit@0.0.3 test
> tsx test/index.ts


  ███████╗███████╗██╗      █████╗  ██████╗ ███████╗███╗   ██╗████████╗    ██╗  ██╗██╗████████╗
  ██╔════╝██╔════╝██║     ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝    ██║ ██╔╝██║╚══██╔══╝
  ███████╗█████╗  ██║     ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║       █████╔╝ ██║   ██║
  ╚════██║██╔══╝  ██║     ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║       ██╔═██╗ ██║   ██║
  ███████║███████╗██║     ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║       ██║  ██╗██║   ██║
  ╚══════╝╚══════╝╚═╝     ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝       ╚═╝  ╚═╝╚═╝   ╚═╝


Starting chat with the Cambrian Agent... Type 'bye' to end.

You: Hey, I would like to swap some sei to usdc.

Cambrian Agent: Sure thing! How much SEI would you like to swap for USDC? Let me know, and I'll get the magic started! ✨

-----------------------------------


You: I would like to swap 0.2 sei for some usdc

Cambrian Agent:

-----------------------------------

Getting token address for USDC...
Swapping 0.2 0x0 to 0x3894085ef7ff0f0aedf52e2a2704928d1ec074f1...
Querying balance of SEI for 0xa0E377AEaF32024f949667f56e7fa4409AFE6b8D...

Cambrian Agent: {"status":"success","result":"0x638d08db41e9ed370504861b4d2ced693869c45136bfdba2d92e8aed43c080fa","fromToken":"SEI","toToken":"USDC","amount":"0.2"}

-----------------------------------


Cambrian Agent: Your swap of 0.2 SEI to USDC was successful! 🎉 The transaction hash is `0x638d08db41e9ed370504861b4d2ced693869c45136bfdba2d92e8aed43c080fa`. If you have any more magical swaps or questions, just let me know! 🪄

-----------------------------------


You: Give me my new balances after the previous transaction

Cambrian Agent:

-----------------------------------

Getting token address for SEI...
Getting token address for USDC...
Querying balance of 0x3894085ef7ff0f0aedf52e2a2704928d1ec074f1 for 0xa0E377AEaF32024f949667f56e7fa4409AFE6b8D...
Querying balance of 0x67da7010c6c231ad620e3940e707adb6c1a08f23 for 0xa0E377AEaF32024f949667f56e7fa4409AFE6b8D...

Cambrian Agent: {"status":"success","balance":"0","token":{"ticker":"SEI"}}

-----------------------------------


Cambrian Agent: After the swap, your new balances are:

- SEI: 0 SEI (Looks like you've spent it all!)
- USDC: 0.147866 USDC

If you need anything else, just give me a shout! 📢

-----------------------------------


You: bye
```

<Info>
  **Understanding the Transaction:**

  * **SEI Address**: `0x0` represents native SEI token in the agent kit
  * **Transaction Hash**: Can be verified on [Seiscan](https://seiscan.io/)
  * **Gas Fees**: Automatically calculated and deducted from your balance
</Info>

### 4. Explore Core Features & Protocols

#### a) Check Token Balance with Error Handling

```typescript theme={"dark"}
import { SeiAgentKit } from './src/agent';

async function checkBalanceWithErrorHandling() {
  try {
    const agent = new SeiAgentKit(process.env.SEI_PRIVATE_KEY, 'openai');

    // Check SEI balance
    const balance = await agent.getERC20Balance(); // SEI or specify contract address
    console.log('Your SEI Balance:', balance);

    // Validate balance before proceeding
    if (parseFloat(balance) < 0.01) {
      console.warn('⚠️ Low SEI balance. You may need more SEI for gas fees.');
    }
  } catch (error) {
    console.error('Error checking balance:', error.message);

    // Handle specific error types
    if (error.message.includes('insufficient funds')) {
      console.log('💡 Tip: Add more SEI to your wallet');
    } else if (error.message.includes('network')) {
      console.log('💡 Tip: Check your RPC connection');
    }
  }
}
```

#### b) Safe Token Swapping with Symphony

```typescript theme={"dark"}
async function safeSwap() {
  try {
    const agent = new SeiAgentKit(process.env.SEI_PRIVATE_KEY, 'openai');

    // Validate inputs
    const amount = '1.0';
    const fromToken = '0x0'; // SEI
    const toToken = 'usdc_contract_address';

    // Check balance first
    const balance = await agent.getERC20Balance();
    if (parseFloat(balance) < parseFloat(amount)) {
      throw new Error('Insufficient balance for swap');
    }

    // Execute swap with error handling
    const tx = await agent.swap(amount, fromToken, toToken);
    console.log('Swap TX:', tx);

    // Verify transaction
    if (tx.status === 'success') {
      console.log('✅ Swap successful!');
      console.log('🔗 Transaction hash:', tx.result);
    } else {
      console.error('❌ Swap failed:', tx.error);
    }
  } catch (error) {
    console.error('Swap error:', error.message);

    // Handle common swap errors
    if (error.message.includes('slippage')) {
      console.log('💡 Tip: Try increasing slippage tolerance');
    } else if (error.message.includes('liquidity')) {
      console.log('💡 Tip: Insufficient liquidity for this pair');
    }
  }
}
```

<Warning>
  **Swap Safety Tips:**

  * **SEI Native Token**: Use "0x0" as the address for native SEI token while using the agent kit
  * **Slippage Protection**: Always set appropriate slippage tolerance
  * **Price Impact**: Monitor price impact before large swaps
</Warning>

#### c) Liquid Staking with Silo Protocol

```typescript theme={"dark"}
async function stakingWithSilo() {
  try {
    const agent = new SeiAgentKit(process.env.SEI_PRIVATE_KEY, 'openai');

    // Stake SEI and receive iSEI
    const stakeAmount = '2.0';
    const stakeTx = await agent.stake(stakeAmount);
    console.log('Staked TX:', stakeTx);

    if (stakeTx.status === 'success') {
      console.log('✅ Successfully staked SEI!');
      console.log('📄 You received iSEI tokens representing your stake');
      console.log('💰 Your rewards will auto-compound over time');
    }

    // Later, unstake if needed
    const unstakeAmount = '1.0';
    const unstakeTx = await agent.unstake(unstakeAmount);
    console.log('Unstaked TX:', unstakeTx);
  } catch (error) {
    console.error('Staking error:', error.message);

    if (error.message.includes('minimum amount')) {
      console.log('💡 Tip: Check minimum staking amount requirements');
    }
  }
}
```

<Info>
  **Silo Staking Details:**

  * **iSEI Token**: [Represents your staked SEI plus auto-compounded rewards](https://silostaking.gitbook.io/silo-staking/general-faq)
  * **No Unbonding Period**: [Immediate liquidity unlike traditional staking](https://medium.com/@nordicmoney22/unleashing-the-power-of-liquid-staking-on-sei-4a1d045232e1)
  * **5% Fee**: [Annual management fee of 5% on rewards](https://silostaking.gitbook.io/silo-staking/general-faq)
  * **MEV Benefits**: [Validators share MEV profits with stakers](https://www.silostaking.io/)
</Info>

#### d) Lending/Borrowing with Takara Protocol

```typescript theme={"dark"}
async function takaraLending() {
  try {
    const agent = new SeiAgentKit(process.env.SEI_PRIVATE_KEY, 'openai');

    // Mint tTokens (supply liquidity)
    const mintTx = await agent.mintTakara('USDC', '10');
    console.log('Mint Takara:', mintTx);

    if (mintTx.status === 'success') {
      console.log('✅ Successfully supplied USDC to Takara');
      console.log('💰 You are now earning interest on your supply');
    }

    // Borrow against collateral
    const borrowTx = await agent.borrowTakara('USDC', '5');
    console.log('Borrow Takara:', borrowTx);

    if (borrowTx.status === 'success') {
      console.log('✅ Successfully borrowed USDC from Takara');
      console.log('⚠️ Remember to monitor your collateral ratio');
    }

    // Repay borrowed amount
    const repayTx = await agent.repayTakara('USDC', '5');
    console.log('Repay Takara:', repayTx);
  } catch (error) {
    console.error('Takara error:', error.message);

    if (error.message.includes('collateral')) {
      console.log('💡 Tip: Add more collateral to maintain healthy ratio');
    } else if (error.message.includes('liquidity')) {
      console.log('💡 Tip: Insufficient liquidity in the pool');
    }
  }
}
```

#### e) Perpetual Trading with Citrex Markets

```typescript theme={"dark"}
async function citrexTrading() {
  try {
    const agent = new SeiAgentKit(process.env.SEI_PRIVATE_KEY, 'openai');

    // Deposit margin
    const depositAmount = '10';
    const depositTx = await agent.citrexDeposit(depositAmount);
    console.log('Citrex Deposit:', depositTx);

    if (depositTx.status === 'success') {
      console.log('✅ Successfully deposited margin to Citrex');
      console.log('⚡ You can now trade perpetuals with up to 20x leverage');
    }

    // Check available products
    const products = await agent.citrexGetProducts();
    console.log('Available Products:', products);

    // Withdraw margin when done
    const withdrawTx = await agent.citrexWithdraw('5');
    console.log('Citrex Withdraw:', withdrawTx);
  } catch (error) {
    console.error('Citrex error:', error.message);

    if (error.message.includes('margin')) {
      console.log('💡 Tip: Ensure sufficient margin for your positions');
    } else if (error.message.includes('leverage')) {
      console.log('💡 Tip: Reduce leverage to lower risk');
    }
  }
}
```

<Info>See `/tools/` for more advanced protocol integrations!</Info>

## Error Handling & Troubleshooting

### Common Error Types

<Info>
  **Comprehensive Error Handling Examples:**

  ```typescript theme={"dark"}
  // Robust error handling for all operations
  async function robustAgentOperation() {
    const agent = new SeiAgentKit(process.env.SEI_PRIVATE_KEY, 'openai');

    try {
      // Operation code here
    } catch (error) {
      // Network errors
      if (error.code === 'NETWORK_ERROR') {
        console.log('🌐 Network issue - retrying in 5 seconds...');
        await new Promise((resolve) => setTimeout(resolve, 5000));
        // Implement retry logic
      }

      // Insufficient funds
      if (error.message.includes('insufficient funds')) {
        console.log('💰 Insufficient funds for this operation');
        const balance = await agent.getERC20Balance();
        console.log('Current balance:', balance);
      }

      // Gas estimation errors
      if (error.message.includes('gas')) {
        console.log('⛽ Gas estimation failed - transaction may fail');
        console.log('Try reducing transaction amount or increasing gas limit');
      }

      // Contract-specific errors
      if (error.message.includes('revert')) {
        console.log('📋 Smart contract reverted the transaction');
        console.log('Check transaction parameters and try again');
      }
    }
  }
  ```
</Info>

### Transaction Monitoring

```typescript theme={"dark"}
async function monitorTransaction(txHash: string) {
  const maxRetries = 30; // 30 seconds max wait
  let retries = 0;

  while (retries < maxRetries) {
    try {
      // Check transaction status
      const receipt = await checkTransactionStatus(txHash);

      if (receipt.status === 'success') {
        console.log('✅ Transaction confirmed!');
        return receipt;
      } else if (receipt.status === 'failed') {
        console.log('❌ Transaction failed');
        return receipt;
      }

      // Wait and retry
      await new Promise((resolve) => setTimeout(resolve, 1000));
      retries++;
    } catch (error) {
      console.log(`⏳ Waiting for confirmation... (${retries}/${maxRetries})`);
      retries++;
      await new Promise((resolve) => setTimeout(resolve, 1000));
    }
  }

  console.log('⏰ Transaction timeout - check manually on Seiscan');
}
```

### Troubleshooting Guide

| Issue                 | Cause                   | Solution                    |
| --------------------- | ----------------------- | --------------------------- |
| "Insufficient funds"  | Low SEI balance         | Add more SEI to your wallet |
| "Transaction failed"  | Gas estimation error    | Reduce transaction amount   |
| "Network error"       | RPC connection issue    | Check RPC URL in .env       |
| "Slippage too high"   | Price moved during swap | Increase slippage tolerance |
| "Invalid private key" | Incorrect key format    | Verify private key format   |

**Debug Commands:**

```bash theme={"dark"}
# Check network connection
curl -X POST https://evm-rpc.sei-apis.com \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Verify wallet balance
# Use Seiscan: https://seiscan.io/
```

### 5. Advanced Features & Customization

#### Multi-Protocol Strategy Example

```typescript theme={"dark"}
async function deFiStrategy() {
  const agent = new SeiAgentKit(process.env.SEI_PRIVATE_KEY, 'openai');

  try {
    // 1. Swap SEI for USDC via Symphony
    console.log('Step 1: Swapping SEI for USDC...');
    const swapTx = await agent.swap('10', '0x0', 'usdc_address');

    // 2. Supply USDC to Takara for lending
    console.log('Step 2: Supplying USDC to Takara...');
    const supplyTx = await agent.mintTakara('USDC', '5');

    // 3. Stake remaining SEI via Silo
    console.log('Step 3: Staking SEI via Silo...');
    const stakeTx = await agent.stake('5');

    // 4. Monitor positions
    console.log('Step 4: Monitoring positions...');
    const balance = await agent.getERC20Balance();

    console.log('✅ Multi-protocol strategy executed successfully!');
    console.log('📊 Final balance:', balance);
  } catch (error) {
    console.error('Strategy failed:', error.message);
    // Implement rollback logic if needed
  }
}
```

#### Monitoring & Alerts:

```typescript theme={"dark"}
// Set up monitoring for your agent
async function setupMonitoring() {
  const agent = new SeiAgentKit(process.env.SEI_PRIVATE_KEY, 'openai');

  // Monitor balance changes
  setInterval(async () => {
    const balance = await agent.getERC20Balance();
    if (parseFloat(balance) < 1.0) {
      console.warn('⚠️ Low balance alert:', balance);
      // Send alert to your monitoring system
    }
  }, 60000); // Check every minute

  // Monitor failed transactions
  agent.on('transactionFailed', (error) => {
    console.error('Transaction failed:', error);
    // Log to monitoring system
  });
}
```

#### Custom Protocol Integration

To extend the Cambrian Agent Kit for your own protocol, please follow this repository which explains how to add plugins to the agent kit so that it can support your protocol: [Cambrian Agents Plugin Guide](https://github.com/CambrianAgents/cambrian-plugin)

---

URL: https://docs.sei.io/ai/agentic-wallets

# Agentic Wallets

> Build AI agents with secure, programmable wallets on Sei using Coinbase AgentKit or Privy server wallets. Includes setup guides, policy engines, and a full feature comparison.

Agentic wallets give AI agents the ability to hold funds, sign transactions, and interact with smart contracts autonomously — without exposing private keys to the agent or the LLM. This page covers the two leading solutions that work on Sei today: **Coinbase AgentKit** and **Privy server wallets**.

<Info>
  Both platforms support Sei as an EVM-compatible chain. No special integration is required — you point the wallet provider at Sei's RPC and chain ID and everything works out of the box.
</Info>

## How It Works

An agentic wallet sits between your AI agent and the blockchain:

1. **Agent decides** — The LLM reasons about what onchain action to take (e.g. "send 5 USDC to 0x...").
2. **SDK prepares** — The wallet SDK constructs and validates the transaction.
3. **Policy check** — The policy engine evaluates the transaction against spending limits, allowlists, and other guardrails.
4. **TEE signs** — The private key, isolated in a Trusted Execution Environment, signs the transaction. The key is never exposed to the agent.
5. **Broadcast** — The signed transaction is submitted to Sei's EVM RPC.

```
┌─────────┐     ┌───────────┐     ┌──────────────┐     ┌─────────┐     ┌──────────┐
│ LLM /   │────▶│ Wallet    │────▶│ Policy       │────▶│ TEE     │────▶│ Sei EVM  │
│ Agent   │     │ SDK       │     │ Engine       │     │ Signer  │     │ RPC      │
└─────────┘     └───────────┘     └──────────────┘     └─────────┘     └──────────┘
```

## Quick Comparison

| Dimension            | Coinbase AgentKit                                                                                   | Privy Server Wallets                                |
| -------------------- | --------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| **Type**             | Open-source SDK + wallet infra                                                                      | Wallet-as-a-service API                             |
| **Key isolation**    | Self-custodial on Sei (bring-your-own key via Viem). CDP's TEE-managed signer does not support Sei. | TEE + Shamir secret sharing                         |
| **Sei support**      | Via `ViemWalletProvider` (TS) or `EthAccountWalletProvider` (Python)                                | Via CAIP-2 `eip155:1329`                            |
| **Policy engine**    | Spending limits, address/contract allowlists, network restrictions                                  | All of the above + time-based controls, key quorums |
| **Built-in actions** | 40+ action providers (wallet, ERC-20, ERC-721, Pyth on Sei; many others Base/Ethereum-only)         | Wallet operations only (create, sign, send)         |
| **AI frameworks**    | LangChain, Vercel AI SDK, OpenAI Agents SDK, MCP                                                    | LangChain (`langchain-privy`)                       |
| **Server SDKs**      | TypeScript, Python                                                                                  | TypeScript, Python, Java, Rust, Go + REST API       |
| **Open source**      | Yes (MIT)                                                                                           | Partial (`langchain-privy` is OSS)                  |
| **Pricing**          | Free SDK; CDP wallets \$0.005/op (5K free/mo)                                                       | Free 50K sigs/mo; paid tiers from \$299/mo          |

**Use both together:** AgentKit ships with a built-in `PrivyWalletProvider`, so you can combine Privy's policy engine with AgentKit's 40+ action providers.

***

## Coinbase AgentKit on Sei

[AgentKit](https://github.com/coinbase/agentkit) is Coinbase's open-source toolkit for giving AI agents crypto wallets and onchain capabilities. It is framework-agnostic (LangChain, Vercel AI SDK, OpenAI Agents SDK, MCP) and wallet-agnostic (CDP wallets, Privy, Viem, and more).

### Architecture

AgentKit is organized around three concepts:

* **Wallet Providers** — Abstraction over different wallet implementations. For Sei, use `ViemWalletProvider` (TypeScript) or `EthAccountWalletProvider` (Python).
* **Action Providers** — Units of onchain functionality (ERC-20 transfers, ERC-721 ops, Pyth price feeds, etc.). Generic EVM providers work on Sei; providers with hard-coded chain allowlists (e.g. `x402ActionProvider`, `wethActionProvider`, CDP-managed ones) do not — see the support matrix below.
* **Framework Extensions** — Adapters that turn AgentKit actions into tools for your AI framework of choice.

### Prerequisites

* Node.js v22+ (TypeScript) or Python 3.10+
* A [CDP Secret API Key](https://portal.cdp.coinbase.com/) (for CDP wallet providers; not required for Viem)
* A funded wallet on Sei

### Setup

<Tabs>
  <Tab title="TypeScript">
    <Steps>
      <Step title="Install packages">
        ```bash theme={"dark"}
        npm install @coinbase/agentkit @coinbase/agentkit-langchain viem
        ```
      </Step>

      <Step title="Create the wallet provider and AgentKit">
        Viem ships with `sei` (id `1329`) and `seiTestnet` (id `1328`) out of the box, so you can import them directly from `viem/chains`.

        ```typescript theme={"dark"}
        import { AgentKit, ViemWalletProvider, walletActionProvider, erc20ActionProvider } from '@coinbase/agentkit';
        import { createWalletClient, http } from 'viem';
        import { privateKeyToAccount } from 'viem/accounts';
        import { sei } from 'viem/chains';

        // Create a Viem wallet client pointed at Sei
        const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
        const client = createWalletClient({
          account,
          chain: sei,
          transport: http('https://evm-rpc.sei-apis.com'),
        });

        // Wrap it in AgentKit
        const walletProvider = new ViemWalletProvider(client);
        const agentKit = await AgentKit.from({
          walletProvider,
          actionProviders: [
            walletActionProvider(),
            erc20ActionProvider(),
            // Add more action providers as needed
          ],
        });
        ```
      </Step>

      <Step title="Wire into LangChain">
        ```typescript theme={"dark"}
        import { getLangChainTools } from '@coinbase/agentkit-langchain';
        import { ChatOpenAI } from '@langchain/openai';
        import { createReactAgent } from '@langchain/langgraph/prebuilt';

        const tools = await getLangChainTools(agentKit);
        const model = new ChatOpenAI({ model: 'gpt-4o' });

        const agent = createReactAgent({
          llm: model,
          tools,
          messageModifier:
            'You are an AI agent operating on the Sei blockchain. You can check balances, transfer tokens, and interact with smart contracts.',
        });

        // Run the agent
        const result = await agent.invoke({
          messages: [{ role: 'user', content: 'What is my SEI balance?' }],
        });
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Python">
    <Steps>
      <Step title="Install packages">
        ```bash theme={"dark"}
        pip install coinbase-agentkit coinbase-agentkit-langchain
        ```
      </Step>

      <Step title="Create the wallet provider">
        ```python theme={"dark"}
        from coinbase_agentkit import (
            AgentKit,
            AgentKitConfig,
            EthAccountWalletProvider,
            EthAccountWalletProviderConfig,
        )
        from eth_account import Account

        account = Account.from_key("YOUR_PRIVATE_KEY")

        wallet_provider = EthAccountWalletProvider(
            config=EthAccountWalletProviderConfig(
                account=account,
                chain_id=1329,  # Sei mainnet
                rpc_url="https://evm-rpc.sei-apis.com",
            )
        )

        agent_kit = AgentKit(AgentKitConfig(wallet_provider=wallet_provider))
        ```
      </Step>

      <Step title="Wire into LangChain">
        ```python theme={"dark"}
        from coinbase_agentkit_langchain import get_langchain_tools
        from langchain_openai import ChatOpenAI
        from langgraph.prebuilt import create_react_agent

        tools = get_langchain_tools(agent_kit)
        model = ChatOpenAI(model="gpt-4o")

        agent = create_react_agent(
            model,
            tools=tools,
            state_modifier="You are an AI agent on the Sei blockchain.",
        )

        result = agent.invoke({
            "messages": [{"role": "user", "content": "What is my SEI balance?"}]
        })
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

### Available Action Providers on Sei

Not every AgentKit action provider works on Sei — some are chain-specific. Here's what you can use:

| Action Provider          | Works on Sei | Notes                                                                                                                                                                                                                                                                |
| ------------------------ | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `walletActionProvider`   | Yes          | Balance, transfers, native SEI operations                                                                                                                                                                                                                            |
| `erc20ActionProvider`    | Yes          | Any ERC-20 token (USDC, WSEI, etc.)                                                                                                                                                                                                                                  |
| `erc721ActionProvider`   | Yes          | NFT minting, transfers                                                                                                                                                                                                                                               |
| `pythActionProvider`     | Yes          | Pyth price feeds via Hermes (off-chain, chain-agnostic)                                                                                                                                                                                                              |
| `wethActionProvider`     | No           | Hard-coded WETH addresses; no WSEI entry. Use `erc20ActionProvider` against Sei's WSEI contract instead.                                                                                                                                                             |
| `x402ActionProvider`     | No           | Provider's `SUPPORTED_NETWORKS` allowlist is limited to `base-mainnet`, `base-sepolia`, `solana-mainnet`, and `solana-devnet`. The x402 protocol itself is chain-agnostic — write a custom action provider or call the facilitator directly if you need x402 on Sei. |
| `cdpApiActionProvider`   | No           | Requires a Coinbase `networkId`; Sei isn't in AgentKit's chain map.                                                                                                                                                                                                  |
| `morphoActionProvider`   | No           | Morpho contracts not deployed on Sei                                                                                                                                                                                                                                 |
| `moonwellActionProvider` | No           | Moonwell contracts not deployed on Sei                                                                                                                                                                                                                               |

<Info>
  For Sei-native DeFi actions (swaps on Symphony/DragonSwap, staking via Silo, lending via Takara), use the [Cambrian Agent Kit](/ai/cambrian-agent-kit) alongside AgentKit, or write custom action providers.
</Info>

### Known Quirks on Sei

Verified by running AgentKit `0.10.4` against Sei testnet (`chain 1328`). These quirks sit in AgentKit's network and action-provider layer and apply to **both** `ViemWalletProvider` and `PrivyWalletProvider`:

* **Balances are labeled "ETH" in action output.** `walletActionProvider` hard-codes the native-currency symbol, so `get_wallet_details` returns strings like `Native Balance: 512993.50 ETH` and `native_transfer` responses say `Transferred 0.05 ETH to 0x...` even on Sei. Signing and arithmetic are unaffected — it's a display-only quirk. If the LLM will quote balances or transfer confirmations to users, add a post-processing step or a system-prompt instruction to rewrite `ETH` → `SEI` when `chain_id == 1329 || 1328`.
* **`networkId` is `undefined`.** Coinbase's internal `CHAIN_ID_TO_NETWORK_ID` map only includes Ethereum, Polygon, Base, Arbitrum, and Optimism (mainnet + testnet). Sei's chain IDs aren't in it, so `walletProvider.getNetwork()` returns `{ protocolFamily: 'evm', chainId: '1328', networkId: undefined }`. This is harmless for signing/sending, but **any action provider that branches on `networkId`** will refuse to run on Sei. In practice, `AgentKit.from({...})` prints a warning like `The following action providers are not supported on the current network and will be unavailable: weth, x402` and silently drops them — if you expect an action and it's missing from `agentKit.getActions()`, check this warning first.

### CDP-Managed Wallets and Sei

AgentKit's `CdpEvmWalletProvider` (CDP-managed server wallets with built-in policies) is currently scoped to `base`, `base-sepolia`, `ethereum`, `ethereum-sepolia`, `polygon`, `arbitrum`, and `optimism` — **Sei is not a supported network**.

For managed cloud custody with a policy engine on Sei, use one of:

* **Privy server wallets** (below) — TEE-isolated keys with a policy engine that works on any EVM chain, including Sei.
* **AgentKit + Privy combined** — use `PrivyWalletProvider` inside AgentKit to keep the 40+ action providers while delegating custody and policy enforcement to Privy. See [Using AgentKit with Privy (Combined)](#using-agentkit-with-privy-combined) below.

If you only need self-custodial keys (no TEE, you hold the private key), use `ViemWalletProvider` as shown above and enforce limits in your own application logic.

***

## Privy Server Wallets on Sei

[Privy](https://docs.privy.io/) provides wallet-as-a-service infrastructure for AI agents. Server wallets are programmatically managed wallets designed for backend use — no user interaction required. Keys are isolated in TEEs with Shamir secret sharing and never leave secure enclaves.

### Prerequisites

* A [Privy account](https://dashboard.privy.io/) with an App ID and App Secret
* An authorization keypair (generated in the Privy dashboard)

### Setup

<Tabs>
  <Tab title="REST API">
    <Steps>
      <Step title="Create a wallet">
        ```bash theme={"dark"}
        curl --request POST https://api.privy.io/v1/wallets \
          -u "<your-app-id>:<your-app-secret>" \
          -H "privy-app-id: <your-app-id>" \
          -H 'Content-Type: application/json' \
          -d '{
            "chain_type": "ethereum",
            "policy_ids": ["your_policy_id"]
          }'
        ```

        Response:

        ```json theme={"dark"}
        {
          "id": "wallet_abc123",
          "address": "0x1234...abcd",
          "chain_type": "ethereum",
          "policy_ids": ["your_policy_id"]
        }
        ```
      </Step>

      <Step title="Send a transaction on Sei">
        Use `eip155:1329` (CAIP-2 format) to target Sei mainnet:

        ```bash theme={"dark"}
        curl --request POST https://api.privy.io/v1/wallets/wallet_abc123/rpc \
          -u "<your-app-id>:<your-app-secret>" \
          -H "privy-app-id: <your-app-id>" \
          -H "privy-authorization-signature: <authorization-signature>" \
          -H 'Content-Type: application/json' \
          -d '{
            "method": "eth_sendTransaction",
            "caip2": "eip155:1329",
            "params": {
              "transaction": {
                "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
                "value": "0x2386F26FC10000",
                "chain_id": 1329
              }
            }
          }'
        ```
      </Step>

      <Step title="Sign a message">
        ```bash theme={"dark"}
        curl --request POST https://api.privy.io/v1/wallets/wallet_abc123/rpc \
          -u "<your-app-id>:<your-app-secret>" \
          -H "privy-app-id: <your-app-id>" \
          -H "privy-authorization-signature: <authorization-signature>" \
          -H 'Content-Type: application/json' \
          -d '{
            "method": "personal_sign",
            "caip2": "eip155:1329",
            "params": {
              "message": "Hello from Sei"
            }
          }'
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Node.js SDK">
    <Steps>
      <Step title="Install the SDK">
        ```bash theme={"dark"}
        npm install @privy-io/server-auth
        ```
      </Step>

      <Step title="Create a wallet and send a transaction">
        ```typescript theme={"dark"}
        import { PrivyClient } from '@privy-io/server-auth';
        import { parseEther } from 'viem';

        const privy = new PrivyClient('<your-app-id>', '<your-app-secret>', {
          walletApi: { authorizationPrivateKey: process.env.PRIVY_AUTH_KEY },
        });

        // Create a server wallet
        const wallet = await privy.walletApi.createWallet({ chainType: 'ethereum' });
        console.log('Wallet address:', wallet.address);

        // Send a transaction on Sei
        // NOTE: `value` must be a hex string — Privy's request signer can't
        // serialize a BigInt, so don't pass `parseEther(...)` directly.
        const { hash } = await privy.walletApi.ethereum.sendTransaction({
          walletId: wallet.id,
          caip2: 'eip155:1329', // Sei mainnet
          transaction: {
            to: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
            value: '0x' + parseEther('0.01').toString(16),
            chainId: 1329,
          },
        });
        console.log('Transaction hash:', hash);
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Python SDK">
    <Steps>
      <Step title="Install the SDK">
        ```bash theme={"dark"}
        pip install privy-client
        ```
      </Step>

      <Step title="Create a wallet and send a transaction">
        ```python theme={"dark"}
        from privy import PrivyAPI

        client = PrivyAPI(app_id="<your-app-id>", app_secret="<your-app-secret>")

        # Create a server wallet
        wallet = client.wallets.create(chain_type="ethereum")
        print(f"Wallet address: {wallet.address}")

        # Send a transaction on Sei
        result = client.wallets.rpc(
            wallet_id=wallet.id,
            method="eth_sendTransaction",
            caip2="eip155:1329",  # Sei mainnet
            params={
                "transaction": {
                    "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
                    "value": "0x2386F26FC10000",
                    "chain_id": 1329,
                }
            },
        )
        print(f"Transaction hash: {result.hash}")
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

### Known Quirks on Sei (Privy)

Verified by running `@privy-io/server-auth` `1.32.5` against Sei testnet (`eip155:1328`):

* **`value` must be a hex string, not a `BigInt`.** Privy's request signer uses RFC 8785 JSON canonicalization (`canonicalize`), which throws `TypeError: Do not know how to serialize a BigInt` if you pass a `BigInt` in any field of the `transaction` object. Convert viem's `parseEther(...)` output with `'0x' + parseEther('0.01').toString(16)` before sending.
* **`authorizationKeyIds` on `createWallet` expects the public-key registration ID, not the dashboard key ID.** Passing the ID shown next to a key in the Privy dashboard can fail with `400 Invalid authorization key IDs`. If you only need an app-owned wallet (app credentials + `authorizationPrivateKey` for request signing), omit `authorizationKeyIds` — the wallet is still fully operable.

### Privy with LangChain

Privy publishes a LangChain integration (`langchain-privy`) that exposes wallet operations as a single LangChain tool. The tool reads `PRIVY_APP_ID` and `PRIVY_APP_SECRET` from the environment and is bound directly to the LLM:

```python theme={"dark"}
import os
from langchain_privy import PrivyWalletTool
from langchain_openai import ChatOpenAI

os.environ["PRIVY_APP_ID"] = "<your-app-id>"
os.environ["PRIVY_APP_SECRET"] = "<your-app-secret>"

tool = PrivyWalletTool()
print(f"Wallet: {tool.wallet_address}")

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
llm_with_tools = llm.bind_tools([tool])

response = llm_with_tools.invoke("What is my wallet address?")
```

<Warning>
  As of `langchain-privy@0.1.0`, the library's `Chain` enum does not include Sei — the built-in tool only targets Ethereum, Base, Optimism, Arbitrum, Polygon, Zora, Avalanche, BSC, Celo, Linea, Solana, and Bitcoin. For Sei, either:

  * Call Privy's REST API / server-auth SDK directly with `caip2: eip155:1329` (shown above), or
  * Use AgentKit's `PrivyWalletProvider` with a LangChain adapter (`@coinbase/agentkit-langchain`) — see the [Combined](#using-agentkit-with-privy-combined) section below.
</Warning>

### Privy Policy Engine

Privy's policy engine evaluates policies server-side before signing. Each rule pairs an `ALLOW`/`DENY` action with an RPC `method` and a list of `conditions` on transaction fields. Attach one or more policies to a wallet via `updateWallet`.

<Warning>
  **Privy's engine is default-deny.** A request is allowed only when at least one `ALLOW` rule matches and no `DENY` rule matches. A policy built from `DENY`-only rules blocks every transaction — including ones you expect to pass. Always start from an explicit `ALLOW` rule that describes the happy path, then layer `DENY` rules on top.
</Warning>

```typescript theme={"dark"}
// "Cap sends at 10 SEI and block a specific address."
// Rule 1 (ALLOW) defines the happy path; without it, every request is denied.
// Rule 2 (DENY) carves a specific hole in that allow.
const policy = await privy.walletApi.createPolicy({
  name: 'sei-agent-policy',
  version: '1.0',
  chainType: 'ethereum',
  rules: [
    {
      name: 'Allow sends up to 10 SEI',
      action: 'ALLOW',
      method: 'eth_sendTransaction',
      conditions: [
        {
          fieldSource: 'ethereum_transaction',
          field: 'value',
          operator: 'lte',
          value: '10000000000000000000', // 10 SEI in wei
        },
      ],
    },
    {
      name: 'Deny sends to blocklisted address',
      action: 'DENY',
      method: 'eth_sendTransaction',
      conditions: [
        {
          fieldSource: 'ethereum_transaction',
          field: 'to',
          operator: 'in',
          value: ['0xdEAD000000000000000042069420694206942069'],
        },
      ],
    },
  ],
});

// Attach policy to wallet
await privy.walletApi.updateWallet({
  id: wallet.id,
  policyIds: [policy.id],
});
```

<Info>
  Conditions support the `eq`, `gt`, `gte`, `lt`, `lte`, and `in` operators against `ethereum_transaction` fields (`to`, `value`) or `ethereum_calldata` fields. Operand order is `tx_field <operator> rule_value` — e.g. `operator: 'lte'` with `value: '10000000000000000000'` means "transaction value ≤ 10 SEI". `method` must be `eth_sendTransaction` or `eth_signTransaction`. Chain restriction is not a policy condition — enforce `caip2: 'eip155:1329'` at the call site to keep an agent on Sei.
</Info>

Privy also offers features beyond the policy engine:

* **Key quorums** — require multiple authorization keys to approve high-value transactions
* **Webhook notifications** — get notified of all wallet activity (works chain-agnostically)

***

## Using AgentKit with Privy (Combined)

AgentKit includes a built-in `PrivyWalletProvider`, so you can use Privy's wallet infrastructure and policy engine as the backend while using AgentKit's 40+ action providers for onchain operations.

Because of the `authorizationKeyIds` quirk noted above, the simplest working pattern is to create the wallet once via the Privy SDK (or the dashboard) and then hand the resulting `walletId` to AgentKit:

```typescript theme={"dark"}
import { AgentKit, PrivyWalletProvider, walletActionProvider, erc20ActionProvider } from '@coinbase/agentkit';
import { PrivyClient } from '@privy-io/server-auth';

// Step 1 — create (or look up) a server wallet via the Privy SDK.
// Omit authorizationKeyIds here; attach policies with updateWallet if needed.
const privy = new PrivyClient(process.env.PRIVY_APP_ID!, process.env.PRIVY_APP_SECRET!, {
  walletApi: { authorizationPrivateKey: process.env.PRIVY_AUTH_KEY },
});
const wallet = await privy.walletApi.createWallet({ chainType: 'ethereum' });

// Step 2 — wrap the existing wallet in AgentKit's PrivyWalletProvider.
const walletProvider = await PrivyWalletProvider.configureWithWallet({
  appId: process.env.PRIVY_APP_ID!,
  appSecret: process.env.PRIVY_APP_SECRET!,
  chainId: '1329', // Sei mainnet
  walletId: wallet.id,
  authorizationPrivateKey: process.env.PRIVY_AUTH_KEY,
});

const agentKit = await AgentKit.from({
  walletProvider,
  actionProviders: [
    walletActionProvider(),
    erc20ActionProvider(),
  ],
});
```

This gives you the best of both worlds: Privy's fine-grained policies and key quorums with AgentKit's rich action library.

<Warning>
  If you call `PrivyWalletProvider.configureWithWallet` **without** a `walletId`, AgentKit will attempt to create a new wallet for you and pass `authorizationKeyId` through to Privy — which hits the same `400 Invalid authorization key IDs` failure described in Privy's Known Quirks. Always pre-create the wallet and pass `walletId`.
</Warning>

***

## Feature Matrix

### Wallet Creation & Key Management

| Capability                          | Coinbase AgentKit                                                                                                                            | Privy                                         |
| ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- |
| Programmatic wallet creation on Sei | Yes — self-custodial via `ViemWalletProvider` (you hold the key). CDP-managed server wallets do not currently support Sei.                   | Yes — Server wallets on any EVM               |
| TEE-secured key isolation on Sei    | No — CDP's TEE signer is scoped to Base/Ethereum/Polygon/Arbitrum/Optimism. Use Privy (standalone or via `PrivyWalletProvider` in AgentKit). | Yes — TEE + key sharding                      |
| Managed cloud custody on Sei        | No via CDP. Yes via `PrivyWalletProvider`.                                                                                                   | Yes — Server wallets with `eip155:1329`       |
| Multi-party key quorum              | No                                                                                                                                           | Yes — Authorization key quorums via dashboard |
| Key export / portability            | Yes                                                                                                                                          | Yes                                           |

### Policy Engine & Guardrails

| Capability                             | Coinbase AgentKit                                                                                    | Privy                          |
| -------------------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------ |
| Spending limits (per-tx) on Sei        | Only via app-level checks with `ViemWalletProvider`. CDP's `ethValue` policy doesn't apply on Sei.   | Yes — Policy engine, any chain |
| Contract / address allowlisting on Sei | Only via app-level checks with `ViemWalletProvider`. CDP's `evmAddress` policy doesn't apply on Sei. | Yes — Contract allowlist rules |
| Network restriction policies on Sei    | N/A — CDP networkIds don't include Sei                                                               | Yes — Chain restrictions       |
| Time-based access controls             | No                                                                                                   | Yes                            |
| Transaction simulation                 | No                                                                                                   | No — Needs Sei-specific RPC    |

### Gas & Transaction Management

| Capability                              | Coinbase AgentKit                     | Privy                                             |
| --------------------------------------- | ------------------------------------- | ------------------------------------------------- |
| Gasless / sponsored transactions on Sei | No — Gasless is Base-only             | No — Requires Sei-native paymaster                |
| Smart wallet (ERC-4337) on Sei          | No — Smart Accounts don't include Sei | No — Possible via ZeroDev or Biconomy integration |
| Batch transactions on Sei               | No — Requires Smart Accounts          | Yes                                               |
| Basic send / transfer on Sei            | Yes                                   | Yes                                               |
| ERC-20 token operations on Sei          | Yes — `erc20ActionProvider`           | Yes — Standard EVM ops                            |

### Agentic DeFi Actions

| Capability                     | Coinbase AgentKit                                                                          | Privy |
| ------------------------------ | ------------------------------------------------------------------------------------------ | ----- |
| Token swaps on Sei DEXs        | No — Built-in swap providers (Jupiter, 0x, Sushi, Enso) don't route Sei DEXs               | No    |
| Yield / lending on Sei         | No — Built-in lending providers (Morpho, Moonwell, Compound, Yelay) aren't deployed on Sei | No    |
| Liquidity provision on Sei     | No                                                                                         | No    |
| Cross-chain bridge to/from Sei | No — Sei not a listed Across route                                                         | No    |
| Pyth oracle price feeds        | Yes — `pythActionProvider` works on Sei                                                    | No    |

<Info>
  For Sei-native DeFi actions, use the [Cambrian Agent Kit](/ai/cambrian-agent-kit) which includes built-in integrations for Symphony, DragonSwap, Silo, Takara, and Citrex.
</Info>

### x402 & Machine-to-Machine Payments

| Capability                    | Coinbase AgentKit                                                                                              | Privy                                        |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
| x402 protocol support on Sei  | No via built-in `x402ActionProvider` (allowlist is Base + Solana only) — possible via a custom action provider | Yes — Works wherever agent holds stablecoins |
| Agent-to-agent USDC transfers | Yes — ERC-20 transfers with Sei USDC                                                                           | Yes — Server wallet transfers                |
| Stablecoin operations on Sei  | Yes — `erc20ActionProvider` + Sei USDC                                                                         | Yes — Standard ERC-20 ops                    |

### Developer Experience

| Capability                        | Coinbase AgentKit                         | Privy                                     |
| --------------------------------- | ----------------------------------------- | ----------------------------------------- |
| MCP server integration            | Yes — AgentKit MCP framework extension    | No                                        |
| LangChain / Vercel AI SDK         | Yes — Framework extensions for both       | Yes — `langchain-privy`                   |
| OpenAI Agents SDK                 | Yes — Native extension                    | No                                        |
| Webhook / event monitoring on Sei | No — Webhooks for supported networks only | Yes — Chain-agnostic webhooks             |
| Multi-language SDKs               | TypeScript, Python                        | TypeScript, Python, Java, Rust, Go + REST |

***

## Other Agentic Wallet Solutions

While Coinbase AgentKit and Privy are the most mature options for Sei, several other platforms support agentic wallet use cases:

| Platform                                                                               | Approach                                                           | Sei Support                | Best For                                        |
| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | -------------------------- | ----------------------------------------------- |
| [Turnkey](https://docs.turnkey.com/products/embedded-wallets/features/agentic-wallets) | TEE-based key isolation, sub-100ms signing, granular policies      | Yes (any EVM)              | Enterprise agents needing fine-grained policies |
| [Lit Protocol](https://developer.litprotocol.com/)                                     | Decentralized key management (DKG), programmable key pairs as NFTs | Yes (any EVM)              | Decentralized, user-owned agent delegation      |
| [Dynamic](https://www.dynamic.xyz/ecosystems/sei)                                      | MPC or smart contract wallets, strong onboarding UX                | Yes (explicit Sei support) | Apps serving both humans and agents             |
| [thirdweb](https://thirdweb.com/)                                                      | Backend wallets + account abstraction, session keys                | Yes (any EVM)              | Broadest AI framework support (6+ frameworks)   |
| [Openfort](https://www.openfort.io/solutions/ai-agents)                                | TEE server wallets, sub-125ms signing, 25+ EVM chains              | Yes (any EVM)              | Gaming and high-throughput agent workloads      |

***

## Sei Network Configuration Reference

Use these values when configuring any agentic wallet provider for Sei:

| Parameter          | Mainnet                          | Testnet                                  |
| ------------------ | -------------------------------- | ---------------------------------------- |
| **Chain ID**       | `1329`                           | `1328`                                   |
| **Chain ID (hex)** | `0x531`                          | `0x530`                                  |
| **CAIP-2**         | `eip155:1329`                    | `eip155:1328`                            |
| **RPC URL**        | `https://evm-rpc.sei-apis.com`   | `https://evm-rpc-testnet.sei-apis.com`   |
| **Currency**       | SEI (18 decimals)                | SEI (18 decimals)                        |
| **Block Explorer** | [seiscan.io](https://seiscan.io) | [seiscan.io](https://testnet.seiscan.io) |
| **Finality**       | \~400ms                          | \~400ms                                  |

<Warning>
  **Security Reminders:**

  * Never expose private keys or authorization secrets to the LLM/agent process.
  * Always use dedicated wallets for agent operations — never your main wallet.
  * Start with testnet (`eip155:1328`) before deploying to mainnet.
  * Set spending limits and contract allowlists via the policy engine before going live.
  * Monitor agent wallet activity via block explorers or webhook notifications.
</Warning>

---

URL: https://docs.sei.io/ai/x402

# x402 Protocol on Sei

> Implement HTTP micropayments on Sei using the x402 protocol for API monetization and digital services.

x402 Protocol brings HTTP micro payments to Sei, enabling you to monetize APIs, premium content, and digital services with instant, low-cost payments. Whether you're building AI APIs, data feeds, or premium content platforms, x402 makes it simple to add payment gates to any HTTP endpoint.

**Works with Sei's advantages:** Sei's fast finality, low gas, and EVM compatibility make it perfect for micro payments. x402 leverages these features to enable seamless payment flows that complete in milliseconds.

<Info>
  **Why x402 on Sei?**

  * **Fast & Cheap Payments**: Sei's 400ms finality and low gas make micropayments practical. Perfect for pay-per-request APIs and streaming content.
  * **EVM Compatible**: Use familiar tools like Viem, Ethers.js, and Hardhat. All existing Ethereum tooling works seamlessly on Sei.
  * **Built-in Wallet Support**: Integrates with Sei wallets, MetaMask, and any EIP-6963 compatible wallet for smooth user experiences.
</Info>

## Use Cases on Sei

The x402 protocol enables a wide range of monetization strategies for web services and APIs:

* **AI & Machine Learning Services**: Per-inference pricing for LLM APIs, image generation, and data processing.
* **Premium Content & Media**: Pay-per-view articles, videos, and subscription gates.
* **Real-Time Data & APIs**: Market data feeds, weather and IoT data monetization.
* **Infrastructure & CDN Services**: Bandwidth metering and storage payments.

## sei-js Integration

The `sei-js` library provides a suite of packages to simplify working with x402 on Sei. You can find more details in the [sei-js x402 repository](https://github.com/sei-protocol/sei-x402).

### Core Concepts

* [**Protocol Overview**](https://github.com/sei-protocol/sei-x402/blob/main/docs/core-concepts/client-server.md): Learn about the architecture of x402.
* [**Quickstart Guide**](https://github.com/sei-protocol/sei-x402/blob/main/docs/getting-started/quickstart-for-sellers.md): Build your first paid API.
* [**Facilitators**](https://github.com/sei-protocol/sei-x402/blob/main/docs/core-concepts/facilitator.md): Understanding payment facilitators.
* [**Client Integration**](https://github.com/sei-protocol/sei-x402/blob/main/docs/getting-started/quickstart-for-buyers.md): How to integrate x402 in your frontend.

### Available Packages

* [**x402**](https://www.npmjs.com/package/@sei-js/x402): The core protocol implementation.
* [**x402-fetch**](https://www.npmjs.com/package/@sei-js/x402-fetch): A fetch wrapper for making x402-compliant requests.
* [**x402-axios**](https://www.npmjs.com/package/@sei-js/x402-axios): Axios interceptors for x402 payments.
* [**x402-express**](https://www.npmjs.com/package/@sei-js/x402-express): Express middleware for serving paid content.
* [**x402-hono**](https://www.npmjs.com/package/@sei-js/x402-hono): Middleware for Hono applications.
* [**x402-next**](https://www.npmjs.com/package/@sei-js/x402-next): Components and utilities for Next.js applications.

These packages help streamline both the client-side (paying) and server-side (charging) aspects of the protocol.

***

## Axiom Kit Integration

While you can build x402 integrations using standard tools and the libraries mentioned above, you can also optionally use Axiom Kit for a more agent-centric approach. This guide demonstrates an end-to-end x402 (HTTP 402 Payment Required) micropayment flow on the Sei testnet using AxiomKit.

### What is x402?

x402 is an open standard protocol for internet-native payments that enables users to send and receive payments globally in a simple, secure, and interoperable manner. The protocol leverages the HTTP 402 status code ("Payment Required") to facilitate blockchain-based micropayments directly through HTTP requests.

#### Key Features of x402:

* **HTTP-Native**: Uses standard HTTP status codes and headers
* **Blockchain Integration**: Supports multiple blockchain networks
* **Real-time Settlement**: Enables instant payment verification
* **Interoperable**: Works across different payment schemes and networks
* **Micropayment Support**: Designed for small, frequent transactions

### Protocol Overview

The x402 protocol follows a specific flow:

1. **Initial Request**: Client makes a request to a protected resource
2. **402 Response**: Server responds with HTTP 402 and payment requirements
3. **Payment Execution**: Client executes blockchain payment
4. **Payment Proof**: Client includes payment proof in subsequent request
5. **Resource Access**: Server verifies payment and grants access

### Axiom Integration

Axiom is a blockchain interaction framework that provides tools and libraries for building decentralized applications. In this implementation, Axiom integrates with x402 to enable seamless blockchain payments within Sei network applications.

#### Axiom Components Used:

* **@axiomkit/core**: Core framework for building blockchain agents
* **@axiomkit/sei**: Sei blockchain integration
* **AxiomSeiWallet**: Wallet management for Sei transactions
* **Context and Actions**: Framework for building interactive blockchain agents

### Sei Blockchain Implementation

This implementation uses the Sei testnet for x402 payments with the following configuration:

#### Network Configuration

```typescript theme={"dark"}
export const X402_CONFIG = {
  network: 'sei-testnet',
  chainId: 1328,
  asset: 'USDC',
  assetAddress: '0x4fCF1784B31630811181f670Aea7A7bEF803eaED', // Sei Testnet USDC
  assetDecimals: 6,
  recipient: '0x9dC2aA0038830c052253161B1EE49B9dD449bD66',
  rpcUrl: 'https://evm-rpc-testnet.sei-apis.com'
};
```

### Technical Architecture

The x402 implementation consists of several key components:

#### 1. Payment Challenge Generation

```typescript theme={"dark"}
function generatePaymentChallenge() {
  const reference = `sei-${Date.now()}-${Math.random().toString(36).substring(7)}`;
  const amountInUnits = parseUnits('0.001', X402_CONFIG.assetDecimals);

  return {
    x402Version: 1,
    accepts: [
      {
        scheme: 'exact',
        network: X402_CONFIG.network,
        maxAmountRequired: amountInUnits.toString(),
        resource: '/api/weather',
        description: 'Get current weather data',
        mimeType: 'application/json',
        payTo: X402_CONFIG.recipient,
        maxTimeoutSeconds: 300,
        asset: X402_CONFIG.assetAddress,
        extra: {
          name: X402_CONFIG.asset,
          version: '2',
          reference: reference
        }
      }
    ]
  };
}
```

#### 2. Payment Verification

```typescript theme={"dark"}
async function verifyPayment(paymentHeader: string) {
  const paymentData = JSON.parse(Buffer.from(paymentHeader, 'base64').toString());
  const { x402Version, scheme, network, payload } = paymentData;

  // Validate payment format
  if (x402Version !== 1 || scheme !== 'exact' || network !== X402_CONFIG.network) {
    return { isValid: false, reason: 'Invalid payment format or network' };
  }

  // Verify transaction on-chain
  const receipt = await publicClient.getTransactionReceipt({
    hash: payload.txHash as `0x${string}`
  });

  return { isValid: receipt?.status === 'success', txHash: payload.txHash };
}
```

#### 3. Axiom Agent Integration

The Axiom agent handles the complete x402 flow:

```typescript theme={"dark"}
action({
  name: 'getWeather',
  description: 'Get current weather data. This requires an x402 payment of $0.001 USDC.',
  async handler({ location }, { memory }) {
    // Step 1: Request weather data (returns 402 Payment Required)
    const weatherResponse = await fetch(`${baseUrl}/api/weather`);

    if (weatherResponse.status !== 402) {
      throw new Error(`Expected 402 Payment Required, got ${weatherResponse.status}`);
    }

    const paymentChallenge = await weatherResponse.json();

    // Step 2: Make x402 payment
    const txHash = await makeX402Payment(amount, recipient, reference);

    // Step 3: Retry request with payment proof
    const paymentProof = {
      x402Version: 1,
      scheme: 'exact',
      network: X402_CONFIG.network,
      payload: { txHash, amount, from: seiWallet.walletAddress }
    };

    const weatherDataResponse = await fetch(`${baseUrl}/api/weather`, {
      headers: { 'X-Payment': Buffer.from(JSON.stringify(paymentProof)).toString('base64') }
    });

    return weatherDataResponse.json();
  }
});
```

### Payment Flow

#### 1. Initial Request

```
Client → GET /api/weather
Server → 402 Payment Required + Payment Challenge
```

#### 2. Payment Challenge Response

```json theme={"dark"}
{
  "x402Version": 1,
  "accepts": [
    {
      "scheme": "exact",
      "network": "sei-testnet",
      "maxAmountRequired": "1000",
      "resource": "/api/weather",
      "description": "Get current weather data",
      "mimeType": "application/json",
      "payTo": "0x9dC2aA0038830c052253161B1EE49B9dD449bD66",
      "maxTimeoutSeconds": 300,
      "asset": "0x4fCF1784B31630811181f670Aea7A7bEF803eaED",
      "extra": {
        "name": "USDC",
        "version": "2",
        "reference": "sei-1234567890-abc123"
      }
    }
  ]
}
```

#### 3. Payment Execution

The Axiom agent executes a USDC transfer on Sei testnet:

```typescript theme={"dark"}
const transferData = encodeFunctionData({
  abi: [
    {
      name: 'transfer',
      type: 'function',
      stateMutability: 'nonpayable',
      inputs: [
        { name: 'to', type: 'address' },
        { name: 'amount', type: 'uint256' }
      ],
      outputs: [{ name: '', type: 'bool' }]
    }
  ],
  functionName: 'transfer',
  args: [recipient, amountInUnits]
});

const hash = await seiWallet.walletClient.sendTransaction({
  to: X402_CONFIG.assetAddress,
  data: transferData
});
```

#### 4. Payment Proof Submission

```
Client → GET /api/weather + X-Payment Header (base64 encoded payment proof)
Server → Verifies payment + Returns weather data
```

### Code Examples

#### Complete Weather API Implementation

```typescript theme={"dark"}
export async function GET(req: NextRequest) {
  const paymentHeader = req.headers.get('x-payment');

  if (!paymentHeader) {
    // No payment provided, return 402 with payment requirements
    return NextResponse.json(generatePaymentChallenge(), { status: 402 });
  }

  // Verify the payment
  const verification = await verifyPayment(paymentHeader);

  if (!verification.isValid) {
    // Invalid payment, return 402 with error
    const challenge = generatePaymentChallenge();
    challenge.error = verification.reason || 'Payment verification failed';
    return NextResponse.json(challenge, { status: 402 });
  }

  // Payment verified, return weather data
  const weatherData = {
    location: 'Sei Network',
    temperature: '99°F',
    conditions: 'Sunny',
    humidity: '45%',
    windSpeed: '8 mph',
    timestamp: new Date().toISOString(),
    payment: verification
  };

  return NextResponse.json(weatherData);
}
```

#### Axiom Agent Weather Action

```typescript theme={"dark"}
action({
  name: 'getWeather',
  description: 'Get current weather data. This requires an x402 payment of $0.001 USDC.',
  schema: {
    location: z.string().optional().describe('Optional location for weather data.')
  },
  async handler({ location }, { memory }) {
    try {
      // Step 1: Request weather data (this will return 402 Payment Required)
      const weatherResponse = await fetch(`${baseUrl}/api/weather`);

      if (weatherResponse.status !== 402) {
        throw new Error(`Expected 402 Payment Required, got ${weatherResponse.status}`);
      }

      const paymentChallenge = await weatherResponse.json();

      // Step 2: Make x402 payment
      const reference = paymentChallenge.accepts[0].extra.reference;
      const amount = '0.001'; // $0.001 USDC
      const recipient = paymentChallenge.accepts[0].payTo;

      const txHash = await makeX402Payment(amount, recipient, reference);

      // Step 3: Wait for transaction confirmation
      await new Promise((resolve) => setTimeout(resolve, 3000));

      // Step 4: Retry weather request with payment proof
      const paymentProof = {
        x402Version: 1,
        scheme: 'exact',
        network: X402_CONFIG.network,
        payload: {
          txHash: txHash,
          amount: parseUnits(amount, X402_CONFIG.assetDecimals).toString(),
          from: seiWallet.walletAddress
        }
      };

      const paymentHeader = Buffer.from(JSON.stringify(paymentProof)).toString('base64');

      const weatherDataResponse = await fetch(`${baseUrl}/api/weather`, {
        headers: {
          'Content-Type': 'application/json',
          'X-Payment': paymentHeader
        }
      });

      const weatherData = await weatherDataResponse.json();

      // Update memory
      memory.transactions.unshift(txHash);
      memory.lastTransaction = txHash;

      return actionResponse(`🌤️ **Weather Data Retrieved**

**Location:** ${weatherData.location}
**Temperature:** ${weatherData.temperature}
**Conditions:** ${weatherData.conditions}
**Humidity:** ${weatherData.humidity}
**Wind Speed:** ${weatherData.windSpeed}

✅ **Payment Successful!**

**Transaction Hash:** ${txHash}
**Amount:** $${amount} USDC
**Status:** Confirmed on Sei Testnet

🔗 **View Transaction:** [Seiscan](https://testnet.seiscan.io/tx/${txHash})`);
    } catch (error) {
      return actionResponse(`❌ **Weather Request Failed**

${error.message}

Please try again or check your wallet balance for USDC tokens needed for the payment.`);
    }
  }
});
```

### Security Considerations

#### Payment Verification

* **On-chain Verification**: All payments are verified against the Sei blockchain.
* **Transaction Receipt Validation**: Ensures transaction success and proper recipient.
* **Payment Caching**: Prevents double-spending by caching verified payments.
* **Reference Validation**: Unique payment references prevent replay attacks.

#### Network Security

* **HTTPS Required**: All API communications use secure connections.
* **Base64 Encoding**: Payment proofs are base64 encoded for safe transmission.
* **Timeout Handling**: Payment challenges include timeout mechanisms.
* **Error Handling**: Comprehensive error handling prevents information leakage.

#### Wallet Security

* **Private Key Management**: Private keys are stored securely in environment variables.
* **Transaction Signing**: All transactions are properly signed before submission.
* **Balance Validation**: Sufficient balance checks before payment execution.

### Tutorials & Resources

* **[Sei-js X402 Repository](https://github.com/sei-protocol/sei-x402)**: Comprehensive guide on using the x402 protocol with the sei-js library, including package details and examples.
* **[AxiomKit X402 Demo Repository](https://github.com/AxiomKit/axiomkit-showcase)**: The complete source code for the Axiom integration demo used in this guide, including installation and configuration instructions.