Calldata 최적화를 위한 짧은 ABI

1    /**
2     * @dev 호출자에게 1,000개의 토큰을 제공합니다
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    /**
3     * @dev 토큰 주소를 지정합니다
4     * @param tokenAddr_ ERC-20 계약 주소
5     */
6    constructor(
7        address tokenAddr_
8    )  {
9        token = OrisUselessToken(tokenAddr_);
10    }   // constructor
모두 보기
복사

1    function calldataVal(uint startByte, uint length)
2        private pure returns (uint) {
복사

1        uint _retVal;\n\n        require(length < 0x21,\n            \"calldataVal 길이 제한은 32바이트입니다\");\n\n        require(length + startByte <= msg.data.length,\n            \"calldataVal 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        // calldata의 정보를 사용하여
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("토큰을 사용할 수 있도록 해야 합니다", 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// faucet이 토큰을 올바르게 제공하는지 확인
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     * 소유자만 한 번 호출할 수 있습니다
4     */
5    function setProxy(address _proxy) external {
6        require(msg.sender == owner, "소유자만 호출할 수 있습니다");
7        require(proxy == address(0), "프록시가 이미 설정되었습니다");
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// 허용량을 확인하기 위해 두 명의 서명자가 필요합니다
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// approval 및 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)
모두 보기
복사