How to migrate to Sei from another EVM chain

Sei offers full EVM bytecode compatibility plus near-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.

Chain Comparison Overview

Before diving into migration steps, understand how Sei compares to your source chain:

Chain-Specific Migration Guides

Select your source chain to see specific migration considerations:

// 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('0.1', 'gwei') // Sei has much lower fees
});

// 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

// Base-specific (remove)
// L1Block(0x4200000000000000000000000000000000000015).number();
 
// Use standard EVM on Sei
uint256 blockNum = block.number;

// 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://seitrace.com']
};

// Before (Polygon)
// IERC20(0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270).transfer(...); // WMATIC
 
// After (Sei) - use native SEI or wrapped version
// Check ecosystem contracts for canonical WSEI address

// 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

// Before (Avalanche)
// IERC20(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7).transfer(...); // WAVAX
 
// After (Sei)
// Use native SEI or check ecosystem contracts for WSEI

// Avalanche-specific (remove)
// INativeMinter(0x0200000000000000000000000000000000000001).mintNativeCoin(...)
 
// Use standard EVM patterns on Sei

// If deploying large contracts, batch by gas
const MAX_GAS_PER_BATCH = 9_000_000; // Leave buffer under 10M

// Avalanche: 1 hour = ~1800 blocks
// Sei: 1 hour = ~9000 blocks
uint32 constant TWAP_PERIOD = 9000; // Adjust for Sei's block time

Step 1: Evaluate Compatibility

Revisit the Divergence from Ethereum doc and confirm every assumption your contracts/frontends make still holds.

Step 2: Prepare Your Development Environment

Add Sei Network Configuration

Hardhat Configuration:

import '@nomicfoundation/hardhat-verify';
 
const config = {
  networks: {
    seiMainnet: {
      url: process.env.SEI_MAINNET_RPC ?? 'https://evm-rpc.sei-apis.com',
      chainId: 1329,
      accounts: process.env.DEPLOYER_KEYS?.split(',') ?? []
    },
    seiTestnet: {
      url: process.env.SEI_TESTNET_RPC ?? 'https://evm-rpc-testnet.sei-apis.com',
      chainId: 1328,
      accounts: process.env.DEPLOYER_KEYS?.split(',') ?? []
    }
  },
  etherscan: {
    apiKey: {
      seiMainnet: 'dummy', // Seitrace doesn't require real API key
      seiTestnet: 'dummy'
    },
    customChains: [
      {
        network: 'seiMainnet',
        chainId: 1329,
        urls: {
          apiURL: 'https://seitrace.com/pacific-1/api',
          browserURL: 'https://seitrace.com'
        }
      },
      {
        network: 'seiTestnet',
        chainId: 1328,
        urls: {
          apiURL: 'https://seitrace.com/atlantic-2/api',
          browserURL: 'https://seitrace.com'
        }
      }
    ]
  }
};
 
export default config;

Foundry Configuration:

[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"
 
[etherscan]
sei_mainnet = { key = "dummy", url = "https://seitrace.com/pacific-1/api", chain = 1329 }
sei_testnet = { key = "dummy", url = "https://seitrace.com/atlantic-2/api", chain = 1328 }

See the Hardhat tutorial and Foundry guide for complete setup instructions.

Wallet Configuration

Pre-configure MetaMask or other wallets with Sei chain params:

const seiMainnet = {
  chainId: '0x531', // 1329
  chainName: 'Sei',
  nativeCurrency: { name: 'Sei', symbol: 'SEI', decimals: 18 },
  rpcUrls: ['https://evm-rpc.sei-apis.com'],
  blockExplorerUrls: ['https://seitrace.com']
};
 
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:

For third-party contracts (LayerZero, Safe, etc.), consult the full Ecosystem Contracts page.

Step 4: Port Contracts and Configuration

Parameterize Chain-Specific Constants

// 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 10M gas limit per block means large deployments may need batching

Refactor Deprecated Patterns

// 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.

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)
• IBC: For Cosmos ecosystem assets
• Pointer contracts: For bridging non-EVM assets—see Pointer Contracts

Step 6: Handle Assets and Oracles

Bridge Canonical Assets

Follow the Bridging guide to move core tokens to Sei.

Oracle Integration

Sei supports multiple oracle solutions:

Step 7: Launch Checklist

Testnet Deployment (atlantic-2)

• Deploy all contracts to testnet (chain ID: 1328)
• Run full integration test suite
• Verify contracts via Seitrace
• 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 Seitrace
• Update frontend configurations
• Prepare user migration documentation

Step 8: Operational Readiness

Contract Verification

Automate verification through CI using the Seitrace APIs:

# Foundry verification
forge verify-contract --watch \
  --compiler-version "0.8.22" \
  --verifier blockscout \
  --verifier-url https://seitrace.com/pacific-1/api \
  --etherscan-api-key dummy \
  --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

Monitoring Gas Parameters

Periodically query fee data to keep dashboards aligned:

// 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 10M block cap

4. Price Oracles: Reuse TWAP/Chainlink logic but shorten observation windows for Sei’s faster blocks.

5. Verification: Submit to Seitrace and the Ecosystem Contracts registry.

Helpful References

• Divergence from Ethereum – Opcode, gas, and state nuances
• EVM Networks – RPCs, explorers, and MetaMask payloads
• Precompiles – Interoperability patterns
• Ecosystem Contracts – Canonical addresses
• LayerZero Integration – Cross-chain messaging
• Contract Verification – Contract verification guide