智能合约开发完全指南

什么是智能合约

智能合约是存储在区块链上的一段计算机程序代码，它定义了一组规则（合约条款），当预设条件被触发时，合约会自动执行相应操作——无需人工干预、无需信任第三方中介。

智能合约的核心特征

智能合约与传统合同的对比

主流智能合约平台

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团队数十个智能合约项目的交付经验，典型的合约开发流程如下：

项目报价参考