代理合约与可升级合约系列（一）：为什么需要可升级？

(bool success, bytes memory returnData) = implementation.delegatecall(calldata)

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

contract Logic {
    uint256 public value;

    event ValueChanged(address indexed caller, uint256 indexed newValue);

    function setValue(uint256 newValue) external returns (bool) {
        value = newValue;
        emit ValueChanged(msg.sender, value);
        return true;
    }
}

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

import "./Logic.sol";

contract Caller {
    uint256 public value;

    event LowLevelCall(bool success, bytes returnData, bool parsedOk);

    function callSetValue(address logic, uint256 _value) external {
        (bool success, bytes memory returnData) = logic.call(
            abi.encodeCall(Logic.setValue, (_value))
        );
        bool parsedOk = _parseBoolReturn(success, returnData);
        emit LowLevelCall(success, returnData, parsedOk);
        require(parsedOk, "Call failed");
    }

    function delegateSetValue(address logic, uint256 _value) external {
        (bool success, bytes memory returnData) = logic.delegatecall(
            abi.encodeCall(Logic.setValue, (_value))
        );
        bool parsedOk = _parseBoolReturn(success, returnData);
        emit LowLevelCall(success, returnData, parsedOk);
        require(parsedOk, "Delegatecall failed");
    }

    /// @dev 兼容两类返回：
    /// - 无返回值：returnData.length == 0，但 success == true
    /// - 返回 bool：returnData 编码了 bool（32 bytes）
    /// 注意：如果目标函数返回的是其他类型（例如 uint256），这里不适用。
    function _parseBoolReturn(bool success, bytes memory returnData) internal pure returns (bool) {
        if (!success) return false;
        // 目标函数没有返回值的常见情况：成功时 returnData 为空
        if (returnData.length == 0) return true;
        // 如果确实返回了数据，且长度符合 bool ABI 编码（32 bytes），尝试 decode
        if (returnData.length == 32) {
            return abi.decode(returnData, (bool));
        }
        // 其他长度：无法按 bool 解析，保守处理为失败（也可以选择直接 return true）
        return false;
    }
}

contract Called {
    uint256 public number;  // slot 0

    function increment() public {
        number++;
    }
}

contract Caller {
    address public implementation;  // slot 0  ← 危险！
    uint256 public myNumber;        // slot 1

    function callIncrement() public {
        implementation.delegatecall(
            abi.encodeWithSignature("increment()")
        );
    }
}

// 逻辑合约地址存储槽
bytes32 constant IMPLEMENTATION_SLOT = 
    bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1);
// = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc

// 管理员地址存储槽  
bytes32 constant ADMIN_SLOT = 
    bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1);
// = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103

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

contract SimpleProxy {
    bytes32 private constant IMPLEMENTATION_SLOT = 
        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    constructor(address _implementation) {
        assembly {
            sstore(IMPLEMENTATION_SLOT, _implementation)
        }
    }

    fallback(bytes calldata data) external payable returns (bytes memory) {
        address impl;
        assembly {
            impl := sload(IMPLEMENTATION_SLOT)
        }

        (bool success, bytes memory result) = impl.delegatecall(data);
        require(success, "Delegatecall failed");
        return result;
    }
}

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

/// @notice 用 Logic 的 ABI 去调用 Proxy
interface ILogic {
    function setValue(uint256 newValue) external returns (bool);
    function value() external view returns (uint256);
}

/// @notice 模拟完整的代理调用流程
contract User {
    /// @notice 演示：用户 -> Proxy -> delegatecall -> Logic 代码 -> 写 Proxy 存储
    function demo(address proxy, address logic, uint256 newValue) 
        public
        returns (uint256 proxyValue, uint256 logicValue, bool success)
    {
        // 通过 Proxy 调用 setValue（会触发 fallback -> delegatecall）
        success = ILogic(proxy).setValue(newValue);

        // 读取 Proxy 的 value（delegatecall 写入的是 Proxy 的存储）
        proxyValue = ILogic(proxy).value();

        // 对比 Logic 自身的 value（应该不变）
        logicValue = ILogic(logic).value();
    }
}