[ERC6454] NFTがTransfer可能か検証するインターフェースの提案を理解しよう！

pragma solidity ^0.8.16;

interface IERC6454 /* is IERC165 */ {
    function isTransferable(uint256 tokenId, address from, address to) external view returns (bool);
}

cd ../assets/eip-6454
npm install
npx hardhat test

import { ethers } from "hardhat";
import { expect } from "chai";
import { BigNumber } from "ethers";
import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";
import { ERC721TransferableMock } from "../typechain-types";

async function transferableTokenFixture(): Promise<ERC721TransferableMock> {
  const factory = await ethers.getContractFactory("ERC721TransferableMock");
  const token = await factory.deploy("Chunky", "CHNK");
  await token.deployed();

  return token;
}

describe("Transferable", async function () {
  let nonTransferable: ERC721TransferableMock;
  let owner: SignerWithAddress;
  let otherOwner: SignerWithAddress;
  const tokenId = 1;

  beforeEach(async function () {
    const signers = await ethers.getSigners();
    owner = signers[0];
    otherOwner = signers[1];
    nonTransferable = await loadFixture(transferableTokenFixture);

    await nonTransferable.mint(owner.address, 1);
    await nonTransferable.mint(otherOwner.address, 2);
  });

  it("can support IRMRKNonTransferable", async function () {
    expect(await nonTransferable.supportsInterface("0x91a6262f")).to.equal(true);
  });

  it("does not support other interfaces", async function () {
    expect(await nonTransferable.supportsInterface("0xffffffff")).to.equal(false);
  });

  it("cannot transfer", async function () {
    expect(
      nonTransferable
        .connect(owner)
        ["safeTransferFrom(address,address,uint256)"](
          owner.address,
          otherOwner.address,
          tokenId + 1
        )
    ).to.be.revertedWithCustomError(nonTransferable, "CannotTransferNonTransferable");
  });

  it("returns the expected transferability state", async function () {
    expect(await nonTransferable['isTransferable(uint256,address,address)'](tokenId, ethers.constants.AddressZero, ethers.constants.AddressZero)).to.equal(false);
    expect(await nonTransferable['isTransferable(uint256,address,address)'](tokenId, ethers.constants.AddressZero, otherOwner.address)).to.equal(true);
  })

  it("reverts if token does not exist", async function () {
    await expect(nonTransferable['isTransferable(uint256,address,address)'](10, owner.address, otherOwner.address)).to.be.revertedWith("ERC721: invalid token ID");
  });

  it("can burn", async function () {
    await nonTransferable.connect(owner).burn(tokenId);
    await expect(nonTransferable.ownerOf(tokenId)).to.be.revertedWith(
      "ERC721: invalid token ID"
    );
  });
});

// SPDX-License-Identifier: CC0-1.0

pragma solidity ^0.8.16;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "../IERC6454.sol";
import "hardhat/console.sol";

error CannotTransferNonTransferable();

/**
 * @title ERC721TransferableMock
 * Used for tests
 */
contract ERC721TransferableMock is IERC6454, ERC721 {
    address public owner;

    constructor(
        string memory name,
        string memory symbol
    ) ERC721(name, symbol) {
        owner = msg.sender;
    }

    function mint(address to, uint256 amount) public {
        _mint(to, amount);
    }

    function burn(uint256 tokenId) public {
        _burn(tokenId);
    }

    function isTransferable(uint256 tokenId, address from, address to) public view returns (bool) {
        if (from == address(0x0) && to == address(0x0)){
            return false;
        }
        // Only allow minting and burning
        if (from == address(0x0) || to == address(0x0)){
            return true;
        }
        _requireMinted(tokenId);
        return false;
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

        uint256 lastTokenId = firstTokenId + batchSize;
        for (uint256 i = firstTokenId; i < lastTokenId; ) {
            if (!isTransferable(i, from, to)) {
                revert CannotTransferNonTransferable();
            }
            unchecked {
                i++;
            }
        }
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(ERC721) returns (bool) {
        return interfaceId == type(IERC6454).interfaceId
            || super.supportsInterface(interfaceId);
    }
}