智能合約開發完全指南

什麼是智能合約

智能合約是存儲在區塊鏈上的一段計算機程序代碼，它定義了一組規則（合約條款），當預設條件被觸發時，合約會自動執行相應操作——無需人工干預、無需信任第三方中介。

智能合約的核心特徵

智能合約與傳統合同的對比

主流智能合約平臺

Solidity語言基礎

Solidity 是以太坊及所有 EVM 兼容鏈的主流智能合約編程語言。它是一種靜態類型、面向合約的高級語言，語法類似 JavaScript 和 C++。

基本數據類型

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

函數修飾符與可見性

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

事件與日誌

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) => { ... });

錯誤處理

• require()：驗證輸入參數和前置條件，失敗則退還剩餘Gas
• revert()：顯式回滾交易，支持自定義錯誤（Custom Error，更省Gas）
• assert()：驗證不變量（invariant），失敗表示嚴重bug
• try/catch：捕獲外部調用失敗，防止整個交易回滾

開發環境搭建

一個專業的智能合約開發環境需要編譯器、測試框架、本地區塊鏈和部署工具的配合。以下是主流工具鏈對比：

開發框架對比

Hardhat 項目初始化

# 创建项目
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 配置示例

// 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 項目初始化

# 安装 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

合約結構與生命週期

理解合約的完整生命週期是寫出高質量代碼的基礎。從編寫、編譯、部署到交互，每個階段都有其技術要求。

合約生命週期

完整合約模板

// 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標準合約

ERC（Ethereum Request for Comments）是以太坊社區制定的代幣接口標準。遵循標準可確保代幣在不同應用間互操作。

主流ERC標準一覽

ERC-20代幣合約實現

// 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代幣化金庫

// 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 等协议中的存款
    }
}

設計模式與架構

成熟的智能合約項目需要運用經過驗證的設計模式，以確保代碼的安全性、可維護性和可擴展性。

核心設計模式

Factory工廠模式實現

// 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合約開發

DeFi（去中心化金融）是智能合約最複雜也最有價值的應用場景。以下展示核心DeFi模塊的實現思路。

DeFi核心模塊

簡易AMM DEX合約

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

質押挖礦合約

// 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優化技巧

Gas費用直接影響用戶體驗和合約競爭力。以下是經過驗證的優化策略，可顯著降低交互成本。

優化策略總覽

變量打包示例

// ❌ 差：每个变量占一个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;
}

批量操作優化

// ❌ 差：逐笔空投（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; }  // 不可能溢出，省检查
    }
}

可升級合約

智能合約一經部署不可修改。但通過代理模式（Proxy Pattern），我們可以在保持地址和狀態不變的情況下升級合約邏輯。

代理模式對比

UUPS可升級合約實現

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

安全與漏洞防護

智能合約直接管理資金，安全漏洞可能導致數百萬美元不可逆損失。以下是最常見的攻擊類型及防護措施。

Top 10 合約安全風險

安全檢查清單

• 外部調用：所有外部調用後檢查返回值；使用 SafeERC20 處理非標準代幣
• 權限控制：關鍵函數添加 onlyOwner/AccessControl；初始化函數添加 initializer 修飾符
• 輸入驗證：驗證所有參數範圍；檢查地址非零；驗證數組長度
• 狀態一致性：使用 invariant 檢查確保合約狀態始終合法
• 緊急機制：實現 Pausable 暫停功能；設置緊急提款函數
• 前端防護：EIP-712 結構化簽名；清晰展示簽名內容防止盲籤

測試與調試

合約代碼不可修改的特性決定了測試的重要性遠超傳統軟件。100%測試覆蓋率是行業最低標準。

測試類型

Hardhat 單元測試示例

// 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 模糊測試示例

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

部署與驗證

合約部署是將代碼永久寫入區塊鏈的關鍵步驟，需要謹慎執行並確保源碼公開可驗證。

部署檢查清單

• 編譯器版本：鎖定精確版本（如 0.8.20），避免 ^0.8.0 範圍
• 優化設置：記錄 optimizer runs 參數，驗證時需完全一致
• 構造函數參數：仔細確認初始化參數（地址、數值）
• 網絡確認：二次確認目標網絡（mainnet vs testnet）
• Gas 預估：確保部署錢包有足夠的原生代幣
• 多籤審批：重要合約通過 Safe 多籤部署

多鏈部署腳本

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

部署後驗證

• 在 Etherscan 確認合約已驗證（綠色勾標識）
• 確認合約 owner 為預期的多籤地址
• 執行一筆測試交易確認功能正常
• 在 Tenderly 上設置交易監控和告警
• 更新前端配置中的合約地址和 ABI

合約審計流程

專業的安全審計是合約上線前的必要步驟。審計不僅發現漏洞，更為用戶提供信心保障。

審計流程時間線

知名審計機構

開發流程與報價

基於NovaLinkR團隊數十個智能合約項目的交付經驗，典型的合約開發流程如下：

項目報價參考