solidity encode encodePacked encodeWithSignature delegatecall

原创已于 2023-03-13 19:49:32 修改 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#区块链

于 2022-05-09 14:47:07 首次发布

区块链专栏收录该内容

15 篇文章

订阅专栏

文章目录

bit bytes 0x uint

bit 二进制位
byte 最小的存储单位 1 byte = 8bit (bytes1-32) bytes 不定长，引用类型
uint8 = 8 bit 最大值就是255 = 2^8-1 （uint(8-256)）
0x 十六进制一位 = 4bit 15 =2^4-1
一个数字或字母占一个字节，一个汉字占用3个字节

编码ASCII和BaseXX

ASCII编码 7个bit位代表一个字符 0-127 每个数字对应一个字符也就是128个字符
[0, 31] 以及 127 (del) 这 33 个属于不可打印的控制字符才有了base64 MIME多媒体传递数据
Base32编码 A-Z（26） 2-7（6）空白用= padding 5个bit代表一个字符 0-31 每个数字代表要给字符也就是32个字符
Base64编码 A-Za-z（52） 0-9(10) + / 6个bit代表一个字符0-63 每个数字代表要给字符也就是64个字符
算法就是3个字节(3*8bit)转成4个base64字符（可打印的字符）,不是3的倍数，用=号补充
ASCII对应的对应的字符转成bit 然后转成base64显示出来
3*8bit=6bit(base64字符)*4
Base58 o0 1i +/ 去掉

1. encode 标准的对参数abi编码

abi.encode(address(0x630959E5aE57D1165c29B5aDC2F77C2bB8B730a0),127)
000000000000000000000000630959e5ae57d1165c29b5adc2f77c2bb8b730a0
000000000000000000000000000000000000000000000000000000000000007f
生成的abi会自动填充到32个byte 就是64个十六进制位

2. encodePacked

abi.encodePacked(address(0x630959E5aE57D1165c29B5aDC2F77C2bB8B730a0),uint8(127));
0x630959e5ae57d1165c29b5adc2f77c2bb8b730a0
7f
不会填充，紧编码数据

3. decode对编码后的数据解码

abi.encode(“a”,“b”)
abi.decode(data, (string, string))

4. encodeWithSelector 对方法keccak256和参数encode并拼接到一起返回

abi.encodeWithSelector(bytes4(keccak256(“set(uint256)”)),number)

5. encodeWithSignature 相当于上面的简写

abi.encodeWithSignature(“set(uint256)”,number)

6. Storage Proxy中的属性要和impl的一致

7. delegatecall 调用编码后的方法修改proxy中的值读取的时候是proxy中的值

8. call 调用编码后的方法修改impl中的值 staticcall-只能读取值，不能写值

// SPDX-License-Identifier: MIT
pragma solidity ^0.8;
contract BytesStudy{
  
    uint public setX; 
    bytes1 a2 = '1';
    bytes5 hh = 0xffffffffff;
    bytes2 b = '11';
    bytes3 c = 0xffffff;
    bytes32 d = '01234567890123456789012345678900';
 
    function test() public view returns (bytes4, bytes1, bytes1, bytes1, bytes1,bytes1){
      bytes4 a = 0x001122FF;
      return (a, a[0], a[1], a[2], a[3],a2);
    }

    function concat(string memory _a, string memory _b) public pure returns (string memory) {
        return string(abi.encodePacked(_a, _b));
    }

  //生成的abi需要填充到32个byte 就是64个十六进制位
  function testEncode() public pure returns (bytes memory){
    return abi.encode("a","b");
  }

   //
    function decode(bytes memory data) public pure returns (string memory _str1, string memory _str2) {
        (_str1, _str2) = abi.decode(data, (string, string));
    }


  //000000000000000000000000630959e5ae57d1165c29b5adc2f77c2bb8b730a0
  //000000000000000000000000000000000000000000000000000000000000007f
   function testEncode2() public pure returns (bytes memory){
    return abi.encode(address(0x630959E5aE57D1165c29B5aDC2F77C2bB8B730a0),127);
  }

      //0xb63e800d000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000500e5eb0cf12736f237604bb90ee996a24def620000000000000000000000000aeb79c89bd801348da200c73533908562a1d726e00000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000000
   //去掉前面的方法id(0x+4个bytes(8个16进制位))就是参数值000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000500e5eb0cf12736f237604bb90ee996a24def620000000000000000000000000aeb79c89bd801348da200c73533908562a1d726e00000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000000
   function test4(bytes memory d) public pure returns (address[] memory,uint256,address,bytes memory,address,address,uint256,address){
     return abi.decode(d, (address[],uint256,address,bytes,address,address,uint256,address));
  }


  //不会填充到64位 uint8=8bit = 1bytes = 2十六进制位
  //0x630959e5ae57d1165c29b5adc2f77c2bb8b730a0
  //7f
  function testEncodePacked2() public pure returns (bytes memory){
      return abi.encodePacked(address(0x630959E5aE57D1165c29B5aDC2F77C2bB8B730a0),uint8(127));
  }

  function testEncodePacked() public pure returns (bytes memory){
     return abi.encodePacked("a","b");
  }
  //方法名和参数的abi编码1
  //传入10返回 
  //0x60fe47b1
  //000000000000000000000000000000000000000000000000000000000000000a
   function testEncodeWithSelector(uint number) public pure returns (bytes memory){
     return abi.encodeWithSelector(bytes4(keccak256("set(uint256)")),number);
  }

  function set(uint x) public {
     setX = x;
  }

    //方法名和参数的abi编码2
  function testEncodeWithSignature(uint number) public pure returns (bytes memory){
    return abi.encodeWithSignature("set(uint256)",number);
  }
 

}

contract MyProxy {
  uint public setX; 

  //可以修改MyProxy-setX值
  //0x60fe47b1
  //000000000000000000000000000000000000000000000000000000000000000a
  function doFunction(address _address,bytes calldata _calldata ) public   returns (bool){
      (bool success,) =   _address.delegatecall(_calldata);
      require(success);
      return true;
  }

  //修改的是BytesStudy-setX值
  function doFunction2(address _address,bytes calldata _calldata ) public   returns (bool){
      (bool success,) =   _address.call(_calldata);
      require(success);
      return true;
  }

}

contract TestPayable {
    uint x;
    uint y;
    fallback() external payable { x = 1; y = msg.value; }
    receive() external payable { x = 2; y = msg.value; }
}

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

contract TestPayable {
    event Log(string methodName,uint _x,uint _y);
    uint x;
    uint y;
    //调用没有对应的方法时候的回调
    fallback() external payable { 
      x = 1; 
      y = msg.value; 
      emit Log("fallback",x,y);
      
    }
    //接受到eth的回调
    receive() external payable {
       x = 2; 
       y = msg.value; 
       emit Log("receive",x,y);
    }
    function clearXY() public returns (uint) {
       x = 0;
       y = 0;
      emit Log("clearXY",x,y);
       return 0;
    }

    function setXY(uint _x,uint _y) public {
       x = _x;
       y = _y;
       emit Log("setXY",x,y);
    }

    function getValue() public pure returns (uint) {
       return 0;
    }
    function getValue2() public pure returns (uint,uint) {
       return (0,1);
    }

}

contract TestSender {
  event Log(string name,address _addre);

  //msg.sender调用这个合约的地址(包括普通地址或者合约地址)
   function testSender() public {
      emit Log("TestSender",msg.sender);
   } 
}

contract TestProxy {
    event Log(string name,address _addre);
    event LogBool(string name,bool isOK, bytes  dt);

 // 测试msg.sender
   function callTestSender(TestSender ts) public {
     emit Log("TestProxy",msg.sender);
     ts.testSender();
   }

  // 写的方法有1个返回值
  function callTestPayable(address _address) public  returns (bool) {
      (bool success,bytes memory returnData) =  _address.delegatecall(abi.encodeWithSignature("clearXY()"));
      emit LogBool("callTestPayable-clearXY",success,returnData);
      require(success);
      return true;
   }

  // 读的方法有1个返回值
   function callTestPayable2(address _address) public  returns (bool) {
      (bool success,bytes memory returnData) =  _address.delegatecall(abi.encodeWithSignature("getValue()"));
      emit LogBool("callTestPayable2-getValue",success,returnData);
      require(success);
      return true;
   }

  //没有对应的调用方法
   function callTestPayableNo(address _address) public  returns (bool) {
      (bool success,) =  _address.delegatecall(abi.encodeWithSignature("clearXYZ()"));
       emit LogBool("callTestPayableNo-clearXYZ",success,'aaaa');
      require(success);
      return true;
   }

    // 读的方法有1个返回值
    //0000000000000000000000000000000000000000000000000000000000000000
    //0000000000000000000000000000000000000000000000000000000000000001
    function callTestPayable3(address _address) public  returns (bool) {
      (bool success,bytes memory returnData) =  _address.delegatecall(abi.encodeWithSignature("getValue2()"));
       emit LogBool("callTestPayable3-getValue2",success,returnData);
      require(success);
      return true;
   }
  
}

9. 实例代码App

MyApp

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

//属性存储插槽slot中，每个solt顺序合约A和aProxy一致，否则会报错
//定义不同的Storage来存储属性值 让合约A,aProxy继承来统一插槽

//用户信息
contract MyAppStorage {

 struct User{
     uint age;
     uint sex;
     bool isMember;
 }
  mapping (address => User) public users;
  bool public isOpen;
  string public appName;
}


contract OwnableStorage {
  address public owner;
   constructor()  {
    owner = msg.sender;
  }

  event OwnerUpdate(address _prevOwner, address _newOwner);

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

  function transferOwnership(address _newOwner) public onlyOwner {
    require(_newOwner != owner, "Cannot transfer to yourself");
    owner = _newOwner;
  }

}

contract ProxyStorage  {

  /**
   * Current contract to which we are proxing
   */
  address public currentContract;

}

contract Storage is MyAppStorage,OwnableStorage,ProxyStorage {
}

interface IMyApp{
 event RegisterUser(
    address indexed _caller,
    address indexed _deployer
  );
  event eOpen(
    bool indexed rIsOpen
  );
  event logName(string name);

   function updateOpen(bool _isOpen) external;
}

contract MyApp is Storage,IMyApp{


  function initialize() external {
    appName = "AppTest";
  }

  modifier onlyOpen {
    require(isOpen,"only open");
    _;
  }
  // 测试阶段用public，正式环境用external
  function registerUser(address beneficiary) public onlyOpen{
    require(beneficiary != address(0), "invalid address");
    require(users[beneficiary].isMember == false, "address is already register");
    User storage user =  users[beneficiary];
    user.isMember = true;
    emit RegisterUser(msg.sender, beneficiary);
  } 

   function updateOpen(bool _isOpen) override public onlyOwner{
         isOpen = _isOpen;
         emit eOpen(isOpen);
    }


}

proxy

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



//用户信息
contract MyAppStorage {

 struct User{
     uint age;
     uint sex;
     bool isMember;
 }
  mapping (address => User) public users;
  bool public isOpen;
  string public appName;
}


contract OwnableStorage {
  address public owner;
   constructor()  {
    owner = msg.sender;
  }

  event OwnerUpdate(address _prevOwner, address _newOwner);

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

  function transferOwnership(address _newOwner) public onlyOwner {
    require(_newOwner != owner, "Cannot transfer to yourself");
    owner = _newOwner;
  }

}

contract ProxyStorage  {

  /**
   * Current contract to which we are proxing
   */
  address public currentContract;

}

contract Storage is MyAppStorage,OwnableStorage,ProxyStorage {
}



contract DelegateProxy {
  /**
   * @dev Performs a delegatecall and returns whatever the delegatecall returned (entire context execution will return!)
   * @param _dst Destination address to perform the delegatecall
   * @param _calldata Calldata for the delegatecall
   */
  function delegatedFwd(address _dst, bytes memory _calldata) internal {
    require(isContract(_dst));
    assembly {
      let result := delegatecall(gas(), _dst, add(_calldata, 0x20), mload(_calldata), 0, 0)
      let size := returndatasize()

      let ptr := mload(0x40)
      returndatacopy(ptr, 0, size)

      // revert instead of invalid() bc if the underlying call failed with invalid() it already wasted gas.
      // if the call returned error data, forward it
      switch result case 0 { revert(ptr, size) }
      default { return(ptr, size) }
    }
  }

  function isContract(address _target) view internal returns (bool) {
    uint256 size;
    assembly { size := extcodesize(_target) }
    return size > 0;
  }
}


contract Proxy is Storage, DelegateProxy {
  event UpgradeE(address indexed newContract);
  event Fallback(bytes msgData);

  function Upgrade(address _proxy) public onlyOwner {
     currentContract = _proxy;
  }

  fallback() external payable {
      emit Fallback(msg.data);
      require(isContract(currentContract),"error currentContract");
      delegatedFwd(currentContract,msg.data);
   }
   receive() external payable {  }

}


contract MyAppProxy is  Proxy {}