主网分批交易的经济学研究

Question

我想知道，如果你要写一份智能合同，批量发送N个交易，而不是进行N个单独的交易，那么是否可以在汽油费上实现边际节约。

考虑到部署和与批处理事务处理的智能契约交互的字节代码每字符有200个气体单位，理论上是否有可能做到这一点？即使是少量的< 5%的储蓄也有规模经济。

这是我写过的第一份聪明的合同。如果人们能指出，如果我可以通过以下方式将字节代码最小化，我会非常感激：

• 重构
• 重新设计合同，这样我们就有了一个相互作用的合同系统，可以做同样的事情。

// gas estimates (greater than 10 * standard_transaction_cost)
//{
//    "Creation": {
//        "codeDepositCost": "240000",
//        "executionCost": "48740",
//        "totalCost": "288740"
//    },
//    "External": {
//        "addCashouts(address[],uint256[])": "infinite",
//        "processCashouts()": "infinite"
//    }
//} 

pragma solidity >=0.8.2 <0.9.0;

contract BatchCashout {
    // fake address 
    address owner = 0x9709bA41A4778cad5616d52F25C7700000000000;
    bool processed = false;

    function processCashouts() external {
        require(msg.sender == owner, "Only the contract owner can process cashouts");
        require(!processed, "Cashouts have already been processed");

        address payable[] memory recipients = new address payable[](9);
        recipients[0] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);
        recipients[1] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);
        recipients[2] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);
        recipients[3] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);
        recipients[4] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);
        recipients[5] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);
        recipients[6] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);
        recipients[7] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);
        recipients[8] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);
        recipients[9] = payable(0x9709bA41A4778cad5616d52F25C7700000000000);

        recipients[0].transfer(1 ether);
        recipients[1].transfer(1 ether);
        recipients[2].transfer(1 ether);
        recipients[3].transfer(1 ether);
        recipients[4].transfer(1 ether);
        recipients[5].transfer(1 ether);
        recipients[6].transfer(1 ether);
        recipients[7].transfer(1 ether);
        recipients[8].transfer(1 ether);
        recipients[9].transfer(1 ether);

        processed = true;
    }
}

谢谢!

Answer 1

您应该查看Ethereum上的MakerDAO的多方面合同；它部署在0xeefBa1e63905eF1D7ACbA5a8513c70307C1cE441上。

下面是一个调用Makerdao的助手库multicall.js的智能契约的示例：

const multicall = require("@makerdao/multicall")

const config = {
    rpcUrl: "https://your-rpc-endpoint/12345",
    multicallAddress: "0xeefba1e63905ef1d7acba5a8513c70307c1ce441"
};

const addressArr = [
  "0x2B6ee955a98cE90114BeaF8762819d94C107aCc7",
  "0x2bB42C655DdDe64EE508a0Bf29f9D1c6150Bee5F"
];

async function main() {
  const startTime = Date.now();
  console.log("Started...");

  const calls = [];

  // Retrieve the Ether balance of each Ethereum address in addressArr using the multicall library.
  for (let i = 0; i < addressArr.length; i++) {
      const callObj = {
          call: [
              'getEthBalance(address)(uint256)',
              addressArr[i]
          ],
          returns: [
              [`ETH_BALANCE ${addressArr[i]}`, val => val / 10 ** 18]
          ]
      };
      calls.push(callObj);
  }

  const result = await multicall.aggregate(calls, config);
  console.log(result);

  const timeFromStart = Date.now() - startTime;
  console.log(`Result received in ${timeFromStart / 1000} seconds`);
}

main();

main函数遍历addressArr数组中的每个地址，并为每个地址创建一个调用对象。这些调用对象使用多个库来检索每个地址的以太平衡。

一旦创建了所有调用对象并将其推送到calls数组中，就会使用调用对象数组和配置对象调用多个库的aggregate函数。该函数将所有调用的结果聚合到一个对象中，该对象存储在result变量中。

您也可以使用它发送以太或调用写契约方法。

从气体角度看，根据我的测试，这并没有多大区别。使用多个合同的好处是它的结果被强制在同一个块中。有时候很方便。