スマートコントラクト開発の完全なガイド

スマートコントラクトとは何ですか?

スマートコントラクトとは、ブロックチェーン上に保存されたコンピュータコードの一種で、あらかじめ設定された条件が発動した際に自動的にアクションを実行する一連のルール(契約条件)を定義します。これは人間の介入や第三者の仲介者を信用することなく行われます。

スマートコントラクトの中核機能

スマートコントラクトと従来型コントラクトの比較

主流のスマートコントラクトプラットフォーム

ソリディティ言語基盤

Solidityは、Ethereumおよびすべての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()入力パラメータと前提条件を確認し、失敗した場合は残りのガスを返します
• revert(): 明示的なロールバックトランザクション、カスタムエラーのサポート(カスタムエラー、より省ガス)
• 主張():不変を検証し、失敗は深刻なバグを示します
• トライ/キャッチ外部呼び出しの失敗を検知し、トランザクション全体のロールバックを防ぎます

開発環境の構築

プロフェッショナルなスマートコントラクト開発環境には、コンパイラ、テストフレームワーク、ネイティブブロックチェーン、デプロイツールの協力が必要です。 以下は主流のツールチェーンの比較です:

開発フレームワークの比較

ヘルドハットプロジェクトの初期化

# 创建项目
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.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
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 等协议中的存款
    }
}

設計パターンとアーキテクチャ

成熟したスマートコントラクトプロジェクトは、コードのセキュリティ、保守性、スケーラビリティを確保するために実証済みの設計パターンを使用する必要があります。

コアデザインパターン

工場モデルの実装

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

ガス最適化のヒント

ガス料金はユーザー体験や契約競争力に直接影響を与えます。 ここでは、インタラクションコストを大幅に削減できる実証済みの最適化戦略をご紹介します。

最適化戦略の概要

可変パッケージングの例

// ❌ 差：每个变量占一个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; }  // 不可能溢出，省检查
    }
}

アップグレード可能な契約

一度スマートコントラクトが展開されると、それは変更できません。 しかしプロキシパターンを使えば、アドレスと状態を同じまま契約ロジックをアップグレードできます。

代理モデル比較

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

セキュリティおよび脆弱性保護

スマートコントラクトは資金を直接管理し、セキュリティ侵害は数百万ドルの取り返しのつかない損失をもたらす可能性があります。 ここでは、最も一般的な攻撃の種類とその防御策を紹介します。

契約セキュリティリスクトップ10

安全チェックリスト

• 外部呼び声: すべての外部呼び出し後に返り値を確認します。 非標準トークンの処理にはSafeERC20を使います
• 許可管理: キー関数にonlyOwner/AccessControlを追加; イニショナイザ修飾子はイニショナイザ修飾子に追加されます
• 検証の登場: すべてのパラメータ範囲を検証; アドレスがゼロでないことを確認し、 配列長の検証
• 状態整合性契約状態が常に正当であることを保証するために不変チェックを用いてください
• 緊急対応メカニズム:一時停止を実装; 緊急撤退機能を設置してください
• フロントエンド保護:EIP-712構造化署名; 署名内容を明確に表示し、盲目的署名を防ぎましょう

テストとデバッグ

契約コードの改変不可能な性質から、テストは従来のソフトウェアよりもはるかに重要視されています。 100%のテストカバレッジが業界最低限の基準です。

テストタイプ

ハードハットユニットテストの例

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

ファウンドリーファジングの例

// 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.0の範囲を避けるために正確なバージョン(例:0.8.20)をロックします
• 設定の最適化:は最適化装置の実行パラメータを記録し、検証時に完全に同じでなければなりません
• コンストラクタパラメータ:初期化パラメータ(アドレス、値)を慎重に確認してください
• ネットワーク確認:二次確認ターゲットネットワーク(メインネット対テストネット)
• ガス推定:デプロイメントウォレットに十分なネイティブトークンがあることを確認しましょう
• 承認のためにさらに署名してください重要な契約は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で有効であること(緑のチェック)
• 契約者が期待されるマルチシグアドレスであることを確認しましょう
• 関数が正常であることを確認するためにテストトランザクションを実行します
• Tenderlyで取引監視とアラートを設定しましょう
• フロントエンド構成で契約アドレスとABIを更新してください

契約監査プロセス

専門的なセキュリティ監査は契約が発動する前に必要なステップです。 この監査は脆弱性を見つけるだけでなく、ユーザーに信頼保証を提供します。

監査プロセスのタイムライン

著名な監査機関

開発プロセスと見積もり

NovaLinkRチームの数十件のスマートコントラクトプロジェクトでのデリバリー経験に基づくと、典型的な契約開発プロセスは以下の通りです。

プロジェクト引用文献