Migrate Your EVM dApp to Sei

​

Migrating from Arbitrum

1. Remove L1 interactions: Find any logic that posts data to Ethereum L1 or reads data from it. Remove that logic, or replace it with a Sei-native alternative.
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 them. Sei settles instantly.
4. ArbOS precompiles: Replace any Arbitrum-specific precompiles:

// 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 for omnichain connectivity.

​

Migrating from Base

1. Remove blob transactions: Sei does not support EIP-4844 blob transactions. If you use them for data availability, store the data differently or use Sei’s native mechanisms.
2. OP Stack precompiles: Remove any precompile calls that are specific to Optimism or Base:

// 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 your wallet connection logic to use the Sei network parameters:

// 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']
};

​

Migrating from Polygon PoS

1. Token references: Replace all MATIC and POL references with SEI:

// 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 and Bor assumptions: Remove any Polygon-specific validator or sidechain logic.
4. Reorg handling: You can safely remove the code that handles block reorganizations. Sei’s consensus prevents reorgs.
5. Gas price oracles: Polygon’s gas prices can spike significantly. Sei’s fees are more stable because of higher throughput:

// 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 the Polygon Bridge with LayerZero or other Sei-supported bridges.

​

Migrating from Avalanche C-Chain

1. Token references: Replace AVAX with SEI:

// 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, redesign that architecture for Sei’s single-chain model, or use cross-chain messaging.
3. Avalanche-specific precompiles: Remove C-Chain precompile calls:

// 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. Sei has a fixed 12.5M cap per block and per transaction. If you have large transactions, benchmark them on Sei and split them when needed:

// 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. If you migrate oracle logic, adjust your observation windows:

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