A complete guide to smart contract development

What is a smart contract?

A smart contract is a piece of computer code stored on a blockchain that defines a set of rules (contract terms) that automatically execute actions when preset conditions are triggered – without human intervention and without trusting third-party intermediaries.

Core features of smart contracts

Smart contracts vs. traditional contracts

Mainstream smart contract platform

Solidity language foundation

Solidity is the mainstream smart contract programming language for Ethereum and all EVM-compatible chains. It is a statically typed, contract-oriented, high-level language with a syntax similar to JavaScript and C++.

Basic data types

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract DataTypes {
    // 值类型
    bool public isActive = true;
    uint256 public amount = 1000;           // 无符号整数（0 ~ 2^256-1）
    int256 public temperature = -10;         // 有符号整数
    address public owner = msg.sender;       // 以太坊地址（20字节）
    bytes32 public hash;                     // 固定大小字节数组

    // 引用类型
    string public name = "NovaLink";         // 动态字符串
    uint256[] public numbers;                // 动态数组
    mapping(address => uint256) public balances; // 映射（键值对）

    // 枚举
    enum Status { Pending, Active, Closed }
    Status public currentStatus = Status.Pending;

    // 结构体
    struct Order {
        uint256 id;
        address buyer;
        uint256 amount;
        Status status;
    }
    mapping(uint256 => Order) public orders;
}

Function modifiers and visibility

contract FunctionTypes {
    address public owner;
    uint256 public value;

    // 构造函数（部署时执行一次）
    constructor() {
        owner = msg.sender;
    }

    // 修饰符：权限控制
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;  // 继续执行被修饰的函数
    }

    // 可见性：public（任何人可调用）
    // 状态可变性：payable（可接收ETH）
    function deposit() public payable {
        value += msg.value;
    }

    // 可见性：external（仅外部调用）
    // 状态可变性：view（只读状态）
    function getBalance() external view returns (uint256) {
        return address(this).balance;
    }

    // 可见性：internal（仅本合约和子合约）
    function _validateAmount(uint256 amount) internal pure returns (bool) {
        return amount > 0 && amount <= 1000 ether;
    }

    // 使用修饰符保护的函数
    function withdraw() external onlyOwner {
        payable(owner).transfer(address(this).balance);
    }
}

Events and logs

contract Events {
    // 事件声明（indexed 参数可用于过滤）
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function transfer(address to, uint256 amount) external {
        // ... 转账逻辑
        emit Transfer(msg.sender, to, amount);  // 触发事件
    }
}
// 前端监听事件：
// contract.on("Transfer", (from, to, value) => { ... });

Error handling

• require(): Verify the input parameters and preconditions, and return the remaining gas if it fails
• revert(): Explicit rollback transactions, support custom errors (Custom Error, more gas-saving)
• assert(): Validate invariant, failure indicates a serious bug
• try/catch: Catches external call failures and prevents the entire transaction from being rolled back

Development environment construction

A professional smart contract development environment requires the cooperation of a compiler, test framework, native blockchain, and deployment tools. The following is a comparison of mainstream toolchains:

Comparison of development frameworks

Hardhat project initialization

# 创建项目
mkdir my-contract && cd my-contract
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox

# 初始化 Hardhat
npx hardhat init
# 选择: Create a TypeScript project

# 项目结构
├── contracts/          # Solidity 合约源码
│   └── Lock.sol
├── scripts/            # 部署脚本
│   └── deploy.ts
├── test/               # 测试文件
│   └── Lock.ts
├── hardhat.config.ts   # 配置文件
└── package.json

Hardhat configuration example

// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import "dotenv/config";

const config: HardhatUserConfig = {
  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: { enabled: true, runs: 200 },
      viaIR: true,  // 启用 IR 编译优化
    },
  },
  networks: {
    hardhat: {
      forking: {
        url: process.env.MAINNET_RPC_URL!,  // Fork主网状态
        blockNumber: 19000000,
      },
    },
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: [process.env.PRIVATE_KEY!],
    },
    polygon: {
      url: process.env.POLYGON_RPC_URL,
      accounts: [process.env.PRIVATE_KEY!],
    },
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY,
  },
  gasReporter: {
    enabled: true,
    currency: "USD",
  },
};

export default config;

Foundry project initialization

# 安装 Foundry
curl -L https://foundry.paradigm.xyz | bash
foundryup

# 创建项目
forge init my-contract && cd my-contract

# 项目结构
├── src/               # 合约源码
├── test/              # Solidity 测试
├── script/            # 部署脚本
├── lib/               # 依赖库（git submodule）
└── foundry.toml       # 配置文件

# 安装依赖
forge install OpenZeppelin/openzeppelin-contracts

# 编译
forge build

# 测试（含 Gas 报告）
forge test -vvv --gas-report

# 模糊测试 100万次
forge test --fuzz-runs 1000000

Contract structure and life cycle

Understanding the full lifecycle of a contract is fundamental to writing high-quality code. From writing, compiling, deploying, to interacting, each stage has its technical requirements.

Contract lifecycle

Full contract template

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";

/// @title 完整合约模板
/// @author NovaLinkR
/// @notice 演示一个具备标准安全功能的合约结构
contract ContractTemplate is Ownable, ReentrancyGuard, Pausable {

    // ============ 状态变量 ============
    uint256 public totalDeposits;
    mapping(address => uint256) public userBalances;

    // ============ 事件 ============
    event Deposited(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);

    // ============ 自定义错误（比 require string 更省 Gas） ============
    error InsufficientBalance(uint256 requested, uint256 available);
    error ZeroAmount();

    // ============ 构造函数 ============
    constructor() Ownable(msg.sender) {}

    // ============ 外部函数 ============

    /// @notice 存款
    function deposit() external payable whenNotPaused {
        if (msg.value == 0) revert ZeroAmount();

        userBalances[msg.sender] += msg.value;
        totalDeposits += msg.value;

        emit Deposited(msg.sender, msg.value);
    }

    /// @notice 提款
    function withdraw(uint256 amount) external nonReentrant whenNotPaused {
        uint256 balance = userBalances[msg.sender];
        if (amount > balance) revert InsufficientBalance(amount, balance);

        // Checks-Effects-Interactions 模式
        userBalances[msg.sender] -= amount;  // Effects（先修改状态）
        totalDeposits -= amount;

        (bool success, ) = msg.sender.call{value: amount}("");  // Interactions
        require(success, "Transfer failed");

        emit Withdrawn(msg.sender, amount);
    }

    // ============ 管理函数 ============

    function pause() external onlyOwner { _pause(); }
    function unpause() external onlyOwner { _unpause(); }

    // ============ View 函数 ============

    function getContractBalance() external view returns (uint256) {
        return address(this).balance;
    }

    // ============ Receive/Fallback ============
    receive() external payable {
        userBalances[msg.sender] += msg.value;
        totalDeposits += msg.value;
    }
}

ERC Standard Contract

ERC (Ethereum Request for Comments) is a token interface standard developed by the Ethereum community. Following standards ensures that tokens are interoperable across different applications.

List of mainstream ERC standards

ERC-20 token contract implementation

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

/// @title 带铸造、销毁、Permit功能的ERC-20代币
contract NovaToken is ERC20, ERC20Burnable, ERC20Permit, Ownable {
    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 1e18;

    constructor() ERC20("Nova Token", "NOVA") ERC20Permit("Nova Token") Ownable(msg.sender) {
        // 初始铸造 30% 给部署者
        _mint(msg.sender, 300_000_000 * 1e18);
    }

    /// @notice 仅限owner铸造（用于后续释放）
    function mint(address to, uint256 amount) external onlyOwner {
        require(totalSupply() + amount <= MAX_SUPPLY, "Exceeds max supply");
        _mint(to, amount);
    }
}

ERC-4626 tokenized vaults

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";

/// @title 收益金库（DeFi核心组件）
/// @notice 用户存入底层资产，获得份额代币，份额随收益增值
contract YieldVault is ERC4626 {
    constructor(IERC20 asset_)
        ERC4626(asset_)
        ERC20("Nova Yield Vault", "nvUSDC")
    {}

    // 金库的总资产 = 合约持有的底层代币 + 外部协议中的收益
    function totalAssets() public view override returns (uint256) {
        return IERC20(asset()).balanceOf(address(this));
        // 实际项目中还需加上在 Aave/Compound 等协议中的存款
    }
}

Design patterns and architectures

Mature smart contract projects need to use proven design patterns to ensure the security, maintainability, and scalability of the code.

Core design patterns

Factory model implementation

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/proxy/Clones.sol";

/// @title 最小代理工厂（EIP-1167 Clone）
/// @notice 以极低Gas创建合约实例（比常规部署节省90%+）
contract TokenFactory {
    using Clones for address;

    address public implementation;  // 模板合约
    address[] public deployedTokens;

    event TokenCreated(address indexed token, address indexed creator, string name);

    constructor(address _implementation) {
        implementation = _implementation;
    }

    /// @notice 创建新代币（Clone方式，极低Gas）
    function createToken(
        string memory name,
        string memory symbol,
        uint256 initialSupply
    ) external returns (address) {
        address clone = implementation.clone();

        // 初始化 clone 实例
        IToken(clone).initialize(name, symbol, initialSupply, msg.sender);

        deployedTokens.push(clone);
        emit TokenCreated(clone, msg.sender, name);
        return clone;
    }

    function getDeployedCount() external view returns (uint256) {
        return deployedTokens.length;
    }
}

DeFi contract development

DeFi (decentralized finance) is the most complex and valuable application scenario for smart contracts. The following shows the implementation ideas of the core DeFi module.

DeFi Core Modules

Simple AMM DEX contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

/// @title 恒定乘积AMM（简化版 Uniswap V2）
contract SimpleAMM is ERC20 {
    IERC20 public immutable tokenA;
    IERC20 public immutable tokenB;
    uint256 public reserveA;
    uint256 public reserveB;

    uint256 public constant FEE_BPS = 30; // 0.3% 手续费

    event LiquidityAdded(address indexed provider, uint256 amountA, uint256 amountB, uint256 liquidity);
    event Swapped(address indexed user, address tokenIn, uint256 amountIn, uint256 amountOut);

    constructor(address _tokenA, address _tokenB) ERC20("AMM-LP", "ALP") {
        tokenA = IERC20(_tokenA);
        tokenB = IERC20(_tokenB);
    }

    /// @notice 添加流动性
    function addLiquidity(uint256 amountA, uint256 amountB) external returns (uint256 liquidity) {
        tokenA.transferFrom(msg.sender, address(this), amountA);
        tokenB.transferFrom(msg.sender, address(this), amountB);

        if (totalSupply() == 0) {
            liquidity = sqrt(amountA * amountB);
        } else {
            liquidity = min(
                (amountA * totalSupply()) / reserveA,
                (amountB * totalSupply()) / reserveB
            );
        }

        require(liquidity > 0, "Insufficient liquidity");
        _mint(msg.sender, liquidity);

        reserveA += amountA;
        reserveB += amountB;

        emit LiquidityAdded(msg.sender, amountA, amountB, liquidity);
    }

    /// @notice Token A → Token B 兑换
    function swapAForB(uint256 amountIn) external returns (uint256 amountOut) {
        require(amountIn > 0, "Zero input");

        uint256 amountInWithFee = amountIn * (10000 - FEE_BPS) / 10000;
        // 恒定乘积公式：x * y = k
        amountOut = (reserveB * amountInWithFee) / (reserveA + amountInWithFee);

        tokenA.transferFrom(msg.sender, address(this), amountIn);
        tokenB.transfer(msg.sender, amountOut);

        reserveA += amountIn;
        reserveB -= amountOut;

        emit Swapped(msg.sender, address(tokenA), amountIn, amountOut);
    }

    function sqrt(uint256 x) internal pure returns (uint256) {
        uint256 z = (x + 1) / 2;
        uint256 y = x;
        while (z < y) { y = z; z = (x / z + z) / 2; }
        return y;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

Staking mining contracts

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

/// @title 单币质押挖矿（Synthetix StakingRewards 模型）
contract StakingRewards is ReentrancyGuard {
    IERC20 public immutable stakingToken;
    IERC20 public immutable rewardToken;

    uint256 public rewardRate;          // 每秒奖励数量
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;
    uint256 public totalStaked;

    mapping(address => uint256) public userStaked;
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;

    constructor(address _stakingToken, address _rewardToken, uint256 _rewardRate) {
        stakingToken = IERC20(_stakingToken);
        rewardToken = IERC20(_rewardToken);
        rewardRate = _rewardRate;
    }

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = block.timestamp;
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalStaked == 0) return rewardPerTokenStored;
        return rewardPerTokenStored +
            ((block.timestamp - lastUpdateTime) * rewardRate * 1e18) / totalStaked;
    }

    function earned(address account) public view returns (uint256) {
        return (userStaked[account] * (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18
            + rewards[account];
    }

    function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
        require(amount > 0, "Cannot stake 0");
        stakingToken.transferFrom(msg.sender, address(this), amount);
        userStaked[msg.sender] += amount;
        totalStaked += amount;
    }

    function withdraw(uint256 amount) external nonReentrant updateReward(msg.sender) {
        require(amount <= userStaked[msg.sender], "Exceeds staked");
        userStaked[msg.sender] -= amount;
        totalStaked -= amount;
        stakingToken.transfer(msg.sender, amount);
    }

    function claimReward() external nonReentrant updateReward(msg.sender) {
        uint256 reward = rewards[msg.sender];
        if (reward > 0) {
            rewards[msg.sender] = 0;
            rewardToken.transfer(msg.sender, reward);
        }
    }
}

Gas optimization tips

Gas fees directly impact user experience and contract competitiveness. Here are proven optimization strategies that can significantly reduce interaction costs.

Overview of optimization strategies

Variable packaging example

// ❌ 差：每个变量占一个32字节存储槽（3个槽 = 60000 Gas写入）
contract Unoptimized {
    uint256 public amount;     // Slot 0
    bool public isActive;      // Slot 1（浪费31字节）
    address public owner;      // Slot 2
}

// ✅ 好：紧凑打包到更少的存储槽（2个槽 = 40000 Gas写入）
contract Optimized {
    uint256 public amount;     // Slot 0（占满32字节）
    address public owner;      // Slot 1（20字节）
    bool public isActive;      // Slot 1（+1字节，同一槽）
}

// ✅ 极致优化：位操作打包多个小变量
contract UltraOptimized {
    // 将多个状态打包到一个 uint256
    // bits 0-7: status (uint8)
    // bits 8-39: timestamp (uint32, 可到2106年)
    // bits 40-199: address (uint160)
    // bits 200-255: amount (uint56, 足够大多数场景)
    uint256 private _packedData;
}

Batch operation optimization

// ❌ 差：逐笔空投（N次独立交易，每次21000+ Gas基础费）
// 100人空投 ≈ 100 * 65000 = 6,500,000 Gas

// ✅ 好：批量空投（1次交易，共享基础费）
// 100人空投 ≈ 21000 + 100 * 35000 = 3,521,000 Gas（节省46%）
function batchTransfer(
    address[] calldata recipients,  // calldata 比 memory 省 Gas
    uint256[] calldata amounts
) external {
    require(recipients.length == amounts.length, "Length mismatch");
    for (uint256 i; i < recipients.length; ) {
        _transfer(msg.sender, recipients[i], amounts[i]);
        unchecked { ++i; }  // 不可能溢出，省检查
    }
}

Upgradeable contracts

Once a smart contract is deployed, it cannot be modified. But with the Proxy Pattern, we can upgrade the contract logic while keeping the address and state the same.

Proxy model comparison

UUPS can be upgraded to contract implementation

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";

/// @title V1 版本（初始部署）
contract MyContractV1 is Initializable, UUPSUpgradeable, OwnableUpgradeable {
    uint256 public value;

    /// @notice 替代构造函数（代理模式不使用 constructor）
    function initialize() public initializer {
        __Ownable_init(msg.sender);
        __UUPSUpgradeable_init();
    }

    function setValue(uint256 _value) external {
        value = _value;
    }

    /// @notice 授权升级（仅 owner 可升级）
    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
}

/// @title V2 版本（升级后）
contract MyContractV2 is Initializable, UUPSUpgradeable, OwnableUpgradeable {
    uint256 public value;
    uint256 public newFeature;  // 新增状态变量（只能追加，不能修改已有布局）

    function initialize() public initializer {
        __Ownable_init(msg.sender);
        __UUPSUpgradeable_init();
    }

    function setValue(uint256 _value) external {
        value = _value;
    }

    // V2 新增功能
    function setNewFeature(uint256 _feature) external {
        newFeature = _feature;
    }

    function getVersion() external pure returns (string memory) {
        return "v2.0.0";
    }

    function _authorizeUpgrade(address) internal override onlyOwner {}
}

Security and vulnerability protection

Smart contracts directly manage funds, and security breaches can lead to millions of dollars in irreversible losses. Here are the most common types of attacks and their protections.

Top 10 Contract Security Risks

Safety checklist

• External calls: Check the return value after all external calls; Use SafeERC20 to handle non-standard tokens
• Permission control: Add onlyOwner/AccessControl to the key function; The initializer modifier is added to the initializer modifier
• Enter verification: Validate all parameter ranges; Check that the address is non-zero; Verify array length
• State consistency: Use invariant checks to ensure that the contract state is always legitimate
• Emergency mechanisms: Implement Pausable pause; Set up an emergency withdrawal function
• Front-end protection: EIP-712 Structured Signatures; Clearly display the signature content to prevent blind signing

Test & Debug

The unmodifiable nature of contract code determines that testing is far more important than traditional software. 100% test coverage is the industry minimum.

Test type

Hardhat unit test example

// test/StakingRewards.test.ts
import { expect } from "chai";
import { ethers } from "hardhat";
import { time, loadFixture } from "@nomicfoundation/hardhat-network-helpers";

describe("StakingRewards", function () {
  async function deployFixture() {
    const [owner, user1, user2] = await ethers.getSigners();
    const Token = await ethers.getContractFactory("MockERC20");
    const stakingToken = await Token.deploy("Staking", "STK", ethers.parseEther("1000000"));
    const rewardToken = await Token.deploy("Reward", "RWD", ethers.parseEther("1000000"));

    const Staking = await ethers.getContractFactory("StakingRewards");
    const staking = await Staking.deploy(
      await stakingToken.getAddress(),
      await rewardToken.getAddress(),
      ethers.parseEther("1") // 1 token/sec
    );

    // 分发代币
    await stakingToken.transfer(user1.address, ethers.parseEther("10000"));
    await rewardToken.transfer(await staking.getAddress(), ethers.parseEther("100000"));

    return { staking, stakingToken, rewardToken, owner, user1, user2 };
  }

  it("should accumulate rewards over time", async function () {
    const { staking, stakingToken, user1 } = await loadFixture(deployFixture);

    // 质押
    await stakingToken.connect(user1).approve(await staking.getAddress(), ethers.parseEther("1000"));
    await staking.connect(user1).stake(ethers.parseEther("1000"));

    // 前进 100 秒
    await time.increase(100);

    // 验证奖励累积
    const earned = await staking.earned(user1.address);
    expect(earned).to.be.closeTo(ethers.parseEther("100"), ethers.parseEther("1"));
  });

  it("should revert on zero stake", async function () {
    const { staking, user1 } = await loadFixture(deployFixture);
    await expect(staking.connect(user1).stake(0)).to.be.revertedWith("Cannot stake 0");
  });
});

Foundry fuzzing example

// test/StakingRewards.t.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "forge-std/Test.sol";
import "../src/StakingRewards.sol";

contract StakingFuzzTest is Test {
    StakingRewards staking;

    function setUp() public {
        // ... 部署合约
    }

    /// @notice 模糊测试：任意金额质押后，提取不能超过质押量
    function testFuzz_WithdrawCannotExceedStaked(uint256 stakeAmount, uint256 withdrawAmount) public {
        // 限制输入范围
        stakeAmount = bound(stakeAmount, 1, 1_000_000 ether);
        withdrawAmount = bound(withdrawAmount, stakeAmount + 1, type(uint256).max);

        // 质押
        deal(address(stakingToken), address(this), stakeAmount);
        stakingToken.approve(address(staking), stakeAmount);
        staking.stake(stakeAmount);

        // 超额提取应该失败
        vm.expectRevert("Exceeds staked");
        staking.withdraw(withdrawAmount);
    }
}

Deployment and validation

Contract deployment is a critical step in permanently writing code to the blockchain, requiring careful execution and ensuring that the source code is publicly verifiable.

Deploy checklists

• Compiler version: Locks the exact version (e.g. 0.8.20) to avoid the ^0.8.0 range
• Optimize settings: Records the optimizer runs parameter, which must be exactly the same when verifying
• Constructor parameters: Carefully check the initialization parameters (address, value)
• Network confirmation: Quadratic Confirmation Target Network (mainnet vs testnet)
• Gas estimates: Ensure that the deployment wallet has enough native tokens
• Sign more for approval: Important contracts are deployed through Safe multi-signature

Multi-chain deployment scripts

// scripts/deploy.ts
import { ethers, network, run } from "hardhat";

async function main() {
  const [deployer] = await ethers.getSigners();
  console.log(`Deploying on ${network.name} with ${deployer.address}`);
  console.log(`Balance: ${ethers.formatEther(await ethers.provider.getBalance(deployer.address))} ETH`);

  // 部署合约
  const Contract = await ethers.getContractFactory("MyContract");
  const contract = await Contract.deploy(/* constructor args */);
  await contract.waitForDeployment();

  const address = await contract.getAddress();
  console.log(`Contract deployed: ${address}`);

  // 等待区块确认（Etherscan验证需要）
  console.log("Waiting for confirmations...");
  await contract.deploymentTransaction()?.wait(5);

  // 自动验证源码到 Etherscan
  console.log("Verifying on Etherscan...");
  await run("verify:verify", {
    address,
    constructorArguments: [/* same args */],
  });

  console.log("✅ Deployment & verification complete!");
}

main().catch(console.error);

Post-deployment validation

• Confirm that the contract is validated in Etherscan (green tick)
• Confirm that the contract owner is the expected multisig address
• Execute a test transaction to confirm that the function is normal
• Set up transaction monitoring and alerts on Tenderly
• Update the contract address and ABI in the front-end configuration

Contract audit process

Professional security audits are a necessary step before a contract goes live. The audit not only finds vulnerabilities, but also provides users with confidence guarantees.

Audit process timeline

Well-known audit institutions

Development process and quotation

Based on the delivery experience of the NovaLinkR team in dozens of smart contract projects, the typical contract development process is as follows:

Project quotation reference