乐闻世界logo
搜索文章和话题

Solidity 中如何实现合约升级模式？有哪些常见的升级方案？

3月6日 21:48

合约升级是智能合约开发中的重要话题。由于区块链的不可篡改性，一旦合约部署就无法修改，因此需要设计升级机制来修复漏洞或添加新功能。

1. 为什么需要合约升级

solidity
// 问题：合约部署后无法修改
contract ImmutableContract {
    uint256 public value = 100;
    
    // 如果发现 bug，无法直接修复
    function setValue(uint256 _value) external {
        value = _value; // 假设这里有逻辑错误
    }
}

// 解决方案：使用代理模式实现升级

2. 代理模式（Proxy Pattern）

基本原理

代理模式通过分离存储和逻辑来实现升级：

  • Proxy 合约：持有状态存储，委托调用到 Implementation 合约
  • Implementation 合约：包含业务逻辑，可以被替换
solidity
// 简单的代理合约
contract SimpleProxy {
    address public implementation;
    address public admin;
    
    constructor(address _implementation) {
        implementation = _implementation;
        admin = msg.sender;
    }
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "Not admin");
        _;
    }
    
    function upgrade(address _newImplementation) external onlyAdmin {
        implementation = _newImplementation;
    }
    
    // 委托调用到实现合约
    fallback() external payable {
        address impl = implementation;
        require(impl != address(0), "Implementation not set");
        
        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()) }
        }
    }
    
    receive() external payable {}
}

// 实现合约 V1
contract LogicV1 {
    uint256 public value;
    
    function setValue(uint256 _value) external {
        value = _value;
    }
    
    function getValue() external view returns (uint256) {
        return value;
    }
}

// 实现合约 V2（升级版本）
contract LogicV2 {
    uint256 public value;
    uint256 public bonus; // 新增状态变量
    
    function setValue(uint256 _value) external {
        value = _value;
        bonus = _value / 10; // 新功能：自动计算 10% 奖励
    }
    
    function getValue() external view returns (uint256) {
        return value + bonus;
    }
}

3. 透明代理模式（Transparent Proxy Pattern）

OpenZeppelin 推荐的升级模式，解决了函数选择器冲突问题。

solidity
// 透明代理合约
contract TransparentUpgradeableProxy {
    // 存储槽位：避免与实现合约冲突
    bytes32 private constant IMPLEMENTATION_SLOT = 
        bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1);
    bytes32 private constant ADMIN_SLOT = 
        bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1);
    
    constructor(address _logic, address _admin, bytes memory _data) {
        _setImplementation(_logic);
        _setAdmin(_admin);
        
        if (_data.length > 0) {
            (bool success, ) = _logic.delegatecall(_data);
            require(success, "Initialization failed");
        }
    }
    
    modifier ifAdmin() {
        if (msg.sender == _getAdmin()) {
            _;
        } else {
            _fallback();
        }
    }
    
    function admin() external ifAdmin returns (address) {
        return _getAdmin();
    }
    
    function implementation() external ifAdmin returns (address) {
        return _getImplementation();
    }
    
    function upgradeTo(address _newImplementation) external ifAdmin {
        _setImplementation(_newImplementation);
    }
    
    function upgradeToAndCall(address _newImplementation, bytes calldata _data) 
        external 
        payable 
        ifAdmin 
    {
        _setImplementation(_newImplementation);
        (bool success, ) = _newImplementation.delegatecall(_data);
        require(success, "Upgrade initialization failed");
    }
    
    function _getImplementation() internal view returns (address impl) {
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            impl := sload(slot)
        }
    }
    
    function _setImplementation(address _newImplementation) internal {
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            sstore(slot, _newImplementation)
        }
    }
    
    function _getAdmin() internal view returns (address adm) {
        bytes32 slot = ADMIN_SLOT;
        assembly {
            adm := sload(slot)
        }
    }
    
    function _setAdmin(address _newAdmin) internal {
        bytes32 slot = ADMIN_SLOT;
        assembly {
            sstore(slot, _newAdmin)
        }
    }
    
    function _fallback() internal {
        address impl = _getImplementation();
        require(impl != address(0), "Implementation not set");
        
        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()) }
        }
    }
    
    fallback() external payable {
        _fallback();
    }
    
    receive() external payable {
        _fallback();
    }
}

// 实现合约（使用初始化代替构造函数）
contract MyTokenV1 {
    string public name;
    string public symbol;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    
    bool private initialized;
    
    function initialize(
        string memory _name, 
        string memory _symbol, 
        uint256 _initialSupply
    ) public {
        require(!initialized, "Already initialized");
        initialized = true;
        
        name = _name;
        symbol = _symbol;
        totalSupply = _initialSupply;
        balanceOf[msg.sender] = _initialSupply;
    }
    
    function transfer(address _to, uint256 _amount) external returns (bool) {
        require(balanceOf[msg.sender] >= _amount, "Insufficient balance");
        balanceOf[msg.sender] -= _amount;
        balanceOf[_to] += _amount;
        return true;
    }
}

// 升级版本 V2
contract MyTokenV2 {
    string public name;
    string public symbol;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance; // 新增
    
    bool private initialized;
    
    function initialize(
        string memory _name, 
        string memory _symbol, 
        uint256 _initialSupply
    ) public {
        require(!initialized, "Already initialized");
        initialized = true;
        
        name = _name;
        symbol = _symbol;
        totalSupply = _initialSupply;
        balanceOf[msg.sender] = _initialSupply;
    }
    
    function transfer(address _to, uint256 _amount) external returns (bool) {
        require(balanceOf[msg.sender] >= _amount, "Insufficient balance");
        balanceOf[msg.sender] -= _amount;
        balanceOf[_to] += _amount;
        return true;
    }
    
    // 新增功能：授权转账
    function approve(address _spender, uint256 _amount) external returns (bool) {
        allowance[msg.sender][_spender] = _amount;
        return true;
    }
    
    function transferFrom(address _from, address _to, uint256 _amount) 
        external 
        returns (bool) 
    {
        require(balanceOf[_from] >= _amount, "Insufficient balance");
        require(allowance[_from][msg.sender] >= _amount, "Insufficient allowance");
        
        balanceOf[_from] -= _amount;
        balanceOf[_to] += _amount;
        allowance[_from][msg.sender] -= _amount;
        return true;
    }
}

4. UUPS 代理模式（Universal Upgradeable Proxy Standard）

更轻量级的升级模式，升级逻辑放在实现合约中。

solidity
// UUPS 代理合约
contract ERC1967Proxy {
    bytes32 private constant IMPLEMENTATION_SLOT = 
        bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1);
    
    constructor(address _logic, bytes memory _data) {
        _setImplementation(_logic);
        if (_data.length > 0) {
            (bool success, ) = _logic.delegatecall(_data);
            require(success, "Initialization failed");
        }
    }
    
    function _getImplementation() internal view returns (address impl) {
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            impl := sload(slot)
        }
    }
    
    function _setImplementation(address _newImplementation) internal {
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            sstore(slot, _newImplementation)
        }
    }
    
    fallback() external payable {
        address impl = _getImplementation();
        require(impl != address(0), "Implementation not set");
        
        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()) }
        }
    }
    
    receive() external payable {}
}

// UUPS 实现合约基类
abstract contract UUPSUpgradeable {
    bytes32 private constant IMPLEMENTATION_SLOT = 
        bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1);
    
    modifier onlyProxy() {
        require(address(this) != __self, "Function must be called through delegatecall");
        _;
    }
    
    address private immutable __self = address(this);
    
    function proxiableUUID() external view returns (bytes32) {
        return IMPLEMENTATION_SLOT;
    }
    
    function upgradeTo(address _newImplementation) external onlyProxy {
        _authorizeUpgrade(_newImplementation);
        _upgradeToAndCall(_newImplementation, "", false);
    }
    
    function upgradeToAndCall(address _newImplementation, bytes memory _data) 
        external 
        payable 
        onlyProxy 
    {
        _authorizeUpgrade(_newImplementation);
        _upgradeToAndCall(_newImplementation, _data, true);
    }
    
    function _authorizeUpgrade(address _newImplementation) internal virtual;
    
    function _upgradeToAndCall(
        address _newImplementation, 
        bytes memory _data, 
        bool _forceCall
    ) internal {
        _setImplementation(_newImplementation);
        if (_data.length > 0 || _forceCall) {
            (bool success, ) = _newImplementation.delegatecall(_data);
            require(success, "Upgrade initialization failed");
        }
    }
    
    function _setImplementation(address _newImplementation) private {
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            sstore(slot, _newImplementation)
        }
    }
}

// 使用 UUPS 的合约
contract MyUUPSTokenV1 is UUPSUpgradeable {
    string public name;
    uint256 public value;
    address public owner;
    
    bool private initialized;
    
    function initialize(string memory _name) public {
        require(!initialized, "Already initialized");
        initialized = true;
        
        name = _name;
        owner = msg.sender;
    }
    
    function setValue(uint256 _value) external {
        value = _value;
    }
    
    function _authorizeUpgrade(address _newImplementation) internal override {
        require(msg.sender == owner, "Not authorized");
    }
}

// 升级版本
contract MyUUPSTokenV2 is UUPSUpgradeable {
    string public name;
    uint256 public value;
    uint256 public multiplier; // 新增
    address public owner;
    
    bool private initialized;
    
    function initialize(string memory _name) public {
        require(!initialized, "Already initialized");
        initialized = true;
        
        name = _name;
        owner = msg.sender;
        multiplier = 1; // 初始化新变量
    }
    
    function setValue(uint256 _value) external {
        value = _value * multiplier; // 新逻辑
    }
    
    function setMultiplier(uint256 _multiplier) external {
        require(msg.sender == owner, "Not owner");
        multiplier = _multiplier;
    }
    
    function _authorizeUpgrade(address _newImplementation) internal override {
        require(msg.sender == owner, "Not authorized");
    }
}

5. 钻石模式（Diamond Pattern - EIP-2535）

支持多个实现合约，适合大型复杂系统。

solidity
// 钻石存储结构
library LibDiamond {
    bytes32 constant DIAMOND_STORAGE_POSITION = 
        keccak256("diamond.standard.diamond.storage");
    
    struct FacetAddressAndPosition {
        address facetAddress;
        uint96 functionSelectorPosition;
    }
    
    struct FacetFunctionSelectors {
        bytes4[] functionSelectors;
        uint256 facetAddressPosition;
    }
    
    struct DiamondStorage {
        mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;
        mapping(address => FacetFunctionSelectors) facetFunctionSelectors;
        address[] facetAddresses;
        address contractOwner;
    }
    
    function diamondStorage() internal pure returns (DiamondStorage storage ds) {
        bytes32 position = DIAMOND_STORAGE_POSITION;
        assembly {
            ds.slot := position
        }
    }
    
    event DiamondCut(
        address[] _facetAddresses,
        bytes4[][] _functionSelectors,
        address _initAddress,
        bytes _calldata
    );
}

// 钻石合约
contract Diamond {
    constructor(address _contractOwner, address _diamondCutFacet) {
        LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();
        ds.contractOwner = _contractOwner;
        
        // 添加 diamondCut 函数
        // ...
    }
    
    fallback() external payable {
        LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();
        address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;
        require(facet != address(0), "Function does not exist");
        
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
    
    receive() external payable {}
}

// 钻石切面（Facet）示例
contract TokenFacet {
    struct TokenStorage {
        mapping(address => uint256) balances;
        uint256 totalSupply;
    }
    
    bytes32 constant TOKEN_STORAGE_POSITION = keccak256("token.facet.storage");
    
    function tokenStorage() internal pure returns (TokenStorage storage ts) {
        bytes32 position = TOKEN_STORAGE_POSITION;
        assembly {
            ts.slot := position
        }
    }
    
    function balanceOf(address _account) external view returns (uint256) {
        return tokenStorage().balances[_account];
    }
    
    function transfer(address _to, uint256 _amount) external {
        TokenStorage storage ts = tokenStorage();
        require(ts.balances[msg.sender] >= _amount, "Insufficient balance");
        ts.balances[msg.sender] -= _amount;
        ts.balances[_to] += _amount;
    }
}

// 治理切面
contract GovernanceFacet {
    struct GovernanceStorage {
        mapping(address => uint256) votingPower;
        uint256 proposalCount;
    }
    
    bytes32 constant GOVERNANCE_STORAGE_POSITION = keccak256("governance.facet.storage");
    
    function createProposal(string memory _description) external {
        // 创建提案逻辑
    }
    
    function vote(uint256 _proposalId, bool _support) external {
        // 投票逻辑
    }
}

6. 升级模式对比

特性透明代理UUPS钻石模式
Gas 成本较高较低中等
复杂度中等低高
函数选择器冲突自动解决需手动处理支持多切面
升级权限代理合约控制实现合约控制灵活配置
适用场景通用场景简单升级大型复杂系统
部署成本中等低高

7. 升级最佳实践

存储布局管理

solidity
// 使用存储槽位避免冲突
contract StorageLayout {
    // 存储槽位 0
    uint256 public value1;
    
    // 存储槽位 1
    address public owner;
    
    // 存储槽位 2
    mapping(address => uint256) public balances;
    
    // 升级时只能追加新变量，不能修改已有变量的顺序和类型
    // V2 版本
    uint256 public value1;      // 槽位 0 - 保持不变
    address public owner;       // 槽位 1 - 保持不变
    mapping(address => uint256) public balances; // 槽位 2 - 保持不变
    uint256 public newValue;    // 槽位 3 - 新增变量
}

使用 OpenZeppelin Upgrades

javascript
// hardhat.config.js
require('@openzeppelin/hardhat-upgrades');

module.exports = {
  solidity: '0.8.19',
};

// 部署脚本
const { ethers, upgrades } = require('hardhat');

async function main() {
  const MyToken = await ethers.getContractFactory('MyTokenV1');
  
  // 部署代理
  const proxy = await upgrades.deployProxy(MyToken, ['My Token'], {
    initializer: 'initialize',
  });
  await proxy.deployed();
  
  console.log('Proxy deployed to:', proxy.address);
  
  // 升级
  const MyTokenV2 = await ethers.getContractFactory('MyTokenV2');
  const upgraded = await upgrades.upgradeProxy(proxy.address, MyTokenV2);
  
  console.log('Upgraded to:', upgraded.address);
}

main();

安全注意事项

solidity
// 1. 使用初始化锁防止重复初始化
contract Initializable {
    bool private _initialized;
    bool private _initializing;
    
    modifier initializer() {
        require(
            _initializing || !_initialized,
            "Initializable: contract is already initialized"
        );
        
        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}

// 2. 权限控制
contract UpgradeableWithAuth is Initializable {
    address public admin;
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "Not admin");
        _;
    }
    
    function initialize() public initializer {
        admin = msg.sender;
    }
    
    function upgrade(address _newImplementation) external onlyAdmin {
        // 升级逻辑
    }
}

// 3. 升级前测试
// - 在测试网上充分测试
// - 验证存储布局兼容性
// - 检查新功能的安全性

8. 总结

合约升级是智能合约开发的重要技能：

  1. 透明代理模式：OpenZeppelin 推荐，适合大多数场景

  2. UUPS 模式：更轻量，Gas 效率更高

  3. 钻石模式：适合大型复杂系统，支持模块化升级

  4. 最佳实践：

    • 仔细管理存储布局
    • 使用初始化锁
    • 充分测试升级过程
    • 考虑使用 OpenZeppelin Upgrades 插件
标签：Solidity
热门标签
更多
Git(114)C语言(23)C++(15)React(34)前端(148)Cypress(30)JavaScript(56)Linux(20)Docker(65)Rust(10)TypeScript(27)Mongoose(18)MySQL(8)Vue(13)Tailwind CSS(29)CSS(19)ElasticSearch(24)网络(12)TypeORM(31)