Education

Smart Contracts: Getting Started on Sei in 30 Minutes

Set up your development environment, deploy smart contracts, verify, and interact. All it takes is 30 minutes to get started.

Smart contracts on Sei provide Ethereum developers with a high-performance platform featuring familiar tooling.

The Sei Network is a Layer-1 blockchain that delivers high speed with Ethereum’s developer-friendly EVM environment. It’s the first parallelized EVM chain known for blocktime in sub-seconds and a throughput orders of magnitude higher than Ethereum.

As a result, you can deploy Solidity or Vyper contracts on Sei without modifying your code, yet benefit from massive performance improvements over Ethereum. It’s not only the performance aspect, but also the continuous innovation in architecture, that makes it a reliable platform for EVM development.

Why Build on Sei?

For experienced EVM developers, Sei offers a familiar development experience with extraordinary execution speed and finality.

Key advantages of deploying smart contracts on Sei include:

Fast finality: Twin-Turbo consensus provides Sei with a deterministic time-to-finality of 400 ms, enabling ultra-low-latency dApps. This is ideal for DeFi exchanges, gaming, or any application demanding instant settlement.
Parallel execution: Sei’s runtime executes compatible EVM transactions concurrently using optimistic parallelization, unlocking massive throughput without extra effort from developers. Non-conflicting transactions run in parallel, so your dApp can handle more users and complex logic at scale.
EVM compatibility: Sei is entirely Ethereum Virtual Machine compatible. You can write contracts in Solidity or Vyper and use standard tools like Hardhat or Foundry. There’s no new language to learn. Existing Ethereum tooling and libraries are compatible with Sei. This drastically lowers the barrier to entry.
Low fees and high throughput: Gas fees on Sei are paid in the native $SEI token, and are relatively low in relation to industry standards. The network supports all Ethereum transaction types. However, note that if you use legacy (non-EIP1559) transactions, you must specify a minimum one-gwei base fee. With block capacity measured in gigagas, Sei’s computations-per-second capacity far exceeds Ethereum, reducing congestion and keeping costs low.

You can retain the developer experience of Ethereum while enjoying fast performance on the network.

Configuring Your Development Environment

When you’re building with Sei, there are a few prerequisites you need to ensure while setting up your development environment.

Ensure you have a recent Node.js and a package manager installed. Specifically, the Sei docs recommend Node.js v16+ and npm v7+ (or yarn). You’ll also need a code editor (VS Code is suggested) and familiarity with standard Ethereum dev tools.

Install Hardhat and project dependencies

In a new project folder, initialize a Node project and install Hardhat plus useful libraries like Hardhat Toolbox and OpenZeppelin Contracts:

# Create a new directory for your project

mkdir sei-hardhat-project

cd sei-hardhat-project

# Initialize a new npm project

npm init -y

# Install Hardhat and necessary dependencies

npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox @openzeppelin/contracts dotenv

Next, run npx hardhat init and follow the prompts to create a basic Hardhat project (choose “Create a JavaScript project” when prompted). This will set up the Hardhat config file and sample directories.

Configure Hardhat for the Sei network

By default, Hardhat will be set up for local Ethereum development. You need to add Sei’s network details to your hardhat.config.js. Open that file and add a network configuration for Sei’s testnet. For example, you might add:

require('@nomicfoundation/hardhat-toolbox');

require('dotenv').config();

// Load environment variables

const PRIVATE_KEY = process.env.PRIVATE_KEY || '0x0000000000000000000000000000000000000000000000000000000000000000';

/** @type import('hardhat/config').HardhatUserConfig */

module.exports = {

solidity: {

version: '0.8.28',

settings: {

optimizer: {

enabled: true,

runs: 200

}

networks: {

// Sei testnet configuration

seitestnet: {

url: 'https://evm-rpc-testnet.sei-apis.com',

accounts: [PRIVATE_KEY],

chainId: 1328, // Sei testnet chain ID

gasPrice: 2000000000 // 2 gwei = 2 nsei

// Sei mainnet configuration

seimainnet: {

url: 'https://evm-rpc.sei-apis.com',

accounts: [PRIVATE_KEY],

chainId: 1329, // Sei mainnet chain ID

gasPrice: 2000000000 // 2 gwei = 2 nsei

// Local development with Hardhat Network

hardhat: {

chainId: 31337

}

paths: {

sources: './contracts',

tests: './test',

cache: './cache',

artifacts: './artifacts'

mocha: {

timeout: 40000

}

};

The values above are sourced from Sei’s official network information: chain ID 1328 for the testnet (1329 for the mainnet) and the public RPC endpoints. We set a gas price of 2 Gwei as a reasonable default, as per the docs.

Note: Be sure to load your private key from an environment variable as shown (e.g., in a .env file, set PRIVATE_KEY="0x...your key..."). Never hardcode your private key in the config or commit it to version control. Also, add .env to .gitignore to avoid leaking secrets.

Connect MetaMask to Sei (optional)

To interact with your deployed contract via MetaMask, add the Sei network to your MetaMask wallet. You can do this manually using the above RPC URL, Chain ID, and setting currency symbol to “SEI,” or use the one-click links on Sei’s docs.

Once added, import the account corresponding to your deployment private key. Or, you can use a MetaMask account directly by putting its private key in your .env.

Fund Your Account With Testnet SEI

Before deployment, your account needs some SEI for gas. Sei’s Atlantic-2 testnet provides a faucet that dispenses 5 SEI every 24 hours for free. Visit the official Sei Faucet page and enter your Sei address. Complete the CAPTCHA and request funds. These tokens are valueless and intended for testing purposes only.

Pro tip: Always deploy and test on the testnet before touching the mainnet. This helps catch bugs early, avoid wasting real funds on gas, and generally keep your users safe. Once your contracts behave correctly on the Atlantic-2 testnet, you can switch the network to mainnet (chainId 1329, RPC https://evm-rpc.sei-apis.com) for production deployment.

How to Deploy Your First Smart Contract on Sei

With your environment ready, let’s go through the steps to deploy a simple smart contract to Sei. We’ll use a basic ERC-20 token as an example, but you can deploy any Solidity contract of your choice.

1. Write a Smart Contract

You can create a new Solidity file under the contracts/ folder. For example, create contracts/SeiToken.sol with the following content, using OpenZeppelin’s standard ERC20 implementation:

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

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

});

Use this to deploy the token to the Sei testnet:

npx hardhat ignition deploy ignition/modules/deploy-sei-token.js --network seitestnet

2. Compile and Test Locally

It’s wise to compile your contract and run any unit tests before deploying. Run npx hardhat compile to ensure the contract compiles without errors. You can also write Hardhat tests under the test/ directory and run npx hardhat test to verify functionality.

// Transfer 50 tokens from addr1 to addr2const { expect } = require('chai');

const { ethers } = require('hardhat');

describe('SeiToken', function () {

let SeiToken;

let seiToken;

let owner;

let addr1;

let addr2;

beforeEach(async function () {

// Get signers

[owner, addr1, addr2] = await ethers.getSigners();

// Deploy the token

SeiToken = await ethers.getContractFactory('SeiToken');

seiToken = await SeiToken.deploy(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);

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;

});

Hardhat’s toolbox includes plugins like Ethers and Waffle/Chai for testing. While this guide focuses on deployment, a comprehensive project would consist of a robust test suite.

3. Deploy to Sei testnet

With a compiled contract and configured network, you’re ready to deploy. Create a deployment script under the scripts/ folder, for example, scripts/deploy-sei-token.js:

const { ethers } = require("hardhat");

async function main() {

const [deployer] = await ethers.getSigners();

console.log("Deploying with account:", deployer.address);

const SeiToken = await ethers.getContractFactory("SeiToken");

const seiToken = await SeiToken.deploy(); // deploy the contract

await seiToken.waitForDeployment();

console.log("SeiToken deployed to:", await seiToken.getAddress());

}

main().catch((error) => {

console.error(error);

process.exitCode = 1;

});

This script gets your deployer account, deploys the SeiToken contract, and logs the address. Now execute the deployment using Hardhat:

npx hardhat run scripts/deploy-sei-token.js --network seitestnet

When you run this, Hardhat will use the seitestnet config to broadcast the transaction to Sei’s testnet. In the console, you’ll see your address and the new contract address if successful.

4. Verify the deployment

Once Hardhat reports the contract address, you can confirm the contract is live on Sei. Head to the Sei block explorer (SeiScan or SeiTrace for mainnet or testnet) and search for your contract address.

The explorer should show the transaction details and contract code (if verified). Initially, you’ll notice that the Code is not verified. In the next section, we’ll verify the source to make the code publicly visible.

For now, note that the transaction has finalized instantly on Sei, there is no waiting for multiple confirmations or probabilistic finality. The contract address is usable as soon as you see it.

Verifying and Interacting with Your Contract

Contract verification is the process of uploading your source code to the explorer, allowing others to read and audit it.

The simplest way to do it, if using Hardhat, is to run Hardhat’s verify task. For example:

npx hardhat verify --network seitestnet <your_contract_address>

(Include constructor arguments, if any, in the command above.)

This uses Hardhat’s built-in Etherscan/Blockscout verification plugin to submit your contract’s metadata to SeiTrace. Alternatively, you can navigate to the “Verify Contract” page on SeiTrace and manually upload your compiled JSON artifacts or source code.

After verification, refresh the contract page on SeiTrace. You should see a green checkmark indicating the code is verified, and a “Code” tab with your Solidity source.

You’ll also get an additional “Read Contract” and “Write Contract” interface on the explorer, allowing you to interact with the contract directly from the browser.

Interact via Web3 or MetaMask

Now that your contract is deployed, you can integrate it into a frontend or interact with it through scripts. The RPC endpoint understands Ethereum JSON-RPC calls, so libraries like ethers.js or web3.js will work out of the box when pointed at Sei’s RPC URL. For example, in ethers.js, you can create a provider with new ethers.JsonRpcProvider("https://evm-rpc-testnet.sei-apis.com") and use your contract’s Application Binary Interface (ABI) and address to call functions.

MetaMask can also send transactions directly on Sei, since you added the network earlier. You could send SEI tokens, or call your contract’s mint function if it’s Ownable.

Keep in mind that Sei’s instant finality means once a transaction is included in a block, it’s final. There’s no need to wait for confirmations. This simplifies dApp logic.

The System Is Set In Under 30 Minutes

From here, consider deploying to Sei’s mainnet. Just switch the network configuration and ensure you have the mainnet SEI for gas. The process is identical, although you’ll want to conduct extra diligence and possibly a security audit before mainnet deployment.

Additionally, keep an eye out for Sei Giga, the upcoming upgrade that aims to create industry-best EVM performance. The Sei Labs team is rebuilding core parts of the EVM execution, consensus, and storage to target 5 gigagas/sec throughput.

With this, the dApps on Sei would be able to scale to meet tomorrow’s infrastructure demands today. As a developer, you’ll be able to build high-throughput applications on a familiar platform, knowing that the underlying network is evolving to support web-scale loads.

Time to build faster on Sei.

Join the developer community on Discord for support and to showcase what you build.