How to Migrate from Solana to Sei EVM

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

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

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

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

// 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)?;

// 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);
}

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

// 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);
    }
}

import { HardhatUserConfig } from 'hardhat/config';
import '@nomicfoundation/hardhat-toolbox';
 
const config: HardhatUserConfig = {
  solidity: '0.8.22',
  networks: {
    seiMainnet: {
      url: 'https://evm-rpc.sei-apis.com',
      chainId: 1329,
      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : []
    },
    seiTestnet: {
      url: 'https://evm-rpc-testnet.sei-apis.com',
      chainId: 1328,
      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : []
    }
  },
  etherscan: {
    apiKey: {
      seiMainnet: 'dummy', // Seitrace doesn't require 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;

[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"
 
[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 }

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,
}

contract MyContract {
    uint256 public value;
    address public authority;
 
    constructor(uint256 initialValue) {
        value = initialValue;
        authority = msg.sender;
    }
}

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

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

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

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

// 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,
});

// Sei EVM: Event declaration and emission
event Transfer(
    address indexed from,
    address indexed to,
    uint256 amount
);
 
// Emit
emit Transfer(from, to, amount);

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();

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();

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);
  });
});

import { expect } from 'chai';
import { ethers } from 'hardhat';
 
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);
  });
});