《纸上谈兵·solidity》第 14 课：Solidity 中的可升级合约模式 —— 从代理合约到透明代理、UUPS 与安全陷阱

(bool success, bytes memory data) = implementation.delegatecall(msg.data);

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

contract Storage {
    uint256 private _value;

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

    function getValue() public view returns (uint256) {
        return _value;
    }
}

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

import "./Storage.sol";

contract LogicV1 {
    Storage public store;

    constructor(address _store) {
        store = Storage(_store);
    }

    function setValue(uint256 _value) public {
        store.setValue(_value);
    }

    function getValue() public view returns (uint256) {
        return store.getValue();
    }
}

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

import "./Storage.sol";
import "./LogicV1.sol";

contract LogicV2 is LogicV1 {
    constructor(address _store) LogicV1(_store) {}

    function increment() public {
        uint256 current = store.getValue();
        store.setValue(current + 1); // 使用 getter + setter
    }

}

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

contract Proxy {
    address public implementation;
    address public admin;

    constructor(address _impl) {
        implementation = _impl;
        admin = msg.sender;
    }

    function upgradeTo(address _newImpl) public {
        require(msg.sender == admin, "Not admin");
        implementation = _newImpl;
    }

    fallback() external payable {
        address impl = implementation;
        require(impl != address(0), "No 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()) }
        }
    }

    receive() external payable {}
}

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

import "forge-std/Test.sol";
import "../src/LogicV1.sol";
import "../src/LogicV2.sol";
import "../src/Proxy.sol";
import "../src/Storage.sol";

contract UpgradeTest is Test {
    LogicV1 logicV1;
    Proxy proxy;
    Storage store;

    function setUp() public {
        store = new Storage();
        logicV1 = new LogicV1(address(store));
        proxy = new Proxy(address(logicV1));
    }

    function testUpgrade() public {
        LogicV1 proxyAsV1 = LogicV1(address(proxy));
        proxyAsV1.setValue(42);
        assertEq(proxyAsV1.getValue(), 42);

        LogicV2 logicV2 = new LogicV2(address(store));
        proxy.upgradeTo(address(logicV2));

        LogicV2 proxyAsV2 = LogicV2(address(proxy));
        proxyAsV2.increment();
        assertEq(proxyAsV2.getValue(), 43);
    }
}

➜  counter git:(main) ✗ forge test --match-path test/UpgradeTest.t.sol -vvv
[⠊] Compiling...
[⠢] Compiling 5 files with Solc 0.8.29
[⠰] Solc 0.8.29 finished in 1.21s
Compiler run successful!

Ran 1 test for test/UpgradeTest.t.sol:UpgradeTest
[PASS] testUpgrade() (gas: 376528)
Suite result: ok. 1 passed; 0 failed; 0 skipped; finished in 10.86ms (3.15ms CPU time)

Ran 1 test suite in 355.58ms (10.86ms CPU time): 1 tests passed, 0 failed, 0 skipped (1 total tests)