一种压缩Solidity函数参数的方法

Posted 2022-03-02 Zero_Nothing

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了一种压缩Solidity函数参数的方法相关的知识，希望对你有一定的参考价值。

我们知道，在Solidity的合约调用中，函数参数会自动被扩展为256位（32字节），这就意味着哪怕是一个bool类型的参数，它也会完全占用32字节（64位）。我们知道，布尔的true实际中会编码成01，那么它前面的62个0只是填充位，是没有实际用处的。但是我们仍然需要为这些填充的0付gas费用。于是有人就想，能否压缩一下参数，不去支付这个额外的费用呢？答案是可以尝试一下的。

在UniswapV3中，也意识到了这一点，于是他们也部分采用了压缩参数的方法。并且给出了在Solidity中进行解码地址类型和Uint24类型变量的方法。本文正是基于此解码进行的一个自我学习。

基本思路为：我们要调用的函数不定义参数，所有需要使用的参数按顺序压缩编码后放在payload中，发交易时直接构造交易对象然后签名发送。我们一步一步来重现这个过程。

一、新建一个工程

这里我们推荐使用hardhat来新建一个工程，这里我们使用yarn作为包管理器。

打开控制台，切换到工作目录，例如work目录。
运行mkdir encode_param && cd encode_param && yarn init并一路回车。
运行yarn add hardhat --dev，耐心等待完成。
运行npx hardhat，选择Create a basic sample project并一路回车。
运行code .使用vscode打开，或者手动使用vscode打开。

将Greeter.sol重命名为DecodeParams.sol，并替换合约内容如下：

//SPDX-License-Identifier: Unlicense
pragma solidity =0.6.6;
contract DecodeParams 
    event ParamDecode(address user1,address user2,bool isVip, uint112 amount,uint24 fee0,uint24 fee1,uint24 fee2); 

    function callWithParams(
        address user1,
        address user2,
        bool isVip,
        uint112 amount,
        uint24 fee0,
        uint24 fee1,
        uint24 fee2
    ) external 
        emit ParamDecode(user1,user2,isVip,amount,fee0,fee1,fee2);

合约的内容很简单，就是定义了多个参数的函数，然后在函数中触发一个相应的事件来记录全部参数。

修改hardhat.config.js，将solidity编译器版本改为0.6.6。
```
module.exports = 
  solidity: "0.6.6",
;
```
运行npx hardhat compile进行编译。

写一个简单的单元测试来进行测试，将test/sample-test.js的内容替换如下：

const  expect  = require("chai");
const  ethers  = require("hardhat");

describe("DecodeParams", function () 

  let instance;
  let user1,user2,users;
  let args;

  beforeEach( async () => 
    const DecodeParams = await ethers.getContractFactory("DecodeParams");
    instance = await DecodeParams.deploy();

    [user1,user2,...users] = await ethers.getSigners();
    args = [user1.address,user2.address,true,ethers.utils.parseEther("1003.59"),30,15,8];
  );

  describe("Call with params and without params", () => 
    it("Should emit ParamDecode with function params", async function () 
      await expect(instance.callWithParams(...args)).to.emit(instance,"ParamDecode")
        .withArgs(...args);
    );
  )
  
);

运行单元测试npx hardhat test，会得到 1 passing的结果。

二、获取消耗的gas

我们进行测试的最终目的是比较参数压缩和参数不压缩时的gas消耗。因此我们非常有必要先获取正常调用时的gas消耗。我们使用hardhat-gas-reporter插件来获取。

项目根目录下运行yarn add hardhat-gas-reporter --dev来安装该插件。
编辑配置文件hardhat.config.js，在第二行添加如下内容：require("hardhat-gas-reporter");

再次运行npx hardhat test来进行单元测试，此时会显示消耗的gas。

·-----------------------------------|----------------------------|-------------|-----------------------------·
|        Solc version: 0.6.6        ·  Optimizer enabled: false  ·  Runs: 200  ·  Block limit: 30000000 gas  │
····································|····························|·············|······························
|  Methods                                                                                                   │
·················|··················|··············|·············|·············|···············|··············
|  Contract      ·  Method          ·  Min         ·  Max        ·  Avg        ·  # calls      ·  eur (avg)  │
·················|··················|··············|·············|·············|···············|··············
|  DecodeParams  ·  callWithParams  ·           -  ·          -  ·      25819  ·            2  ·          -  │
·················|··················|··············|·············|·············|···············|··············
|  Deployments                      ·                                          ·  % of limit   ·             │
····································|··············|·············|·············|···············|··············
|  DecodeParams                     ·           -  ·          -  ·     172459  ·        0.6 %  ·          -  │
·-----------------------------------|--------------|-------------|-------------|---------------|-------------·

可以看到，运行我们的callWithParams函数消耗了 25819 的gas。

ps:未知原因，需要使用VPN才能获取到结果，否则运行npx hardhat test会长时间卡住。

三、参数编码后直接发送交易。

在我们上面的测试中，我们直接调用了合约的函数来进行测试。而我们知道，其底层其实相当于一个api调用，是将一个交易对象签名后发送给了节点服务器。这种方式和我们使用参数压缩的方式更为接近，因此，我们将函数参数编码后再发送一次交易进行尝试。

我们修改一下sample-test.js，增加以下代码片断以进行一个新的测试：

 describe("Call with params and without params", () => 
    // ....
    it("Call with encode function params", async () => 
      let data = instance.interface.encodeFunctionData("callWithParams",args)
      let transaction = 
        to:instance.address,
        data,
      
      await expect(user1.sendTransaction(transaction)).to.emit(instance,"ParamDecode").withArgs(...args);
      console.log("data:",data);
    );
  )

可以看到，我们上面的测试是先编码参数，然后构建一个交易对象，最后使用钱包签名发送该交易对象。

我们再次运行npx hardhat test,仍然会得到相同的结果(除了#calls的值有所不同)，从输出结果中可以得到，我们使用的gas仍然为25819。

最后，我们打印出了那个编码后的payload，为：

0xe9aecc51000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb9226600000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c80000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000036679bebc096470000000000000000000000000000000000000000000000000000000000000000001e000000000000000000000000000000000000000000000000000000000000000f0000000000000000000000000000000000000000000000000000000000000008

我们下一步的目标就是压缩这个payload，离目标很近了。

四、分析`payload`

下一步压缩之前，我们先分析一下这个payload。注意，这里显示的是人类易读的16进制，因此会有"0x"前缀，在真实调用时，是没有这两个字符的，切记。

有人说为什么这个payload怎么这么长啊，是因为32字节对应64位长度啊，一个字节8位，一个16进制数据4位，一个字节等于2个16进制数据。

最开始4个字节（8位）是函数选择器，就是用来匹配合约中哪个函数的，其有专门的计算方法，大抵是将函数和参数列表合起来计算一个哈希再取前四位。笔者以前有篇文章介绍了其计算方法，这里就不再重复了。

接下来的000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266是我们第一个参数，user1，可以看到，我们的地址只用了40位（Uint160），前面有24个0是没有用的，我们的目标就是把它压缩掉。

同理，00000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c8是我们第二个参数，user2，同样也要压缩掉前面24个0。

0000000000000000000000000000000000000000000000000000000000000001就是我们的布尔值true了，因为Solidity中最小整数类型为uint8,我们使用它来替代bool类型，它为2个16进制数据，因此前面的 62（64-2）个0都是无用的，需要压缩掉。

000000000000000000000000000000000000000000000036679bebc096470000是我们的参数ethers.utils.parseEther(“1003.59”)。因为我们的数据类型是uint112，它为112/8=14个字节占28位长度16进制数据，所以前面 36个0是无用的。

000000000000000000000000000000000000000000000000000000000000001e是我们的参数fee0。因为它是uint24类型的，因此只需要24/8*2= 6位长度16进制数据就能显示，所以前面 58个0都是无用的。

后面的fee1和fee2也是同样的。

通过上面的分析我们可以知道，总长度为 7 * 64 = 448 的16进制数据中（不算函数选择器），有 24 * 2 + 62 + 36 + 58 * 3 = 320 个0是无用的，占比约 71.4%。因此我们浪费了相当多的空间（特别是涉及到一些长度很小的数据类型），我们只需要 448 - 320 = 128 个 16进制数据。

我们压缩参数就是为了去掉这些多余的0，把它们紧密排列在一起，然后在合约中解析出来。

五、压缩参数编码

还记得我们上面编码后手动发送交易的方法么？我们简单的把payload压缩一下再发送出去就行了。

我们首先修改合约，编辑DecodeParams.sol，增加一个空函数：

function callWithoutParams() external 
  //todo

修改sample-test.js，增加压缩参数的相关内容，暂时的代码如下：

describe("Call with params and without params", () => 

    /**
     * 
     * @param * v 10进制数|16进制或者BigNumber
     * @param * l 数据长度，如uint112就是112
     * @return 返回无多余填充0的编码
     */
    function encodeUint(v,l) 
      let b = ethers.BigNumber.from(v)
      b = b.toHexString().substring(2);
      let len = l/8 * 2;
      assert.ok(b.length <= len,"out of bounds");
      return "0".repeat(len - b.length) + b;
    

    // it("Should emit ParamDecode with function params", async function () 
    //   await expect(instance.callWithParams(...args)).to.emit(instance,"ParamDecode").withArgs(...args);
    // );

    // it("Call with encode function params", async () => 
    //   let data = instance.interface.encodeFunctionData("callWithParams",args)
    //   let transaction = 
    //     to:instance.address,
    //     data,
    //   
    //   await expect(user1.sendTransaction(transaction)).to.emit(instance,"ParamDecode").withArgs(...args);
    //   console.log("data:",data);
    // );

    it("Call with packed function params", async () => 
      let selector = instance.interface.encodeFunctionData("callWithoutParams",[]); //selector，因为此时没有参数
      let data = selector + args[0].substring(2) + args[1].substring(2) + encodeUint(args[2] ? 1 : 0,8);
      data += encodeUint(args[3],112) + encodeUint(args[4],24) + encodeUint(args[5],24) + encodeUint(args[6],24);
      console.log("data:",data);
      //check params
      assert.equal(data.substring(0,10),selector);
      assert.equal("0x" + data.substring(10,50),user1.address);
      assert.equal("0x" + data.substring(50,90),user2.address);
      assert.equal(data.substring(90,92),args[2] ? "01" : "00");
      let amount = ethers.BigNumber.from("0x" + data.substring(92,92 + 28));
      assert.ok(amount.eq(args[3]));
      let fee0 = ethers.BigNumber.from("0x" + data.substring(120,126))
      assert.equal(+ fee0.toString(), args[4])
      let fee1 = ethers.BigNumber.from("0x" + data.substring(126,132))
      assert.equal(+ fee1.toString(), args[5])
      let fee2 = ethers.BigNumber.from("0x" + data.substring(132,138))
      assert.equal(+ fee2.toString(), args[6])
      assert.ok(data.length === 128 + 10);
      let transaction = 
        to:instance.address,
        data,
      
    );

  )

为了节省时间，我们注释掉了前两个测试，稍后会重新打开它，同时我们在hardhat.config.js中注释掉require("hardhat-gas-reporter");，我们也会在稍后重新打开它。

运行npx hardhat test，会输出我们压缩后的编码：

0xad094ee6f39Fd6e51aad88F6F4ce6aB8827279cffFb9226670997970C51812dc3A010C7d01b50e0d17dc79C801000000000036679bebc09647000000001e00000f000008

同样，这里ad094ee6为函数选择器，在上面的单元测试中，已经详细验证了编码的数据刚好同我们args中的对应的元素相同。

在单元测试的最后，我们构造了一个交易对象准备接下来使用，可以看到这里的payload就是我们的data。

六、在合约中解码

在合约中解码就是将payload(msg.data)解码成我们需要的参数。注意，合约中的msg.data就是上述最后一个单元测试中的data，让我们把合约中那个空函数增加实现。

function callWithoutParams() external 
    address user1;
    address user2;
    uint8 v_amount; //经过多次测试，直接从汇编中读取bool变量为整个32字节，因此这里需要读取uint8的值。
    uint112 amount;
    uint24 fee0;
    uint24 fee1;
    uint24 fee2;
    bytes memory data = msg.data; //这里msg.data位于calldata，所以必须复制一份
    assembly 
        user1 := mload(add(data, 24))
        user2 := mload(add(data, 44))
        v_amount := mload(add(data, 45))
        amount := mload(add(data,59))
        fee0 := mload(add(data,62))
        fee1 := mload(add(data,65))
        fee2 := mload(add(data,68))
    
    emit ParamDecode(user1,user2,v_amount > 0,amount,fee0,fee1,fee2);

运行npx hardhat compile来编译合约。

七、完成对比测试

取消在第五步中注释的测试和hardhat.config.js中的require("hardhat-gas-reporter");注释。在sample-test.js的"Call with packed function params" 测试中最下方添加下面这一行

await expect(user1.sendTransaction(transaction)).to.emit(instance,"ParamDecode").withArgs(...args);。

完整的单元测试文件如下：

const  expect, assert  = require("chai");
const  ethers  = require("hardhat");

describe("DecodeParams", function () 

  let instance;
  let user1,user2,users;
  let args;

  beforeEach( async () => 
    const DecodeParams = await ethers.getContractFactory("DecodeParams");
    instance = await DecodeParams.deploy();
    [user1,user2,...users] = await ethers.getSigners();
    args = [user1.address,user2.address,true,ethers.utils.parseEther("1003.59"),30,15,8];
  );

  describe("Call with params and without params", () => 

    /**
     * 
     * @param * v 10进制数|16进制或者BigNumber
     * @param * l 数据长度，如uint112就是112
     * @return 返回无多余填充0的编码
     */
    function encodeUint(v,l) 
      let b = ethers.BigNumber.from(v)
      b = b.toHexString().substring(2);
      let len = l/8 * 2;
      assert.ok(b.length <= len,"out of bounds");
      return "0".repeat(len - b.length) + b;
    
    
    it("Should emit ParamDecode with function params", async function () 
      await expect(instance.callWithParams(...args)).to.emit(instance,"ParamDecode").withArgs(...args);
    );

    it("Call with encode function params", async () => 
      let data = instance.interface.encodeFunctionData("callWithParams",args)
      let transaction = 
        to:instance.address,
        data,
      
      await expect(user1.sendTransaction(transaction)).to.emit(instance,"ParamDecode").withArgs(...args);
    );

    it("Call with packed function params", async () => 
      let selector = instance.interface.encodeFunctionData("callWithoutParams",[]); //selector，因为此时没有参数
      let data = selector + args[0].substring(2) + args[1].substring(2) + encodeUint(args[2] ? 1 : 0,8);
      data += encodeUint(args[3],112) + encodeUint(args[4],24) + encodeUint(args[5],24) + encodeUint(args[6],24);
      //check params
      assert.equal(data.substring(0,10),selector);
      assert.equal("0x" + data.substring(10,50),user1.address);
      assert.equal("0x" + data.substring(50,90),user2.address);
      assert.equal(data.substring(90,92),args[2] ? "01" : "00");
      let amount = ethers.BigNumber.from("0x" + data.solidity之函数参数和返回变量
 Solidity极简入门#30. Try Catch
 web3.js 调用传递函数返回 Solidity 函数的参数数量无效
 为啥我的 Solidity 构造函数需要两个未在参数中指定的变量？
 将Solidity abi.json压缩成一行
 Solidity极简入门#22. Call