ERC20Permitについて非エンジニアでもわかるように1から丁寧にわかりやすく解説

function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external
function nonces(address owner) external view returns (uint)
function DOMAIN_SEPARATOR() external view returns (bytes32)

function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external

function nonces(address owner) external view returns (uint)

function DOMAIN_SEPARATOR() external view returns (bytes32)

{
  "types": {
    "EIP712Domain": [
      {
        "name": "name",
        "type": "string"
      },
      {
        "name": "version",
        "type": "string"
      },
      {
        "name": "chainId",
        "type": "uint256"
      },
      {
        "name": "verifyingContract",
        "type": "address"
      }
    ],
    "Permit": [{
      "name": "owner",
      "type": "address"
      },
      {
        "name": "spender",
        "type": "address"
      },
      {
        "name": "value",
        "type": "uint256"
      },
      {
        "name": "nonce",
        "type": "uint256"
      },
      {
        "name": "deadline",
        "type": "uint256"
      }
    ],
    "primaryType": "Permit",
    "domain": {
      "name": erc20name,
      "version": version,
      "chainId": chainid,
      "verifyingContract": tokenAddress
  },
  "message": {
    "owner": owner,
    "spender": spender,
    "value": value,
    "nonce": nonce,
    "deadline": deadline
  }
}}

pragma solidity ^0.8.0;

import "./IERC20Permit.sol";
import "../ERC20.sol";
import "../../../utils/cryptography/ECDSA.sol";
import "../../../utils/cryptography/EIP712.sol";
import "../../../utils/Counters.sol";

abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    bytes32 private constant _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;

constructor(string memory name) EIP712(name, "1") {}

function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
) public virtual override {
    require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

    bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

    bytes32 hash = _hashTypedDataV4(structHash);

    address signer = ECDSA.recover(hash, v, r, s);
    require(signer == owner, "ERC20Permit: invalid signature");

    _approve(owner, spender, value);
}

function nonces(address owner) public view virtual override returns (uint256) {
    return _nonces[owner].current();
}

function DOMAIN_SEPARATOR() external view override returns (bytes32) {
    return _domainSeparatorV4();
}

function _useNonce(address owner) internal virtual returns (uint256 current) {
    Counters.Counter storage nonce = _nonces[owner];
    current = nonce.current();
    nonce.increment();
}

require("@nomicfoundation/hardhat-toolbox");

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: {
    version: "0.8.17",
    settings: {
      optimizer: {
        enabled: true,
        runs: 1000,
      },
    },
  },
};

$ mkdir contracts/CardeneToken.sol

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract CardeneToken is ERC20 {
    // トークン名は"Cardene Token"、トークンシンボルは"CARD"。
    constructor() ERC20("Cardene Token", "CARD") {}

    /// @notice CARDトークンを発行する関数。
    /// @ param _to 発行したトークンを送るアドレス。
    /// @ param _amount 発行するトークン数。
    function mint(address _to, uint _amount) external {
        _mint(_to, _amount);
    }
}

$ mkdir contracts/IERC20Permit.sol

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

interface IERC20Permit {
    /// @notice ERC20トークンの総量を返す関数。
    function totalSupply() external view returns (uint);

    /// @notice accountに渡されたアドレスが所有しているERC20トークンの量を返す関数。
    /// @param account 特定のアドレス。
    /// @return アドレスが所有しているERC20トークンの量。
    function balanceOf(address account) external view returns (uint);

    /// @notice recipientに渡されたアドレスに、amount分のERC20トークンを送る関数。
    /// @param recipient ERC20トークンの送り先アドレス。
    /// @param amount 送りたいERC20トークンの量。
    /// @return 送金が成功したか失敗したかのbool値。
    function transfer(address recipient, uint amount) external returns (bool);

    /// @notice spenderに渡されたアドレスが、ownerが所有するERC20トークンをどれくらい送る許可を与えられているか返す関数。
    /// @param owner ERC20トークンの所有者アドレス。
    /// @param spender ownerが所有するERC20トークンをどれくらいの量送る許可を与えられているか確認したいアドレス。
    /// @return ERC20トークンを送れる許可を与えられている量。
    function allowance(address owner, address spender) external view returns (uint);

    /// @notice spenderで指定されたアドレスに、amout分のERC20トークンの送る許可を与える関数。
    /// @param spender ERC20トークンを送る許可を与えたいアドレス。
    /// @param amount　許可を与えるERC20トークンの量。
    /// @return 実行が成功したかのbool値。
    function approve(address spender, uint amount) external returns (bool);

    /// @notice spenderに渡されたアドレスから、recipientに渡されたアドレスへamount分のERC20トークンを送る関数。
    /// @param sender ERC20トークンの所有者アドレス。
    /// @param recipient senderのERC20トークンを送る許可を与えられているアドレス。
    /// @param amount 送りたいERC20トークンの量。
    /// @return 実行が成功したかのbool値。
    function transferFrom(
        address sender,
        address recipient,
        uint amount
    ) external returns (bool);

    /// @notice 第3者アドレスがERC20トークンを送る関数。
    /// @param owner ERC20トークンの所有者アドレス。
    /// @param spender ERC20トークンを代わりに送るアドレス。（ガス代を代わりに負担）
    /// @param value　送りたいERC20トークンの量。
    /// @param deadline 送れる期限。
    /// @param v リカバリーID。
    /// @param r ECDSA署名の出力。
    /// @param s ECDSA署名の出力。
    function permit(
        address owner,
        address spender,
        uint value,
        uint deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    //　イベント
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
}

$ mkdir contracts/Bank.sol

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";

contract Bank is ERC20, Ownable, ERC20Permit {
    // ERC20とERC20Permitのconstructorを呼び出しています。
    constructor(string memory name, string memory symbol) ERC20(name, symbol) ERC20Permit(name) {}

    /// @notice ERC20トークンを発行する関数。
    /// @param to ERC20トークンを送りたいアドレス。
    /// @param amount 発行するERC20トークンの量。
    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

    /// @notice msg.senderからコントラクトにamount分のERC20トークンを送る関数。
    /// @param amount 送りたいERC20トークンの量。
    function deposit(uint amount) external {
        transferFrom(msg.sender, address(this), amount);
    }

    /// @notice permit関数を実行し、第3者がガス代を負担して、特定のアドレスにERC20トークンを送る関数。
    /// @param amount 送りたいERC20トークンの量。
    /// @param deadline 実行できる期限。
    /// @param v リカバリーID。
    /// @param r ECDSA署名の出力。
    /// @param s ECDSA署名の出力。
    function depositWithPermit(address _owner, address _spender, uint amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
        permit(_owner, _spender, amount, deadline, v, r, s);
        require(allowance(_owner, _spender) > 0, "There are no tokens allowed for transfer.");
        transferFrom(_owner, _spender, amount);
    }
}

$ mkdir test/bank-test.js

const { expect } = require("chai")
const { ethers } = require("hardhat")

// 署名を作成。
async function getPermitSignature(owner, contract, spender, value, deadline) {
    const [nonce, name, version, chainId] = await Promise.all([
        contract.nonces(owner.address),
        contract.name(),
        "1",
        owner.getChainId(),
    ])

    return ethers.utils.splitSignature(
        await owner._signTypedData(
        {
            name,
            version,
            chainId,
            verifyingContract: contract.address,
        },
        {
            Permit: [
            {
                name: "owner",
                type: "address",
            },
            {
                name: "spender",
                type: "address",
            },
            {
                name: "value",
                type: "uint256",
            },
            {
                name: "nonce",
                type: "uint256",
            },
            {
                name: "deadline",
                type: "uint256",
            },
            ],
        },
        {
            owner: owner.address,
            spender,
            value,
            nonce,
            deadline,
        }
        )
    )
}

describe("ERC20Permit", function () {
    it("ERC20 permit", async function () {
        // アドレスを用意
        // owner: ERC20トークンの所有者。
        // contractOwner: Bankコントラクトをデプロイするアドレス。
        // Admin: ERC20トークンを受け取り、ガス代を支払うアドレス。
        [owner, contractOwner, admin] = await ethers.getSigners();

        // Bankコントラクトをデプロイ。
        const Bank = await ethers.getContractFactory("Bank", contractOwner)
        const bank = await Bank.deploy("Cardene Token", "CARD")
        await bank.deployed()

        // 1000のERC20トークンを発行。
        const amount = 1000
        await bank.connect(contractOwner).mint(owner.address, amount)

        // ERC20Permitの処理が有効な期間を指定。
        // 今回は指定できる最大値を指定。
        const deadline = ethers.constants.MaxUint256

        // ownerアドレスによる署名を作成。
        const { v, r, s } = await getPermitSignature(
            owner,
            bank,
            admin.address,
            amount,
            deadline
        )

        // ERC20Permitを実行して、ownerアドレスからadminアドレスにERC20トークンを送る。
        await bank.connect(admin).depositWithPermit(owner.address, admin.address, amount, deadline, v, r, s)

        // adminアドレスにERC20トークンが送れているか確認。
        expect(await bank.connect(admin).balanceOf(admin.address)).to.equal(amount)
    })
})

$ npx hardhat compile
$ npx hardhat test

ERC20Permit
	✔ ERC20 permit (1507ms)


1 passing (2s)