智能合约部署完全指南：从零到上线

目标读者：零基础小白 → 能够独立部署和管理智能合约
学习目标：理解合约的本质、部署流程、地址机制和资金归属
实践要求：完成一次完整的合约部署和交互

---

📚 目录

1. 什么是智能合约？
2. 合约地址的工作原理
3. 如何部署合约到链上
4. 合约地址的获取方式
5. 合约与地址的转账机制
6. 合约的访问权限
7. 合约地址的资金归属
8. 实战案例
9. 常见问题解答

---

1. 什么是智能合约？

1.1 简单理解

智能合约 = 运行在区块链上的程序

想象一下：

• 传统合约：写在纸上的协议，需要律师、法院来执行
• 智能合约：写在代码里的协议，由区块链自动执行，无需第三方

1.2 核心特征

智能合约的特点：
├── 自动执行：满足条件自动运行
├── 不可篡改：部署后代码无法修改（除非是可升级合约）
├── 公开透明：代码和状态都可以查看
├── 去中心化：运行在所有节点上
└── 无需信任：不需要信任任何第三方

1.3 合约 vs 普通账户

特性	EOA（普通账户）	合约账户
控制方式	私钥控制	代码控制
能否发起交易	✅ 可以	❌ 不能
能否被调用	❌ 不能	✅ 可以
是否有代码	❌ 没有	✅ 有
是否有存储	❌ 没有	✅ 有
余额	✅ 有	✅ 有

简单记忆：

• EOA：像你的银行账户，你可以主动转账
• 合约：像自动售货机，你投币（调用）它自动执行

1.4 合约能做什么？

// 合约可以：
1. 存储数据（状态变量）
2. 执行逻辑（函数）
3. 接收 ETH（payable 函数）
4. 发送 ETH（transfer/send/call）
5. 调用其他合约
6. 触发事件（日志）

常见应用场景：

• 💰 代币：ERC-20、ERC-721
• 🏦 DeFi：借贷、交易、流动性
• 🎮 GameFi：游戏逻辑、NFT
• 🗳️ DAO：治理投票
• 📝 存证：数据上链

---

2. 合约地址的工作原理

2.1 什么是合约地址？

合约地址 = 合约在区块链上的唯一标识符

就像：

• 身份证号：唯一标识一个人
• IP 地址：唯一标识一台电脑
• 合约地址：唯一标识一个合约

2.2 地址的生成方式

方式 1：CREATE（传统方式）

合约地址 = keccak256(
  RLP([部署者地址, nonce])
)[12:32]

特点：

• 地址取决于部署者地址和 nonce
• 无法提前预测
• 每次部署地址都不同

示例：

// 部署者地址：0x1234...
// nonce：5
// 生成的合约地址：0xabcd...（无法提前知道）

方式 2：CREATE2（可预测地址）

合约地址 = keccak256(
  0xff ++ 
  部署者地址 ++ 
  salt ++ 
  keccak256(初始化代码)
)[12:32]

特点：

• 可以提前计算地址
• 相同的 salt 和代码会生成相同地址
• 常用于工厂合约、账户抽象

示例：

// 使用 CREATE2 可以提前知道地址
address predictedAddress = address(uint160(uint256(keccak256(
    abi.encodePacked(
        bytes1(0xff),
        address(this),
        salt,
        keccak256(bytecode)
    )
))));

2.3 地址的结构

以太坊地址格式：
├── 长度：20 字节（40 个十六进制字符）
├── 前缀：0x（表示十六进制）
└── 示例：0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb

地址示例：

• ✅ 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb（正确）
• ❌ 0x742d35Cc6634C0532925a3b844Bc9e7595f0bE（39个字符，错误）
• ❌ 742d35Cc6634C0532925a3b844Bc9e7595f0bEb（缺少0x前缀）

2.4 地址的唯一性

重要理解：

• 每个合约地址在链上是唯一的
• 同一个地址不能部署两次
• 地址一旦生成，永久存在（即使合约被销毁）

特殊情况：

// 如果合约被销毁（selfdestruct）
// 地址仍然存在，但：
// - 代码被清空
// - 余额被转移
// - 地址可以重新使用（但很少见）

---

3. 如何部署合约到链上

3.1 部署前的准备

步骤 1：编写合约代码

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

contract SimpleStorage {
    uint256 public value;
    
    constructor(uint256 _initialValue) {
        value = _initialValue;
    }
    
    function setValue(uint256 _newValue) public {
        value = _newValue;
    }
}

步骤 2：编译合约

使用 Hardhat：

npx hardhat compile

使用 Foundry：

forge build

编译产物：

• bytecode：部署到链上的代码
• abi：应用二进制接口（用于前端调用）

步骤 3：准备部署账户

// 需要：
// 1. 有足够 ETH 的账户（支付 Gas）
// 2. 私钥或助记词
// 3. 连接到网络（测试网或主网）

const deployer = {
  address: "0x...",
  privateKey: "0x...", // 或使用助记词
  balance: "0.1 ETH" // 足够支付 Gas
}

3.2 部署方式

方式 1：使用 Hardhat 部署

部署脚本：

// scripts/deploy.js
const { ethers } = require("hardhat");

async function main() {
  // 获取部署者账户
  const [deployer] = await ethers.getSigners();
  console.log("Deploying with account:", deployer.address);
  console.log("Account balance:", (await deployer.provider.getBalance(deployer.address)).toString());

  // 获取合约工厂
  const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
  
  // 部署合约（传入构造函数参数）
  const simpleStorage = await SimpleStorage.deploy(100);
  
  // 等待部署完成
  await simpleStorage.waitForDeployment();
  
  // 获取合约地址
  const address = await simpleStorage.getAddress();
  console.log("Contract deployed to:", address);
  
  // 验证部署
  const value = await simpleStorage.value();
  console.log("Initial value:", value.toString());
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

执行部署：

# 部署到本地网络
npx hardhat run scripts/deploy.js

# 部署到测试网
npx hardhat run scripts/deploy.js --network sepolia

# 部署到主网
npx hardhat run scripts/deploy.js --network mainnet

方式 2：使用 Foundry 部署

部署脚本：

// script/Deploy.s.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "forge-std/Script.sol";
import "../src/SimpleStorage.sol";

contract DeployScript is Script {
    function run() external {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        vm.startBroadcast(deployerPrivateKey);
        
        SimpleStorage simpleStorage = new SimpleStorage(100);
        
        console.log("Contract deployed to:", address(simpleStorage));
        
        vm.stopBroadcast();
    }
}

执行部署：

# 设置环境变量
export PRIVATE_KEY=your_private_key
export RPC_URL=https://sepolia.infura.io/v3/your_key

# 部署
forge script script/Deploy.s.sol --rpc-url $RPC_URL --broadcast

方式 3：使用 Remix IDE（最简单）

步骤：

1. 访问 https://remix.ethereum.org
2. 创建新文件，粘贴合约代码
3. 编译合约（Compile）
4. 切换到部署标签（Deploy）
5. 选择环境（Injected Provider - MetaMask）
6. 点击 Deploy
7. 在 MetaMask 中确认交易
8. 等待部署完成，获取合约地址

优点：

• 无需安装工具
• 适合快速测试
• 图形界面友好

3.3 部署过程详解

部署交易的结构

{
  from: "0x部署者地址",
  to: null, // 部署时 to 为空
  value: 0, // 可以附带 ETH
  data: "0x6080604052...", // 合约字节码 + 构造函数参数
  gasLimit: 2000000,
  gasPrice: 20000000000
}

部署流程

1. 创建部署交易
   ↓
2. 签名交易（用私钥）
   ↓
3. 广播到网络
   ↓
4. 进入内存池（pending）
   ↓
5. 矿工打包进区块
   ↓
6. 执行部署：
   - 创建合约账户
   - 执行构造函数
   - 存储字节码
   - 返回合约地址
   ↓
7. 获得交易回执（receipt）
   - contractAddress: 新合约地址
   - status: 成功/失败

部署成本

部署成本 = Gas Used × Gas Price

典型成本：
├── 简单合约：~100,000 gas
├── 中等合约：~500,000 gas
├── 复杂合约：~2,000,000+ gas
└── 主网费用：$10 - $500+（取决于 Gas 价格）

3.4 验证部署成功

方法 1：检查交易回执

const receipt = await deployTx.wait();
console.log("Contract address:", receipt.contractAddress);
console.log("Status:", receipt.status === 1 ? "Success" : "Failed");

方法 2：在区块浏览器查看

1. 访问 Etherscan（主网）或 Sepolia Etherscan（测试网）
2. 输入交易哈希（txHash）
3. 查看：
   - To: Contract Creation
   - Contract Address: 新创建的地址
   - 可以查看合约代码和状态

方法 3：调用合约验证

// 尝试调用合约函数
const value = await simpleStorage.value();
console.log("Value:", value.toString()); // 应该返回初始值 100

---

4. 合约地址的获取方式

4.1 部署时获取

方式 1：从部署返回值获取

// Hardhat/Ethers.js
const contract = await SimpleStorage.deploy(100);
await contract.waitForDeployment();
const address = await contract.getAddress();
console.log("Contract address:", address);

// Foundry
SimpleStorage simpleStorage = new SimpleStorage(100);
address contractAddress = address(simpleStorage);
console.log("Contract address:", contractAddress);

方式 2：从交易回执获取

const deployTx = await SimpleStorage.deploy(100);
const receipt = await deployTx.wait();
const contractAddress = receipt.contractAddress;
console.log("Contract address:", contractAddress);

4.2 从区块浏览器获取

步骤：

1. 找到部署交易哈希（txHash）
2. 在 Etherscan 输入 txHash
3. 查看 “Contract Creation” 部分
4. 点击合约地址链接

示例：

交易哈希：0x1234abcd...
区块浏览器：https://sepolia.etherscan.io/tx/0x1234abcd...
合约地址：0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb

4.3 从事件日志获取

// 合约中定义事件
event ContractDeployed(address indexed contractAddress, address indexed deployer);

// 部署时触发事件
emit ContractDeployed(address(this), msg.sender);

// 监听事件获取地址
const filter = contract.filters.ContractDeployed();
const events = await contract.queryFilter(filter);
const contractAddress = events[0].args.contractAddress;

4.4 使用 CREATE2 提前计算

// 在部署前计算地址
function computeAddress(bytes32 salt, bytes memory bytecode) 
    public 
    view 
    returns (address) 
{
    return address(uint160(uint256(keccak256(
        abi.encodePacked(
            bytes1(0xff),
            address(this), // 部署者
            salt,
            keccak256(bytecode)
        )
    ))));
}

---

5. 合约与地址的转账机制

5.1 用户地址 → 合约地址

方式 1：直接转账（合约有 receive/fallback）

// 合约代码
contract ReceiveETH {
    // 接收 ETH 的函数
    receive() external payable {
        // 当直接发送 ETH 时调用
    }
    
    // 备用函数
    fallback() external payable {
        // 当调用不存在的函数时调用
    }
}

// 前端代码
// 方式 1：直接转账
await signer.sendTransaction({
  to: contractAddress,
  value: ethers.parseEther("1.0") // 发送 1 ETH
});

// 方式 2：调用 payable 函数
await contract.deposit({ value: ethers.parseEther("1.0") });

重要：

• 如果合约没有 receive() 或 fallback()，直接转账会失败
• 必须使用 payable 函数来接收 ETH

方式 2：调用 payable 函数

contract Bank {
    mapping(address => uint256) public balances;
    
    // payable 函数可以接收 ETH
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }
}

// 调用时附带 ETH
await contract.deposit({
  value: ethers.parseEther("1.0") // 发送 1 ETH
});

转账流程

用户发起转账
   ↓
钱包签名交易
   ↓
交易包含：
  - to: 合约地址
  - value: 转账金额
  - data: 函数调用（如果有）
   ↓
交易上链
   ↓
合约接收 ETH
   ↓
更新合约状态（如余额）

5.2 合约地址 → 用户地址

方式 1：使用 transfer

contract Bank {
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        
        // 转账给用户
        payable(msg.sender).transfer(amount);
    }
}

特点：

• Gas 限制：2300 gas
• 失败会 revert
• 安全性高

方式 2：使用 send

bool success = payable(msg.sender).send(amount);
require(success, "Transfer failed");

特点：

• Gas 限制：2300 gas
• 失败返回 false，不会 revert
• 不推荐使用

方式 3：使用 call（推荐）

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

特点：

• 无 Gas 限制
• 更灵活
• 需要防止重入攻击

完整示例：安全的提款函数

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract Bank is ReentrancyGuard {
    mapping(address => uint256) public balances;
    
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }
    
    function withdraw(uint256 amount) public nonReentrant {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        
        // 先更新状态（CEI 模式）
        balances[msg.sender] -= amount;
        
        // 再转账（防止重入攻击）
        (bool success, ) = payable(msg.sender).call{value: amount}("");
        require(success, "Transfer failed");
    }
}

5.3 转账的 Gas 成本

转账成本：
├── 普通转账：21,000 gas
├── 合约调用转账：21,000 + 函数执行 gas
└── 复杂逻辑：可能数万 gas

5.4 转账状态检查

// 检查转账是否成功
const tx = await contract.withdraw(amount);
const receipt = await tx.wait();

if (receipt.status === 1) {
  console.log("转账成功！");
} else {
  console.log("转账失败！");
}

// 检查余额变化
const balanceBefore = await provider.getBalance(userAddress);
// ... 等待交易确认
const balanceAfter = await provider.getBalance(userAddress);
console.log("余额变化:", balanceAfter - balanceBefore);

---

6. 合约的访问权限

6.1 所有人都可以调用吗？

答案：取决于函数可见性

contract AccessControl {
    // ✅ 所有人都可以调用
    function publicFunction() public {
        // 任何人都可以调用
    }
    
    // ✅ 外部可以调用，内部不能直接调用
    function externalFunction() external {
        // 外部可以调用
    }
    
    // ❌ 只有合约内部可以调用
    function internalFunction() internal {
        // 内部或继承合约可以调用
    }
    
    // ❌ 只有当前合约可以调用
    function privateFunction() private {
        // 只有当前合约可以调用
    }
}

6.2 权限控制

方式 1：onlyOwner 模式

import "@openzeppelin/contracts/access/Ownable.sol";

contract MyContract is Ownable {
    // 只有 owner 可以调用
    function adminFunction() public onlyOwner {
        // 只有部署者（owner）可以调用
    }
    
    // 转移所有权
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }
}

方式 2：角色控制

import "@openzeppelin/contracts/access/AccessControl.sol";

contract MyContract is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    
    constructor() {
        _grantRole(ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
    }
    
    // 只有 ADMIN 可以调用
    function adminFunction() public onlyRole(ADMIN_ROLE) {
        // ...
    }
    
    // 只有 MINTER 可以调用
    function mint() public onlyRole(MINTER_ROLE) {
        // ...
    }
}

方式 3：自定义权限

contract MyContract {
    mapping(address => bool) public authorized;
    address public owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    modifier onlyAuthorized() {
        require(authorized[msg.sender] || msg.sender == owner, "Not authorized");
        _;
    }
    
    function addAuthorized(address account) public {
        require(msg.sender == owner, "Not owner");
        authorized[account] = true;
    }
    
    function restrictedFunction() public onlyAuthorized {
        // 只有授权地址可以调用
    }
}

6.3 实际案例

案例 1：公开的代币合约

contract PublicToken is ERC20 {
    // ✅ 所有人都可以转账
    function transfer(address to, uint256 amount) public override returns (bool) {
        // 任何人都可以调用
        return super.transfer(to, amount);
    }
    
    // ✅ 所有人都可以查询余额
    function balanceOf(address account) public view override returns (uint256) {
        // 任何人都可以查询
        return super.balanceOf(account);
    }
    
    // ❌ 只有 owner 可以铸造
    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

案例 2：受限的银行合约

contract RestrictedBank {
    mapping(address => uint256) public balances;
    bool public paused = false;
    
    modifier whenNotPaused() {
        require(!paused, "Contract is paused");
        _;
    }
    
    // ✅ 所有人都可以存款
    function deposit() public payable whenNotPaused {
        balances[msg.sender] += msg.value;
    }
    
    // ✅ 只有账户所有者可以取款
    function withdraw(uint256 amount) public whenNotPaused {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }
    
    // ❌ 只有 owner 可以暂停
    function pause() public onlyOwner {
        paused = true;
    }
}

6.4 权限检查流程

用户调用函数
   ↓
检查函数可见性（public/external/internal/private）
   ↓
检查修饰符（onlyOwner/onlyRole/自定义）
   ↓
检查条件（require/if）
   ↓
执行函数逻辑
   ↓
返回结果

---

7. 合约地址的资金归属

7.1 核心问题：转到合约地址的钱算谁的？

答案：属于合约地址本身，但由合约代码控制

7.2 资金归属的三种情况

情况 1：合约有明确的资金管理逻辑

contract Bank {
    mapping(address => uint256) public balances;
    
    // 用户存款
    function deposit() public payable {
        balances[msg.sender] += msg.value;
        // 资金属于合约，但记录在用户的余额中
    }
    
    // 用户取款
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
        // 资金从合约转回用户
    }
}

说明：

• 合约地址的余额 = 所有用户存款的总和
• 每个用户的余额记录在 balances 映射中
• 用户可以通过 withdraw() 取回自己的资金

情况 2：合约没有资金管理逻辑

contract SimpleContract {
    uint256 public value;
    
    // 没有 receive/fallback，无法直接接收 ETH
    // 如果有人强制发送（selfdestruct），ETH 会留在合约中
}

问题：

• 如果 ETH 被发送到合约，但合约没有提取函数
• ETH 会永久锁定在合约中
• 无法取回（除非合约有提取函数）

情况 3：合约有提取函数

contract Withdrawable {
    address public owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    // 接收 ETH
    receive() external payable {}
    
    // 只有 owner 可以提取
    function withdraw() public {
        require(msg.sender == owner, "Not owner");
        payable(owner).transfer(address(this).balance);
    }
}

说明：

• 任何人都可以发送 ETH 到合约
• 只有 owner 可以提取
• 资金属于合约，但 owner 有提取权限

7.3 资金归属的判定规则

资金归属判定：
├── 合约地址的余额 = 合约账户的 ETH 余额
├── 如果合约有映射记录 → 资金属于映射中的用户
├── 如果合约有提取函数 → owner/授权地址可以提取
├── 如果合约没有提取函数 → 资金可能被锁定
└── 最终控制权 = 合约代码的逻辑

7.4 实际案例分析

案例 1：Uniswap 流动性池

// 简化示例
contract UniswapPool {
    mapping(address => uint256) public liquidity;
    
    function addLiquidity() public payable {
        liquidity[msg.sender] += msg.value;
        // 资金属于合约，但记录在用户的流动性中
    }
    
    function removeLiquidity(uint256 amount) public {
        require(liquidity[msg.sender] >= amount);
        liquidity[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
        // 用户可以取回自己的流动性
    }
}

资金归属：

• 合约地址的 ETH = 所有流动性提供者的资金总和
• 每个提供者的份额记录在 liquidity 映射中
• 提供者可以随时取回自己的份额

案例 2：多签钱包

contract MultiSigWallet {
    address[] public owners;
    uint256 public required;
    
    struct Transaction {
        address to;
        uint256 value;
        bool executed;
        mapping(address => bool) approvals;
    }
    
    // 接收 ETH
    receive() external payable {}
    
    // 提交交易
    function submitTransaction(address to, uint256 value) public {
        // 创建交易提案
    }
    
    // 批准交易
    function approveTransaction(uint256 txId) public {
        // 需要足够多的 owner 批准
    }
    
    // 执行交易
    function executeTransaction(uint256 txId) public {
        // 只有达到 required 数量的批准才能执行
        payable(transaction.to).transfer(transaction.value);
    }
}

资金归属：

• 资金属于多签钱包合约
• 只有达到 required 数量的 owner 批准才能转出
• 没有单个 owner 可以单独控制资金

案例 3：锁定的资金（错误示例）

contract LockedFunds {
    // ❌ 错误：没有提取函数
    // 如果有人发送 ETH，资金会被永久锁定
    
    function doSomething() public {
        // 某些逻辑，但不涉及资金提取
    }
}

问题：

• 如果 ETH 被发送到合约
• 合约没有提取函数
• 资金永久锁定，无法取回

7.5 如何查看合约资金

方法 1：区块浏览器

1. 访问 Etherscan
2. 输入合约地址
3. 查看 "Balance" 字段
4. 查看 "Transactions" 了解资金流向

方法 2：代码查询

// 查询合约余额
const balance = await provider.getBalance(contractAddress);
console.log("Contract balance:", ethers.formatEther(balance), "ETH");

// 查询用户在该合约中的余额（如果有映射）
const userBalance = await contract.balances(userAddress);
console.log("User balance in contract:", ethers.formatEther(userBalance));

7.6 资金安全建议

资金安全建议：
├── 1. 明确资金归属逻辑
├── 2. 提供提取函数（如果需要）
├── 3. 使用多签管理大额资金
├── 4. 添加紧急暂停功能
├── 5. 充分测试资金提取逻辑
└── 6. 审计合约代码

---

8. 实战案例

案例 1：完整的银行合约部署

步骤 1：编写合约

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

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

contract Bank is ReentrancyGuard, Ownable {
    mapping(address => uint256) public balances;
    
    event Deposit(address indexed user, uint256 amount);
    event Withdraw(address indexed user, uint256 amount);
    
    // 接收 ETH
    receive() external payable {
        deposit();
    }
    
    // 存款（所有人都可以调用）
    function deposit() public payable {
        require(msg.value > 0, "Must send ETH");
        balances[msg.sender] += msg.value;
        emit Deposit(msg.sender, msg.value);
    }
    
    // 取款（只有账户所有者可以调用）
    function withdraw(uint256 amount) public nonReentrant {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
        emit Withdraw(msg.sender, amount);
    }
    
    // 查询余额
    function getBalance() public view returns (uint256) {
        return balances[msg.sender];
    }
    
    // 查询合约总余额（只有 owner 可以调用）
    function getContractBalance() public view onlyOwner returns (uint256) {
        return address(this).balance;
    }
}

步骤 2：编写测试

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Bank", function () {
  let bank;
  let owner, user1, user2;

  beforeEach(async function () {
    [owner, user1, user2] = await ethers.getSigners();
    const Bank = await ethers.getContractFactory("Bank");
    bank = await Bank.deploy();
    await bank.waitForDeployment();
  });

  it("Should allow deposit", async function () {
    await bank.connect(user1).deposit({ value: ethers.parseEther("1.0") });
    expect(await bank.getBalance()).to.equal(ethers.parseEther("1.0"));
  });

  it("Should allow withdraw", async function () {
    await bank.connect(user1).deposit({ value: ethers.parseEther("1.0") });
    await bank.connect(user1).withdraw(ethers.parseEther("0.5"));
    expect(await bank.getBalance()).to.equal(ethers.parseEther("0.5"));
  });

  it("Should prevent withdraw without balance", async function () {
    await expect(
      bank.connect(user1).withdraw(ethers.parseEther("1.0"))
    ).to.be.revertedWith("Insufficient balance");
  });
});

步骤 3：部署脚本

// scripts/deploy-bank.js
const { ethers } = require("hardhat");

async function main() {
  const [deployer] = await ethers.getSigners();
  console.log("Deploying with account:", deployer.address);
  
  const Bank = await ethers.getContractFactory("Bank");
  const bank = await Bank.deploy();
  
  await bank.waitForDeployment();
  const address = await bank.getAddress();
  
  console.log("Bank deployed to:", address);
  console.log("Deployer address:", deployer.address);
  
  // 验证部署
  const contractBalance = await bank.getContractBalance();
  console.log("Contract balance:", ethers.formatEther(contractBalance), "ETH");
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

步骤 4：部署到测试网

# 设置网络配置（hardhat.config.js）
module.exports = {
  networks: {
    sepolia: {
      url: `https://sepolia.infura.io/v3/${process.env.INFURA_KEY}`,
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

# 部署
npx hardhat run scripts/deploy-bank.js --network sepolia

步骤 5：交互示例

// 前端交互代码
import { ethers } from "ethers";

const contractAddress = "0x..."; // 部署后的合约地址
const abi = [...]; // 合约 ABI

// 连接合约
const provider = new ethers.providers.Web3Provider(window.ethereum);
const signer = provider.getSigner();
const bank = new ethers.Contract(contractAddress, abi, signer);

// 存款
async function deposit() {
  const tx = await bank.deposit({ value: ethers.parseEther("1.0") });
  await tx.wait();
  console.log("Deposit successful!");
}

// 取款
async function withdraw(amount) {
  const tx = await bank.withdraw(ethers.parseEther(amount));
  await tx.wait();
  console.log("Withdraw successful!");
}

// 查询余额
async function getBalance() {
  const balance = await bank.getBalance();
  console.log("Balance:", ethers.formatEther(balance), "ETH");
}

案例 2：查看已部署的合约

// 已知合约地址，如何交互
const contractAddress = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb";

// 1. 查询合约余额
const balance = await provider.getBalance(contractAddress);
console.log("Contract balance:", ethers.formatEther(balance));

// 2. 查询合约代码（是否已部署）
const code = await provider.getCode(contractAddress);
if (code === "0x") {
  console.log("Not a contract address");
} else {
  console.log("Contract deployed, code length:", code.length);
}

// 3. 调用合约函数（需要 ABI）
const contract = new ethers.Contract(contractAddress, abi, signer);
const value = await contract.value();
console.log("Value:", value.toString());

---

9. 常见问题解答

Q1: 合约部署后可以修改吗？

答案：取决于合约设计

不可变合约：
- 部署后代码无法修改
- 更安全，用户更信任
- 如果需要修复 bug，需要重新部署

可升级合约：
- 使用代理模式（Proxy Pattern）
- 可以升级逻辑合约
- 需要谨慎设计，有安全风险

Q2: 部署合约需要多少 Gas？

答案：取决于合约复杂度

简单合约：~100,000 gas
中等合约：~500,000 gas
复杂合约：~2,000,000+ gas

主网费用（以 20 gwei 计算）：
- 简单合约：~$2-10
- 中等合约：~$10-50
- 复杂合约：~$50-500+

Q3: 合约地址和普通地址有什么区别？

答案：

合约地址：
- 有代码（bytecode）
- 可以被调用
- 不能主动发起交易
- 有存储空间

普通地址（EOA）：
- 没有代码
- 可以主动发起交易
- 不能被调用
- 没有存储空间（只有余额和 nonce）

如何区分：

// 检查地址是否有代码
const code = await provider.getCode(address);
if (code === "0x") {
  console.log("这是普通地址（EOA）");
} else {
  console.log("这是合约地址");
}

Q4: 如何确保合约地址的唯一性？

答案：

CREATE 方式：
- 地址 = f(部署者地址, nonce)
- 同一个部署者，nonce 不同，地址不同
- 无法提前预测

CREATE2 方式：
- 地址 = f(部署者地址, salt, 代码哈希)
- 相同的 salt 和代码会生成相同地址
- 可以提前计算
- 常用于工厂合约

Q5: 合约可以接收 ETH 吗？

答案：可以，但需要实现 receive() 或 fallback() 函数

// ✅ 可以接收 ETH
contract CanReceive {
    receive() external payable {}
}

// ❌ 不能直接接收 ETH（会失败）
contract CannotReceive {
    // 没有 receive/fallback
}

Q6: 如何从合约中提取资金？

答案：取决于合约设计

情况 1：合约有提取函数
- 调用 withdraw() 函数
- 需要满足权限要求

情况 2：合约没有提取函数
- 资金可能被永久锁定
- 无法取回（除非使用 selfdestruct，但需要权限）

情况 3：多签合约
- 需要足够的签名批准
- 然后执行提取交易

Q7: 部署合约后如何验证源代码？

答案：在区块浏览器验证

步骤：
1. 访问 Etherscan
2. 输入合约地址
3. 点击 "Contract" 标签
4. 点击 "Verify and Publish"
5. 选择编译器版本
6. 粘贴源代码
7. 点击验证

验证后：
- 可以查看源代码
- 可以在浏览器中直接调用函数
- 提高透明度

Q8: 合约部署失败怎么办？

答案：检查常见问题

可能原因：
1. Gas 不足
   - 增加 Gas Limit
   - 检查账户余额

2. 构造函数参数错误
   - 检查参数类型和数量
   - 验证参数值

3. 合约代码错误
   - 编译错误
   - 运行时错误

4. 网络问题
   - RPC 节点不稳定
   - 切换到其他 RPC

5. 非ce 错误
   - 检查 nonce 是否正确
   - 等待之前的交易确认

Q9: 如何测试合约部署？

答案：使用测试网

推荐流程：
1. 本地测试（Hardhat/Foundry）
2. 测试网部署（Sepolia/Goerli）
3. 测试网验证功能
4. 主网部署（谨慎）

测试网优势：
- 免费（水龙头获取测试币）
- 可以反复测试
- 不影响真实资产

Q10: 合约部署后如何升级？

答案：使用代理模式

// 代理合约（存储数据）
contract Proxy {
    address public implementation; // 逻辑合约地址
    
    function upgrade(address newImplementation) public {
        // 只有 owner 可以升级
        implementation = newImplementation;
    }
    
    fallback() external {
        // 委托调用逻辑合约
        address impl = implementation;
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
}

注意事项：

• 存储布局必须兼容
• 需要多签和时间锁
• 充分测试升级逻辑

---

10. 高级主题

10.1 合约工厂模式

什么是工厂模式？

使用一个合约来部署多个其他合约

contract TokenFactory {
    address[] public deployedTokens;
    
    function createToken(string memory name, string memory symbol) public {
        Token newToken = new Token(name, symbol);
        deployedTokens.push(address(newToken));
    }
    
    function getDeployedTokens() public view returns (address[] memory) {
        return deployedTokens;
    }
}

优势：

• 批量部署
• 统一管理
• 可以使用 CREATE2 预测地址

10.2 最小代理（EIP-1167）

什么是最小代理？

轻量级的代理合约，用于克隆合约

// 最小代理代码（只有 55 字节）
// 用于克隆合约，节省 Gas

使用场景：

• 需要部署大量相似合约
• 节省部署成本
• 统一升级逻辑

10.3 合约自毁（selfdestruct）

什么是 selfdestruct？

销毁合约，将余额发送到指定地址

contract Destructible {
    address public owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    function destroy() public {
        require(msg.sender == owner, "Not owner");
        selfdestruct(payable(owner));
    }
}

注意事项：

• 需要权限控制
• 余额会发送到指定地址
• 代码会被清空
• 地址仍然存在（但无法调用）

10.4 合约验证和源代码

为什么需要验证？

验证的好处：
├── 提高透明度
├── 增强信任
├── 方便调试
└── 可以在浏览器中调用

验证方法：

# 使用 Hardhat 插件
npm install --save-dev @nomiclabs/hardhat-etherscan

# hardhat.config.js
require("@nomiclabs/hardhat-etherscan");

module.exports = {
  etherscan: {
    apiKey: "YOUR_ETHERSCAN_API_KEY"
  }
};

# 验证
npx hardhat verify --network sepolia DEPLOYED_CONTRACT_ADDRESS "Constructor argument 1"

10.5 Gas 优化技巧

优化部署 Gas：

// ❌ 浪费 Gas
contract Bad {
    uint256 public a = 1;
    uint256 public b = 2;
    uint256 public c = 3;
}

// ✅ 节省 Gas（使用 packed storage）
contract Good {
    uint128 public a = 1;  // 16 字节
    uint128 public b = 2;  // 16 字节
    uint256 public c = 3;  // 32 字节
    // a 和 b 可以打包在一个 slot 中
}

优化技巧：

• 使用库减少代码重复
• 优化存储布局
• 使用事件替代存储
• 避免循环和复杂计算

---

11. 安全最佳实践

11.1 部署前检查清单

部署前必须检查：
├── [ ] 代码已通过测试
├── [ ] 使用静态分析工具（Slither）
├── [ ] 代码已审计（大额资金）
├── [ ] 权限设置正确
├── [ ] 没有硬编码的地址
├── [ ] Gas 优化合理
├── [ ] 错误处理完善
├── [ ] 事件记录完整
└── [ ] 文档齐全

11.2 常见部署错误

错误 1：忘记设置 owner

// ❌ 错误
contract Bad {
    function adminFunction() public {
        // 没有权限检查，任何人都可以调用
    }
}

// ✅ 正确
contract Good {
    address public owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }
    
    function adminFunction() public onlyOwner {
        // 只有 owner 可以调用
    }
}

错误 2：构造函数参数错误

// ❌ 错误：参数类型不匹配
constructor(uint256 initialValue) {
    value = initialValue;
}
// 部署时传入字符串会失败

// ✅ 正确：明确参数类型
constructor(uint256 initialValue) {
    require(initialValue > 0, "Invalid value");
    value = initialValue;
}

错误 3：没有处理资金提取

// ❌ 错误：资金可能被锁定
contract Bad {
    receive() external payable {}
    // 没有提取函数，资金无法取回
}

// ✅ 正确：提供提取函数
contract Good {
    address public owner;
    
    receive() external payable {}
    
    function withdraw() public {
        require(msg.sender == owner, "Not owner");
        payable(owner).transfer(address(this).balance);
    }
}

11.3 多签部署

为什么使用多签？

单签风险：
- 私钥泄露 → 资金被盗
- 个人失误 → 错误操作
- 单点故障

多签优势：
- 需要多个签名才能操作
- 提高安全性
- 适合团队管理

推荐工具：

• Gnosis Safe（最流行）
• OpenZeppelin Defender
• 自定义多签合约

---

12. 工具和资源

12.1 部署工具

Hardhat

• 网址：https://hardhat.org
• 特点：JavaScript/TypeScript，生态丰富
• 适合：前端开发者

Foundry

• 网址：https://book.getfoundry.sh
• 特点：Rust 编写，速度快
• 适合：合约开发者

Remix IDE

• 网址：https://remix.ethereum.org
• 特点：在线 IDE，无需安装
• 适合：快速测试

12.2 区块浏览器

主网：

• Etherscan：https://etherscan.io
• Blockscout：https://blockscout.com

测试网：

• Sepolia Explorer：https://sepolia.etherscan.io
• Goerli Explorer：https://goerli.etherscan.io

12.3 RPC 服务

推荐服务：

• Alchemy：https://www.alchemy.com
• Infura：https://www.infura.io
• QuickNode：https://www.quicknode.com
• Public RPC：https://cloudflare-eth.com（免费但有限制）

12.4 学习资源

官方文档：

• Solidity 文档：https://docs.soliditylang.org
• Ethereum 文档：https://ethereum.org/developers
• OpenZeppelin 文档：https://docs.openzeppelin.com

教程：

• CryptoZombies：https://cryptozombies.io
• Buildspace：https://buildspace.so

---

13. 总结

13.1 核心要点回顾

智能合约部署核心要点：

1. 什么是合约？
   - 运行在区块链上的程序
   - 自动执行，不可篡改

2. 合约地址如何生成？
   - CREATE：基于部署者和 nonce
   - CREATE2：可预测地址

3. 如何部署？
   - 编写代码 → 编译 → 部署 → 验证

4. 如何获取地址？
   - 部署返回值
   - 交易回执
   - 区块浏览器

5. 转账机制？
   - 用户 → 合约：直接转账或调用 payable 函数
   - 合约 → 用户：transfer/send/call

6. 访问权限？
   - public/external：所有人都可以调用
   - internal/private：受限访问
   - 使用修饰符控制权限

7. 资金归属？
   - 资金属于合约地址
   - 由合约代码控制分配
   - 需要提取函数才能取回

13.2 实践建议

部署合约的实践建议：

1. 开发阶段：
   - 本地测试充分
   - 使用测试网验证
   - 编写完整测试

2. 部署阶段：
   - 检查所有配置
   - 使用多签钱包
   - 记录部署信息

3. 部署后：
   - 验证源代码
   - 监控合约状态
   - 准备应急方案

4. 安全考虑：
   - 权限最小化
   - 资金管理谨慎
   - 定期审计

13.3 下一步学习

深入学习方向：

1. 合约升级
   - 代理模式
   - 存储布局
   - 升级策略

2. Gas 优化
   - 存储优化
   - 代码优化
   - 算法优化

3. 安全审计
   - 常见漏洞
   - 审计工具
   - 最佳实践

4. 高级模式
   - 工厂模式
   - 最小代理
   - 账户抽象

---

结语

恭喜你完成了智能合约部署的学习！

记住：

• 🎯 实践最重要：理论必须结合实践
• 🔒 安全第一：永远把安全放在首位
• 📚 持续学习：Web3 技术发展很快
• 🤝 参与社区：与其他开发者交流

现在你可以：

• ✅ 理解智能合约的本质
• ✅ 独立部署合约到链上
• ✅ 理解合约地址的工作原理
• ✅ 处理合约与地址之间的转账
• ✅ 理解资金归属和权限控制

祝你部署顺利！ 🚀