Sei EVM Smart Contract Development with Foundry

This tutorial shows how to set up Foundry for Sei EVM development. It covers environment setup, contract creation, and deployment. You use OpenZeppelin’s pre-built components with the Foundry toolkit to build secure, standardized smart contracts.

Watch the video walkthrough for this topic in the Video Tutorials section.

Deploy to Sei Testnet firstWe highly recommend that you deploy to Sei Testnet first. Make sure that everything works as expected before you deploy to Sei Mainnet. This helps you catch bugs early, avoid unnecessary gas costs, and keep your users safe.

Try it before you install

It takes a few minutes to install Foundry and scaffold a project. If you only want to see a contract deploy to Sei, you can do both of these steps in the browser now. First, confirm that the RPC endpoints you will use in foundry.toml respond: Then add Sei Testnet to your wallet and deploy a minimal Counter.sol from Remix. You do not need forge or a local install. In Remix, compile the contract under Solidity Compiler. Then deploy it under Deploy & Run, with Environment set to Injected Provider - MetaMask.

Try it before you install
Prerequisites
Setting up your development environment
Configuring Foundry for Sei EVM
Using OpenZeppelin contracts
Creating and deploying smart contracts
Testing your smart contracts
Deploying to Sei Testnet and Mainnet
Interacting with deployed contracts

Prerequisites

Before you start, make sure that you have the following:

Foundry installed on your system
A basic understanding of Solidity and smart contract development
A wallet with SEI tokens for gas
Node.js (v18.0.0 or later) for ethers.js interactions

Setting up your development environment

If you have not installed Foundry yet, install it first. Follow the installation guide or use the quick install command:

curl -L https://foundry.paradigm.xyz | bash
foundryup

Create a new Foundry project:

# 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 creates a standard Foundry project structure with src/, test/, and script/ directories.

Configuring Foundry for Sei EVM

To configure Foundry for Sei networks, create a foundry.toml file in your project root:

foundry.toml

[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:

.env

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

Add .env to your .gitignore file. If you commit sensitive information such as your PRIVATE_KEY, you can lose funds.

Using OpenZeppelin contracts

OpenZeppelin has a library of secure, tested smart contract components. Install the OpenZeppelin contracts:

forge install OpenZeppelin/openzeppelin-contracts

Create a remappings.txt file to map the imports correctly:

forge remappings > remappings.txt

Creating and deploying smart contracts

Each tab below creates a different type of smart contract. Choose the one that matches what you want to build:

Counter Contract
ERC20 Token
ERC721 NFT

Start with a simple counter contract. Update the default src/Counter.sol file:

src/Counter.sol

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

script/DeployCounter.s.sol

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

Create an ERC20 token with OpenZeppelin. Add the contract to src/SeiToken.sol:

src/SeiToken.sol

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

script/DeploySeiToken.s.sol

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

Create an ERC721 NFT contract with OpenZeppelin. Add the contract to src/SeiNFT.sol:

src/SeiNFT.sol

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

script/DeploySeiNFT.s.sol

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

Testing your smart contracts

Foundry has built-in support for testing. Create tests for your contracts.

Counter Tests
ERC20 Tests
ERC721 Tests

Update test/Counter.t.sol:

test/Counter.t.sol

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

Create test/SeiToken.t.sol:

test/SeiToken.t.sol

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

Create test/SeiNFT.t.sol:

test/SeiNFT.t.sol

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

Run your tests:

forge test

For more verbose output, run:

forge test -vvv

Deploying to Sei Testnet and Mainnet

You can deploy your contracts to the Sei networks with Forge scripts or with direct deployment commands.

Using Forge scripts (recommended)

Deploy to Sei Testnet:

forge script script/DeployCounter.s.sol --rpc-url $SEI_TESTNET_RPC --private-key $PRIVATE_KEY --broadcast

Deploy to Sei Mainnet:

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:

# 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/")

A successful deployment prints output similar to this:

[⠒] Compiling...
No files changed, compilation skipped
Deployer: 0xYOUR_DEPLOYER_ADDRESS
Deployed to: 0xYOUR_CONTRACT_ADDRESS
Transaction hash: 0xYOUR_TX_HASH

Interacting with deployed contracts

After deployment, you can interact with your contracts through Foundry’s cast tool or ethers.js.

Using Cast commands

# 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

To interact with your contracts programmatically, install ethers.js:

npm install ethers@latest

Create a Node.js script to interact with your deployed contracts:

interact.js

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

Foundry generates contract ABIs in the out folder. You can use these ABIs to interact with contracts from other tools, such as ethers.js or web3.js.

Overview

Essentials

seid CLI

Frontend Development

Smart Contracts

sei-js Library

Videos

Ecosystem Tutorials

Reference

Hardware Wallets

Sei EVM Smart Contract Development with Foundry

Try it before you install

Table of contents

Prerequisites

Setting up your development environment

Configuring Foundry for Sei EVM

Using OpenZeppelin contracts

Creating and deploying smart contracts

Testing your smart contracts

Deploying to Sei Testnet and Mainnet

Using Forge scripts (recommended)

Using direct Forge create commands

Interacting with deployed contracts

Using Cast commands

Using ethers.js

​Try it before you install

​Table of contents

​Prerequisites

​Setting up your development environment

​Configuring Foundry for Sei EVM

​Using OpenZeppelin contracts

​Creating and deploying smart contracts

​Testing your smart contracts

​Deploying to Sei Testnet and Mainnet

​Using Forge scripts (recommended)

​Using direct Forge create commands

​Interacting with deployed contracts

​Using Cast commands

​Using ethers.js

Try it before you install

Table of contents

Prerequisites

Setting up your development environment

Configuring Foundry for Sei EVM

Using OpenZeppelin contracts

Creating and deploying smart contracts

Testing your smart contracts

Deploying to Sei Testnet and Mainnet

Using Forge scripts (recommended)

Using direct Forge create commands

Interacting with deployed contracts

Using Cast commands

Using ethers.js