스마트 계약 개발에 대한 완전한 가이드

스마트 계약이란 무엇인가요?

스마트 계약은 블록체인에 저장된 컴퓨터 코드 조각으로, 미리 설정된 조건이 발동될 때 인간의 개입 없이, 제3자 중개자를 신뢰하지 않고 자동으로 행동을 실행하는 일련의 규칙(계약 조건)을 정의합니다.

스마트 계약의 핵심 기능

스마트 계약과 전통 계약

주류 스마트 계약 플랫폼

Solidity 언어 기반

Solidity는 이더리움과 모든 EVM 호환 체인의 주류 스마트 계약 프로그래밍 언어입니다. 정적 타입, 계약 지향, 고수준 언어로, 자바스크립트와 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(): 입력 매개변수와 전제 조건을 검증하고, 실패하면 남은 가스를 반환합니다
• 되돌리기(): 명시적 롤백 트랜잭션, 사용자 지정 오류 지원(사용자 지정 오류, 더 많은 가스 절감)
• assert(): 불변 검증, 실패는 심각한 버그를 의미합니다
• 트라이/캐치: 외부 호출 실패를 포착하고 전체 트랜잭션이 롤백되는 것을 방지합니다

개발 환경 건설

전문적인 스마트 계약 개발 환경은 컴파일러, 테스트 프레임워크, 네이티브 블록체인, 배포 도구의 협력을 필요로 합니다. 다음은 주류 툴체인 비교입니다:

개발 프레임워크 비교

하드햇 프로젝트 초기화

# 创建项目
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(이더리움 요청 요청)는 이더리움 커뮤니티에서 개발한 토큰 인터페이스 표준입니다. 표준을 준수하면 토큰이 서로 다른 애플리케이션 간에 상호 운용성이 보장됩니다.

주류 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을 사용하세요
• 권한 제어: key에 onlyOwner/AccessControl을 추가; 초기화 수정자가 초기화 수정자에 추가됩니다
• 검증 도입: 모든 매개변수 범위 검증; 주소가 0이 아닌지 확인하고; 배열 길이 검증
• 상태 일관성: 불변 검사를 사용하여 계약 상태가 항상 정당한지 보장한다
• 비상 메커니즘: 일시정지(Pausable pause) 구현; 비상 인출 기능을 설정하세요
• 프론트엔드 보호: 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 팀의 전달 경험을 바탕으로, 일반적인 계약 개발 프로세스는 다음과 같습니다:

프로젝트 견적 참고 문헌