# 智能合约安全

## 问题

1. 智能合约安全有哪些常见漏洞？
2. 什么是重入攻击（Reentrancy）？如何防范？
3. 什么是整数溢出/下溢？Solidity 0.8+如何处理？
4. 什么是访问控制漏洞？如何设计权限管理？
5. 什么是前置交易（Front-running）？如何防范？
6. 什么是闪电贷攻击？如何防范？
7. 什么是跨链桥安全风险？
8. 智能合约如何进行安全审计？
9. 使用哪些工具进行安全检测？
10. 智能合约有哪些最佳实践？

---

## 标准答案

### 1. 常见智能合约漏洞

#### **OWASP Top 10 - Smart Contract**

```
1. 重入攻击（Reentrancy）
2. 整数溢出/下溢（Arithmetic Issues）
3. 访问控制失败（Access Control）
4. 未检查的低级调用（Unchecked Low-Level Calls）
5. 前置交易（Front-running / TX Origin）
6. 时间戳依赖（Timestamp Manipulation）
7. 逻辑错误（Logic Errors）
8. Gas限制和循环（Gas Limit and Loops）
9. 默认可见性（Default Visibility）
10. 竞态条件（Race Conditions）
```

---

### 2. 重入攻击（Reentrancy）

#### **原理**

攻击者在合约更新状态之前，递归调用提款函数，多次提取资金。

#### **经典案例：The DAO攻击（2016）**

```
1. 攻击者存入ETH到DAO合约
2. 攻击者调用withdraw()
3. DAO合约发送ETH给攻击者
4. 攻击者的fallback函数再次调用withdraw()
5. DAO合约未更新余额，再次发送ETH
6. 重复步骤3-5多次
7. 最终提取远超存款的ETH

损失：360万 ETH（当时价值约$7000万）
```

#### **漏洞代码**

```solidity
// ❌ 易受攻击的合约
contract VulnerableBank {
    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");

        // ❌ 先转账，后更新状态（漏洞！）
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");

        // 更新状态（太晚了！）
        balances[msg.sender] -= amount;
    }
}

// 攻击合约
contract Attack {
    VulnerableBank public bank;

    constructor(address _bank) {
        bank = VulnerableBank(_bank);
    }

    // 存入ETH
    function attack() public payable {
        bank.deposit{value: msg.value}();
        bank.withdraw(msg.value);
    }

    // fallback函数递归调用
    fallback() external payable {
        if (address(bank).balance >= 1 ether) {
            bank.withdraw(1 ether);
        }
    }
}
```

**攻击流程**：
```
1. 攻击者调用attack()，存入1 ETH
2. 调用withdraw(1 ether)
3. 合约检查：balances[msg.sender] >= 1 ether ✓
4. 合约发送1 ETH给攻击者
5. 攻击者合约的fallback()被触发
6. fallback()再次调用withdraw(1 ether)
7. 合约检查：balances[msg.sender]还是1 ether（未更新！）✓
8. 合约再次发送1 ETH
9. 重复步骤5-8，直到合约余额不足
```

---

#### **修复方案1：检查-生效-交互模式（CEI）**

```solidity
// ✅ 安全的合约
contract SecureBank {
    mapping(address => uint256) public balances;

    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");

        // ✅ 先更新状态
        balances[msg.sender] -= amount;

        // ✅ 后交互（转账）
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}
```

---

#### **修复方案2：重入锁（ReentrancyGuard）**

```solidity
// OpenZeppelin ReentrancyGuard
abstract contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
        _status = _ENTERED;
        _;
        _status = _NOT_ENTERED;
    }
}

// 使用ReentrancyGuard
contract SecureBankWithGuard is ReentrancyGuard {
    mapping(address => uint256) public balances;

    function withdraw(uint256 amount) public nonReentrant {
        require(balances[msg.sender] >= amount, "Insufficient balance");

        balances[msg.sender] -= amount;

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

---

#### **修复方案3：Pull over Push模式**

```solidity
// ✅ 使用Pull模式
contract PullOverPush {
    mapping(address => uint256) public balances;
    mapping(address => uint256) public withdrawals;

    function requestWithdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        withdrawals[msg.sender] += amount;
    }

    // 用户主动提取
    function withdraw() public {
        uint256 amount = withdrawals[msg.sender];
        require(amount > 0, "Nothing to withdraw");

        withdrawals[msg.sender] = 0;
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}
```

---

### 3. 整数溢出/下溢

#### **原理**

```
uint8 最大值：255
uint8 最小值：0

溢出：
255 + 1 = 0（回绕）

下溢：
0 - 1 = 255（回绕）

Solidity 0.8+ 自动检查溢出/下溢
旧版本需要使用SafeMath库
```

#### **漏洞代码**

```solidity
// ❌ Solidity 0.8之前
contract VulnerableToken {
    uint8 public totalSupply = 255;

    function mint(uint8 amount) public {
        // 溢出：255 + 1 = 0
        totalSupply += amount;
    }
}

// 攻击
// mint(1) → totalSupply = 0（溢出！）
```

#### **修复方案**

**Solidity 0.8+**（自动检查）：
```solidity
// ✅ Solidity 0.8+
contract SecureToken {
    uint256 public totalSupply;

    function mint(uint256 amount) public {
        // ✅ 自动检查溢出，失败会revert
        totalSupply += amount;
    }
}
```

**SafeMath库**（旧版本）：
```solidity
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }
}

contract SecureTokenWithSafeMath {
    using SafeMath for uint256;

    uint256 public totalSupply;

    function mint(uint256 amount) public {
        // ✅ 使用SafeMath检查溢出
        totalSupply = totalSupply.add(amount);
    }
}
```

---

### 4. 访问控制漏洞

#### **常见问题**

```
1. 函数未设置访问控制
2. 使用tx.origin认证（中间人攻击）
3. 权限提升漏洞
```

#### **漏洞代码1：未保护的函数**

```solidity
// ❌ 任何人都可以调用
contract Vulnerable {
    address public owner;
    uint256 public price = 100;

    function setPrice(uint256 _price) public {
        // ❌ 没有权限检查
        price = _price;
    }
}
```

**修复**：
```solidity
// ✅ 使用onlyOwner修饰符
contract Secure {
    address public owner;
    uint256 public price = 100;

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    function setPrice(uint256 _price) public onlyOwner {
        // ✅ 只有owner可以调用
        price = _price;
    }
}
```

---

#### **漏洞代码2：tx.origin认证（钓鱼攻击）**

```solidity
// ❌ 易受钓鱼攻击
contract Wallet {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    function withdraw() public {
        // ❌ 使用tx.origin（不安全！）
        require(tx.origin == owner, "Not owner");
        payable(msg.sender).transfer(address(this).balance);
    }
}

// 攻击合约
contract AttackWallet {
    Wallet public wallet;

    constructor(address _wallet) {
        wallet = Wallet(_wallet);
    }

    function attack() public {
        // 诱导owner调用这个函数
        wallet.withdraw();
    }

    fallback() external payable {
        // 转账给攻击者
        payable(msg.sender).transfer(msg.value);
    }
}
```

**攻击流程**：
```
1. 攻击者创建AttackWallet合约
2. 攻击者诱导owner调用AttackWallet.attack()
3. attack()调用Wallet.withdraw()
4. Wallet检查：tx.origin == owner ✓（owner是调用者）
5. msg.sender是AttackWallet合约
6. 资金转给AttackWallet合约
7. AttackWallet的fallback()把资金转给攻击者
```

**修复**：
```solidity
// ✅ 使用msg.sender
contract SecureWallet {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    function withdraw() public onlyOwner {
        // ✅ 使用msg.sender
        payable(msg.sender).transfer(address(this).balance);
    }
}
```

---

#### **漏洞代码3：权限提升**

```solidity
// ❌ 可以提升自己为管理员
contract AccessControl {
    mapping(address => bool) public admins;
    address public owner;

    constructor() {
        owner = msg.sender;
        admins[owner] = true;
    }

    function addToAdmin(address _user) public {
        // ❌ 没有检查调用者是否是admin
        admins[_user] = true;
    }
}

// 攻击
// 攻击者调用addToAdmin(攻击者地址)
// 攻击者成为管理员
```

**修复**：
```solidity
// ✅ 检查调用者权限
contract SecureAccessControl {
    mapping(address => bool) public admins;
    address public owner;

    constructor() {
        owner = msg.sender;
        admins[owner] = true;
    }

    modifier onlyAdmin() {
        require(admins[msg.sender], "Not admin");
        _;
    }

    function addToAdmin(address _user) public onlyAdmin {
        // ✅ 只有admin可以添加新admin
        admins[_user] = true;
    }
}
```

---

### 5. 前置交易（Front-running）

#### **原理**

攻击者看到交易在内存池（Mempool）中，复制交易并设置更高的Gas Price，让自己的交易先执行。

#### **示例场景**

```
1. 用户在DEX上用1 ETH买UNI（价格$10）
2. 攻击者看到这笔交易
3. 攻击者设置更高Gas Price，抢先买入
4. 用户交易执行，价格被推高到$11
5. 攻击者立即卖出，获利

用户损失：原本应该花$10，实际花了$11
攻击者获利：$1/UNI × 交易数量
```

#### **代码示例**

```solidity
// ❌ 易受前置交易攻击
contract VulnerableDEX {
    mapping(address => uint256) public prices;

    function setPrice(address token, uint256 price) public {
        // ❌ 可以被抢先交易
        prices[token] = price;
    }

    function trade(address token, uint256 amount) public {
        uint256 price = prices[token];
        // 使用price交易
    }
}
```

#### **修复方案1：提交-揭示模式（Commit-Reveal）**

```solidity
// ✅ 使用Commit-Reveal
contract CommitReveal {
    struct Commitment {
        bytes32 commitHash;
        uint256 revealTime;
        bool revealed;
    }

    mapping(address => Commitment) public commitments;
    mapping(address => uint256) public revealedValues;

    // 1. 提交哈希（隐藏真实值）
    function commit(bytes32 commitHash) public {
        commitments[msg.sender] = Commitment({
            commitHash: commitHash,
            revealTime: block.timestamp + 1 days,
            revealed: false
        });
    }

    // 2. 揭示真实值（1天后）
    function reveal(uint256 value, uint256 salt) public {
        Commitment storage c = commitments[msg.sender];
        require(!c.revealed, "Already revealed");
        require(block.timestamp >= c.revealTime, "Too early");

        // 验证哈希
        bytes32 computedHash = keccak256(abi.encodePacked(value, salt));
        require(computedHash == c.commitHash, "Invalid reveal");

        c.revealed = true;
        revealedValues[msg.sender] = value;
    }
}
```

---

#### **修复方案2：批量交易**

```solidity
// ✅ 批量执行交易，减少前置交易
contract BatchTrade {
    struct Trade {
        address user;
        address token;
        uint256 amount;
        uint256 price;
    }

    Trade[] public pendingTrades;

    function submitTrade(address token, uint256 amount) public {
        pendingTrades.push(Trade({
            user: msg.sender,
            token: token,
            amount: amount,
            price: 0 // 后续设置
        }));
    }

    // 批量执行所有交易
    function executeBatch() public {
        for (uint256 i = 0; i < pendingTrades.length; i++) {
            Trade memory t = pendingTrades[i];
            // 使用平均价格执行所有交易
            executeTrade(t);
        }
        delete pendingTrades;
    }
}
```

---

### 6. 闪电贷攻击

#### **原理**

```
1. 攻击者闪电贷借入大量资金
2. 使用资金操纵市场（如DEX价格）
3. 利用被操纵的价格获利（如套利、清算）
4. 还款 + 手续费
5. 如果失败，交易回滚（无风险）
```

#### **攻击示例**

```solidity
// 闪电贷攻击DEX
contract FlashLoanAttack {
    IUniswapV2Router public router;
    IUniswapV2Pair public pair;

    function attack() external {
        // 1. 闪电贷借入10,000 ETH
        flashLoan(10000 ether);

        // 2. 在DEX上用10,000 ETH卖出代币
        // → 价格被砸到极低

        // 3. 在另一个DEX用低价买回代币
        // → 赚取差价

        // 4. 还款 10,000 ETH + 手续费
        repayFlashLoan(10000 ether);
    }
}
```

#### **防范措施**

```
1. 使用时间加权平均价格（TWAP）
   - 链下预言机（Chainlink）
   - 多个价格源聚合

2. 限制单笔交易规模
   - 最大交易量限制
   - 滑点保护

3. 闪电贷检测
   - 单个区块内大额交易
   - 可疑价格波动告警

4. 暂停机制
   - 检测到攻击时暂停合约
   - 多重签名恢复
```

**代码示例：TWAP预言机**：
```solidity
// ✅ 使用TWAP预言机
contract TWAPOracle {
    uint256 public price;
    uint256 public lastUpdateTime;
    uint256 public constant PERIOD = 1 hours;

    function updatePrice(uint256 newPrice) external {
        if (block.timestamp >= lastUpdateTime + PERIOD) {
            // 时间到了，可以更新
            price = newPrice;
            lastUpdateTime = block.timestamp;
        } else {
            // 未到期，使用加权平均
            uint256 timeElapsed = block.timestamp - lastUpdateTime;
            uint256 weight = timeElapsed * 100 / PERIOD;
            price = (price * (100 - weight) + newPrice * weight) / 100;
        }
    }
}
```

---

### 7. 跨链桥安全风险

#### **常见攻击**

```
1. 验证节点私钥泄露
   - Ronin Bridge：$6.25亿被盗
   - 攻击者控制了5/9个验证节点

2. 伪造签名
   - Wormhole：$3.2亿被盗
   - 攻击者伪造了验证者签名

3. 智能合约漏洞
   - Harmony Bridge：$1亿被盗
   - 漏洞允许绕过验证

4. 逻辑漏洞
   - Nomad Bridge：$1.9亿被盗
   - 漏洞允许任何人伪造消息
```

#### **安全设计原则**

```solidity
// ✅ 安全的跨链桥设计
contract SecureBridge {
    // 1. 多重签名验证
    mapping(bytes32 => bool) public usedSignatures;
    address[] public validators;

    modifier validateSignature(bytes32 message, bytes memory signature) {
        require(verifySignature(message, signature), "Invalid signature");
        require(!usedSignatures[keccak256(signature)], "Signature used");
        _;
    }

    // 2. 延迟提款（给用户时间取消）
    mapping(address => uint256) public pendingWithdrawals;
    uint256 public constant DELAY = 24 hours;

    function requestWithdraw(address token, uint256 amount) public {
        pendingWithdrawals[msg.sender] = block.timestamp;
        emit WithdrawRequested(msg.sender, token, amount);
    }

    function executeWithdraw(address token, uint256 amount) public {
        require(
            block.timestamp >= pendingWithdrawals[msg.sender] + DELAY,
            "Delay not met"
        );
        // 执行提款
    }

    // 3. 暂停机制
    bool public paused;

    modifier whenNotPaused() {
        require(!paused, "Paused");
        _;
    }

    function pause() public {
        // 多重签名
        paused = true;
    }
}
```

---

### 8. 智能合约安全审计

#### **审计流程**

```
1. 文档审查
   - 白皮书
   - 技术文档
   - 经济模型

2. 代码审查
   - 手动代码审查
   - 自动化工具扫描
   - 测试覆盖率检查

3. 测试
   - 单元测试
   - 集成测试
   - 模糊测试（Fuzzing）

4. 形式化验证
   - 数学证明
   - 不变量检查

5. 渗透测试
   - 模拟攻击
   - 红队演练
```

---

#### **审计清单**

```
✅ 访问控制
- 所有敏感函数都有访问控制
- 使用OpenZeppelin的AccessControl

✅ 重入保护
- 外部调用在状态更新之后
- 使用ReentrancyGuard

✅ 整数溢出
- 使用Solidity 0.8+
- 或使用SafeMath

✅ 外部调用
- 检查返回值
- 使用try-catch

✅ Gas优化
- 循环有限制
- 避免动态数组

✅ 测试
- 单元测试覆盖率 > 90%
- 集成测试
- 边界条件测试

✅ 文档
- NatSpec注释
- 清晰的函数说明
- 使用示例
```

---

### 9. 安全检测工具

#### **静态分析工具**

```
1. Slither
   - Python开发
   - 快速扫描
   - 检测常见漏洞

   安装：
   pip install slither-analyzer

   使用：
   slither contract.sol
```

```bash
# Slither扫描示例
$ slither token.sol

...
INFO:Detectors:
Reentrancy in Token.withdraw(uint256) (token.sol#45-50):
    External calls:
    - msg.sender.call{value: amount}(gas()) (token.sol#48)
    State variables written after the call(s):
    - balances[msg.sender] -= amount (token.sol#49)
```

---

```
2. MythX
   - 商业工具
   - 深度分析
   - 支持多种漏洞检测

   使用：
   mythx analyze contract.sol
```

---

```
3. Echidna
   - 模糊测试工具
   - 基于属性的测试
   - 发现边缘情况

   安装：
   cargo install echidna

   使用：
   echidna-test contract.sol
```

**Echidna示例**：
```solidity
// 测试不变量：总供应量 = 所有人余额之和
contract Token {
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    function transfer(address to, uint256 amount) public {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
    }
}

// Echidna测试
contract TestToken is Token, Test {
    function check_total_supply() public {
        uint256 sum = 0;
        // 计算所有余额（需要手动添加）
        assert(totalSupply == sum);
    }
}
```

---

```
4. Mythril
   - 符号执行引擎
   - 深度漏洞检测
   - 支持攻击路径分析

   安装：
   pip install mythril

   使用：
   myth contract.sol
```

---

#### **动态分析工具**

```
1. Hardhat + Tenderly
   - 交易模拟
   - Gas分析
   - 调试工具

2. Ganache
   - 本地测试网络
   - 快速部署测试

3. Fork测试
   - Fork主网状态
   - 在真实环境测试
```

**Fork测试示例**：
```javascript
// hardhat.config.js
module.exports = {
  networks: {
    hardhat: {
      forking: {
        url: "https://eth-mainnet.alchemyapi.io/v2/YOUR-API-KEY",
        blockNumber: 15000000, // Fork特定区块
      },
    },
  },
};

// 测试
describe("Uniswap Fork Test", function () {
  it("should swap on real Uniswap", async function () {
    // 在主网Uniswap上交易（不花真钱）
    const uniswap = await ethers.getContractAt("IUniswapV2Router", UNISWAP_ROUTER);
    await uniswap.swapExactETHForTokens(...);
  });
});
```

---

### 10. 智能合约最佳实践

#### **1. 使用OpenZeppelin库**

```solidity
// ✅ 不要重复造轮子
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract MyToken is ERC20, Ownable, ReentrancyGuard {
    constructor() ERC20("My Token", "MTK") {}

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}
```

---

#### **2. 检查-生效-交互模式**

```solidity
// ✅ CEI模式
function withdraw(uint256 amount) public {
    // 1. 检查（Checks）
    require(balances[msg.sender] >= amount, "Insufficient");

    // 2. 生效（Effects）
    balances[msg.sender] -= amount;

    // 3. 交互（Interactions）
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
}
```

---

#### **3. 使用SafeERC20**

```solidity
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract SafeTransfer {
    using SafeERC20 for IERC20;

    function transferToken(address token, address to, uint256 amount) public {
        // ✅ 自动处理返回值
        IERC20(token).safeTransfer(to, amount);
    }
}
```

---

#### **4. 停止机制（Emergency Pause）**

```solidity
import "@openzeppelin/contracts/security/Pausable.sol";

contract PausableContract is Pausable, Ownable {
    function deposit() public payable whenNotPaused {
        // 正常逻辑
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }
}
```

---

#### **5. 事件日志**

```solidity
contract LogEvents {
    event Withdrawal(address indexed user, uint256 amount, uint256 timestamp);

    function withdraw(uint256 amount) public {
        // ✅ 记录所有重要操作
        emit Withdrawal(msg.sender, amount, block.timestamp);

        // 执行提款
        payable(msg.sender).transfer(amount);
    }
}
```

---

#### **6. 限流机制**

```solidity
contract RateLimiter {
    mapping(address => uint256) public lastCallTime;
    uint256 public constant COOLDOWN = 1 minutes;

    modifier rateLimit() {
        require(
            block.timestamp >= lastCallTime[msg.sender] + COOLDOWN,
            "Cooldown not met"
        );
        _;
        lastCallTime[msg.sender] = block.timestamp;
    }

    function sensitiveOperation() public rateLimit {
        // 限制每个用户每分钟只能调用一次
    }
}
```

---

#### **7. 多重签名钱包**

```solidity
// ✅ 关键操作使用多签
contract MultiSigWallet {
    address[] public owners;
    uint256 public required;

    mapping(uint256 => Transaction) public transactions;
    mapping(uint256 => mapping(address => bool)) public confirmations;

    struct Transaction {
        address to;
        uint256 value;
        bytes data;
        bool executed;
    }

    function submitTransaction(address to, uint256 value, bytes memory data)
        public
    {
        uint256 txIndex = transactions.length;
        transactions[txIndex] = Transaction({
            to: to,
            value: value,
            data: data,
            executed: false
        });
        confirmTransaction(txIndex);
    }

    function confirmTransaction(uint256 txIndex) public {
        // 需要多个所有者确认
        confirmations[txIndex][msg.sender] = true;
        if (isConfirmed(txIndex)) {
            executeTransaction(txIndex);
        }
    }

    function isConfirmed(uint256 txIndex) public view returns (bool) {
        uint256 count = 0;
        for (uint256 i = 0; i < owners.length; i++) {
            if (confirmations[txIndex][owners[i]]) {
                count += 1;
            }
        }
        return count >= required;
    }
}
```

---

#### **8. 升级模式**

```solidity
// ✅ 使用代理模式升级
contract LogicV1 {
    uint256 public value;

    function setValue(uint256 _value) public {
        value = _value;
    }
}

contract LogicV2 {
    uint256 public value;
    uint256 public newValue;

    function setValue(uint256 _value) public {
        value = _value;
        newValue = _value * 2;
    }
}

// 使用OpenZeppelin Transparent Proxy
import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";

// 部署
// 1. 部署LogicV1
// 2. 部署Proxy，指向LogicV1
// 3. 用户通过Proxy交互
// 4. 升级：部署LogicV2，调用Proxy.upgradeTo(LogicV2)
```

---

## 结合简历的面试题

### 1. 电商风控 vs DeFi安全

**面试官会问**：
> "你在电商做过风控系统，DeFi安全有什么异同？"

**参考回答**：
```
电商风控：
- 反欺诈：识别虚假订单、刷单
- 信用评估：用户信用评分
- 异常检测：异常交易行为

DeFi安全：
- 智能合约审计：代码漏洞检测
- 链上监控：异常交易监控
- 价格预言机：防止价格操纵
- MEV保护：防止三明治攻击

共同点：
- 需要实时监控系统
- 需要异常检测机制
- 需要快速响应机制

差异：
- 电商：中心化，可以人工介入
- DeFi：去中心化，只能通过智能合约
```

---

### 2. 高并发与Gas优化

**面试官会问**：
> "你做过高并发系统，智能合约如何优化Gas？"

**参考回答**：
```
Web2高并发：
- 缓存热点数据
- 异步处理
- 数据库优化

Web3 Gas优化：
1. 存储优化
   - 使用打包类型（uint256 vs uint8）
   - 使用短字符串
   - 删除不需要的数据（refund gas）

2. 循环优化
   - 限制循环次数
   - 使用mapping代替array查找

3. 批量操作
   - 批量转账
   - 批量Mint

4. 链下计算
   - Merkle Tree
   - 零知识证明

示例：
// ❌ 高Gas
for (uint256 i = 0; i < 1000; i++) {
    users[i].reward = calculateReward(i);
}

// ✅ 低Gas（链下计算 + Merkle Proof）
bytes32 public merkleRoot;
function claimReward(uint256 amount, bytes32[] memory proof) public {
    require(verifyMerkleProof(msg.sender, amount, proof), "Invalid proof");
    payable(msg.sender).transfer(amount);
}
```

---

## 智能合约安全面试加分项

### 1. 实战经验

- 参与过智能合约审计
- 发现过真实漏洞
- 有漏洞修复经验
- 熟悉常见攻击手法

### 2. 技术深度

- 理解EVM底层机制
- 熟悉汇编语言（Yul）
- 了解形式化验证
- 掌握Gas优化技巧

### 3. 工具使用

- 熟练使用Slither、MythX
- 会使用Foundry测试框架
- 会使用Tenderly调试
- 了解Fuzzing测试

### 4. 安全意识

- 防御性编程思维
- 最小权限原则
- 深度防御策略
- 持续学习最新漏洞