ABI编码 #

contract ABIEncode {
    function encodeUint(uint256 value) public pure returns (bytes memory) {
        return abi.encode(value);
    }
    
    function encodeMultiple(
        uint256 a,
        address b,
        bool c
    ) public pure returns (bytes memory) {
        return abi.encode(a, b, c);
    }
    
    function encodeArray(uint256[] memory arr) public pure returns (bytes memory) {
        return abi.encode(arr);
    }
}

contract EncodeFeatures {
    // abi.encode：包含类型信息
    function encodeWithType(uint256 value) public pure returns (bytes memory) {
        return abi.encode(value);  // 32字节，包含填充
    }
    
    // 每个参数编码为32字节
    function encodeSize() public pure returns (uint256) {
        bytes memory data = abi.encode(uint256(1), uint256(2));
        return data.length;  // 64字节
    }
}

contract ABIEncodePacked {
    function packUint(uint256 value) public pure returns (bytes memory) {
        return abi.encodePacked(value);
    }
    
    function packMultiple(
        uint256 a,
        address b,
        bool c
    ) public pure returns (bytes memory) {
        return abi.encodePacked(a, b, c);
    }
    
    function packString(string memory str) public pure returns (bytes memory) {
        return abi.encodePacked(str);
    }
}

contract PackedFeatures {
    // abi.encodePacked：紧凑编码，不包含类型信息
    function compareEncoding() public pure returns (bytes memory, bytes memory) {
        uint256 value = 1;
        return (abi.encode(value), abi.encodePacked(value));
        // encode: 32字节
        // encodePacked: 1字节
    }
    
    // 字符串拼接
    function concatStrings(
        string memory a,
        string memory b
    ) public pure returns (string memory) {
        return string(abi.encodePacked(a, b));
    }
    
    // 计算哈希
    function hash(
        address sender,
        uint256 amount,
        uint256 nonce
    ) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(sender, amount, nonce));
    }
}

contract EncodeWithSelector {
    function encodeTransfer(
        address to,
        uint256 amount
    ) public pure returns (bytes memory) {
        return abi.encodeWithSelector(
            bytes4(keccak256("transfer(address,uint256)")),
            to,
            amount
        );
    }
    
    function encodeApprove(
        address spender,
        uint256 amount
    ) public pure returns (bytes memory) {
        return abi.encodeWithSelector(
            0x095ea7b3,  // approve(address,uint256) 的选择器
            spender,
            amount
        );
    }
}

contract UseSelector {
    function callTransfer(
        address token,
        address to,
        uint256 amount
    ) public returns (bool) {
        bytes memory data = abi.encodeWithSelector(
            bytes4(keccak256("transfer(address,uint256)")),
            to,
            amount
        );
        
        (bool success, bytes memory result) = token.call(data);
        require(success, "Call failed");
        
        return abi.decode(result, (bool));
    }
}

contract EncodeWithSignature {
    function encodeTransfer(
        address to,
        uint256 amount
    ) public pure returns (bytes memory) {
        return abi.encodeWithSignature(
            "transfer(address,uint256)",
            to,
            amount
        );
    }
    
    // 等价于
    function encodeWithSelectorEquivalent(
        address to,
        uint256 amount
    ) public pure returns (bytes memory) {
        return abi.encodeWithSelector(
            bytes4(keccak256("transfer(address,uint256)")),
            to,
            amount
        );
    }
}

contract ABIDecode {
    function decodeUint(bytes memory data) public pure returns (uint256) {
        return abi.decode(data, (uint256));
    }
    
    function decodeMultiple(
        bytes memory data
    ) public pure returns (uint256, address, bool) {
        return abi.decode(data, (uint256, address, bool));
    }
    
    function decodeArray(bytes memory data) public pure returns (uint256[] memory) {
        return abi.decode(data, (uint256[]));
    }
}

contract EncodeDecode {
    struct User {
        address wallet;
        string name;
        uint256 balance;
    }
    
    function encodeUser(User memory user) public pure returns (bytes memory) {
        return abi.encode(user);
    }
    
    function decodeUser(bytes memory data) public pure returns (User memory) {
        return abi.decode(data, (User));
    }
    
    function roundTrip(User memory user) public pure returns (User memory) {
        bytes memory data = encodeUser(user);
        return decodeUser(data);
    }
}

contract SignatureVerification {
    function verify(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) public pure returns (bool) {
        bytes32 r;
        bytes32 s;
        uint8 v;
        
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }
        
        return ecrecover(hash, v, r, s) == signer;
    }
    
    function hashMessage(
        address to,
        uint256 amount,
        uint256 nonce
    ) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(to, amount, nonce));
    }
}

contract CrossContractCall {
    function callFunction(
        address target,
        string memory functionName,
        uint256 value
    ) public returns (bytes memory) {
        bytes memory data = abi.encodeWithSignature(
            functionName,
            value
        );
        
        (bool success, bytes memory result) = target.call(data);
        require(success, "Call failed");
        
        return result;
    }
}