コールデータを最適化するための簡潔なABI

1    /**
2     * @dev 呼び出し元に試用のための1000トークンを与えます
3     */
4    function faucet() external {
5        _mint(msg.sender, 1000);
6    }   // function faucet
コピー

1//SPDX-License-Identifier: Unlicense
2pragma solidity ^0.8.0;
3
4
5import { OrisUselessToken } from "./Token.sol";
コピー

1contract CalldataInterpreter {
2
3    OrisUselessToken public immutable token;
コピー

1    /**
2     * @dev トークンアドレスを指定します
3     * @param tokenAddr_ ERC-20コントラクトアドレス
4     */
5    constructor(
6        address tokenAddr_
7    )  {
8        token = OrisUselessToken(tokenAddr_);
9    }   // constructor
すべて表示
コピー

1    function calldataVal(uint startByte, uint length)
2        private pure returns (uint) {
コピー

1        uint _retVal;
2
3        require(length < 0x21,
4            "calldataVal length limit is 32 bytes");
5
6        require(length + startByte <= msg.data.length,
7            "calldataVal trying to read beyond calldatasize");
コピー

1        assembly {
2            _retVal := calldataload(startByte)
3        }
コピー

1
2        _retVal = _retVal >> (256-length*8);
コピー

1
2        return _retVal;
3    }
4
5
6    fallback() external {
コピー

1        uint _func;
2
3        _func = calldataVal(0, 1);
コピー

1
2        // コールデータの情報を使用して
3        // トークンの状態変更メソッドを呼び出します
4
5        // faucet
6        if (_func == 1) {
コピー

1            token.faucet();
2            token.transfer(msg.sender,
3                token.balanceOf(address(this)));
4        }
コピー

1        // transfer (そのためのアローワンスがあると仮定します)
2        if (_func == 2) {
コピー

1            token.transferFrom(
2                msg.sender,
コピー

1                address(uint160(calldataVal(1, 20))),
コピー

1                calldataVal(21, 2)
コピー

1            );
2        }
コピー

1    }   // fallback
2
3}       // contract CalldataInterpreter
コピー

1const { expect } = require("chai");
2
3describe("CalldataInterpreter", function () {
4  it("Should let us use tokens", async function () {
5    const Token = await ethers.getContractFactory("OrisUselessToken")
6    const token = await Token.deploy()
7    await token.deployed()
8    console.log("Token addr:", token.address)
9
10    const Cdi = await ethers.getContractFactory("CalldataInterpreter")
11    const cdi = await Cdi.deploy(token.address)
12    await cdi.deployed()
13    console.log("CalldataInterpreter addr:", cdi.address)
14
15    const signer = await ethers.getSigner()
すべて表示
コピー

1    // 試用のためのトークンを取得
2    const faucetTx = {

1      to: cdi.address,
2      data: "0x01"

1
2    }
3    await (await signer.sendTransaction(faucetTx)).wait()

1// フォーセットがトークンを正しく提供することを確認
2expect(await token.balanceOf(signer.address)).to.equal(1000)

1// CDIにアローワンスを与える (承認はプロキシできません)
2const approveTX = await token.approve(cdi.address, 10000)
3await approveTX.wait()
4expect(await token.allowance(signer.address, cdi.address)).to.equal(10000)

1// トークンを送金
2const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
3const transferTx = {
4  to: cdi.address,
5  data: "0x02" + destAddr.slice(2, 42) + "0100",
6}

1    await (await signer.sendTransaction(transferTx)).wait()
2
3    // 256トークン少なくなっていることを確認
4    expect (await token.balanceOf(signer.address)).to.equal(1000-256)
5
6    // そして、送信先がそれらを受け取ったことを確認
7    expect (await token.balanceOf(destAddr)).to.equal(256)
8  })    // it
9})      // describe
すべて表示

1    // CalldataInterpreterアドレスを指定できる唯一のアドレス
2    address owner;
3
4    // CalldataInterpreterアドレス
5    address proxy = address(0);
コピー

1    /**
2     * @dev ERC20コンストラクタを呼び出します。
3     */
4    constructor(
5    ) ERC20("Oris useless token-2", "OUT-2") {
6        owner = msg.sender;
7    }
コピー

1    /**
2     * @dev プロキシ (CalldataInterpreter) のアドレスを設定します。
3     * オーナーが1回だけ呼び出し可能
4     */
5    function setProxy(address _proxy) external {
6        require(msg.sender == owner, "Can only be called by owner");
7        require(proxy == address(0), "Proxy is already set");
8
9        proxy = _proxy;
10    }    // function setProxy
すべて表示
コピー

1    /**
2     * @dev 一部の関数はプロキシによってのみ呼び出し可能です。
3     */
4    modifier onlyProxy {
コピー

1      require(msg.sender == proxy);
コピー

1      _;
2    }
コピー

1   /* プロキシが実際にアカウントのプロキシとして機能できるようにする関数 */
2
3    function transferProxy(address from, address to, uint256 amount)
4        public virtual onlyProxy() returns (bool)
5    {
6        _transfer(from, to, amount);
7        return true;
8    }
9
10    function approveProxy(address from, address spender, uint256 amount)
11        public virtual onlyProxy() returns (bool)
12    {
13        _approve(from, spender, amount);
14        return true;
15    }
16
17    function transferFromProxy(
18        address spender,
19        address from,
20        address to,
21        uint256 amount
22    ) public virtual onlyProxy() returns (bool)
23    {
24        _spendAllowance(from, spender, amount);
25        _transfer(from, to, amount);
26        return true;
27    }
すべて表示
コピー

1        // transfer (アローワンスは不要)
2        if (_func == 2) {
3            token.transferProxy(
4                msg.sender,
5                address(uint160(calldataVal(1, 20))),
6                calldataVal(21, 2)
7            );
8        }
9
10        // approve
11        if (_func == 3) {
12            token.approveProxy(
13                msg.sender,
14                address(uint160(calldataVal(1, 20))),
15                calldataVal(21, 2)
16            );
17        }
18
19        // transferFrom
20        if (_func == 4) {
21            token.transferFromProxy(
22                msg.sender,
23                address(uint160(calldataVal( 1, 20))),
24                address(uint160(calldataVal(21, 20))),
25                calldataVal(41, 2)
26            );
27        }
すべて表示
コピー

1const Cdi = await ethers.getContractFactory("CalldataInterpreter")
2const cdi = await Cdi.deploy(token.address)
3await cdi.deployed()
4await token.setProxy(cdi.address)
コピー

1console.log("CalldataInterpreter addr:", cdi.address)
2
3// アローワンスを確認するには2つの署名者が必要
4const signers = await ethers.getSigners()
5const signer = signers[0]
6const poorSigner = signers[1]
コピー

1// トークンを送金
2const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
3const transferTx = {
4  to: cdi.address,
5  data: "0x02" + destAddr.slice(2, 42) + "0100",
6}
7await (await signer.sendTransaction(transferTx)).wait()
コピー

1// 承認とtransferFrom
2const approveTx = {
3  to: cdi.address,
4  data: "0x03" + poorSigner.address.slice(2, 42) + "00FF",
5}
6await (await signer.sendTransaction(approveTx)).wait()
7
8const destAddr2 = "0xE1165C689C0c3e9642cA7606F5287e708d846206"
9
10const transferFromTx = {
11  to: cdi.address,
12  data: "0x04" + signer.address.slice(2, 42) + destAddr2.slice(2, 42) + "00FF",
13}
14await (await poorSigner.sendTransaction(transferFromTx)).wait()
15
16// approve / transferFrom の組み合わせが正しく行われたことを確認
17expect(await token.balanceOf(destAddr2)).to.equal(255)
すべて表示
コピー