ERC721Aについて非エンジニアでもわかるように概要から実装まで1から丁寧にわかりやすく解説

struct TokenApprovalRef {
    address value;
}

uint256 private _currentIndex;

uint256 private _burnCounter;

string private _name;
string private _symbol;

mapping(uint256 => uint256) private _packedOwnerships;

// - [0..159]   `addr`
// - [160..223] `startTimestamp`
// - [224]      `burned`
// - [225]      `nextInitialized`
// - [232..255] `extraData`

mapping(address => uint256) private _packedAddressData;

// - [0..63]    `balance`
// - [64..127]  `numberMinted`
// - [128..191] `numberBurned`
// - [192..255] `aux`

mapping(uint256 => TokenApprovalRef) private _tokenApprovals;

mapping(address => mapping(address => bool)) private _operatorApprovals;

constructor(string memory name_, string memory symbol_) {
    _name = name_;
    _symbol = symbol_;
    _currentIndex = _startTokenId();
}

function _startTokenId() internal view virtual returns (uint256) {
    return 0;
}

function _nextTokenId() internal view virtual returns (uint256) {
    return _currentIndex;
}

function totalSupply() public view virtual override returns (uint256) {
    unchecked {
        return _currentIndex - _burnCounter - _startTokenId();
    }
}

function _totalMinted() internal view virtual returns (uint256) {
    unchecked {
        return _currentIndex - _startTokenId();
    }
}

function _totalBurned() internal view virtual returns (uint256) {
    return _burnCounter;
}

function balanceOf(address owner) public view virtual override returns (uint256) {
    if (owner == address(0)) _revert(BalanceQueryForZeroAddress.selector);
    return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
}

function _numberMinted(address owner) internal view returns (uint256) {
    return (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
}

function _numberBurned(address owner) internal view returns (uint256) {
    return (_packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
}

function _getAux(address owner) internal view returns (uint64) {
    return uint64(_packedAddressData[owner] >> _BITPOS_AUX);
}

unction _setAux(address owner, uint64 aux) internal virtual {
    uint256 packed = _packedAddressData[owner];
    uint256 auxCasted;
    // Cast `aux` with assembly to avoid redundant masking.
    assembly {
        auxCasted := aux
    }
    packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
    _packedAddressData[owner] = packed;
}

function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
    return
        interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
        interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
        interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
}

function name() public view virtual override returns (string memory) {
    return _name;
}

function symbol() public view virtual override returns (string memory) {
    return _symbol;
}

function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
    if (!_exists(tokenId)) _revert(URIQueryForNonexistentToken.selector);

    string memory baseURI = _baseURI();
    return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : '';
}

function _baseURI() internal view virtual returns (string memory) {
    return '';
}

function ownerOf(uint256 tokenId) public view virtual override returns (address) {
    return address(uint160(_packedOwnershipOf(tokenId)));
}

function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
    return _unpackedOwnership(_packedOwnershipOf(tokenId));
}

function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
    return _unpackedOwnership(_packedOwnerships[index]);
}

function _initializeOwnershipAt(uint256 index) internal virtual {
    if (_packedOwnerships[index] == 0) {
        _packedOwnerships[index] = _packedOwnershipOf(index);
    }
}

function _packedOwnershipOf(uint256 tokenId) private view returns (uint256 packed) {
    if (_startTokenId() <= tokenId) {
        packed = _packedOwnerships[tokenId];
        // If not burned.
        if (packed & _BITMASK_BURNED == 0) {
            if (packed == 0) {
                if (tokenId >= _currentIndex) _revert(OwnerQueryForNonexistentToken.selector);
                for (;;) {
                    unchecked {
                        packed = _packedOwnerships[--tokenId];
                    }
                    if (packed == 0) continue;
                    return packed;
                }
            }
            return packed;
        }
    }
    _revert(OwnerQueryForNonexistentToken.selector);
}

function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
    ownership.addr = address(uint160(packed));
    ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
    ownership.burned = packed & _BITMASK_BURNED != 0;
    ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
}

function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
    assembly {
        owner := and(owner, _BITMASK_ADDRESS)
        result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
    }
}

function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
    assembly {
        result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
    }
}

function approve(address to, uint256 tokenId) public payable virtual override {
    _approve(to, tokenId, true);
}

function getApproved(uint256 tokenId) public view virtual override returns (address) {
    if (!_exists(tokenId)) _revert(ApprovalQueryForNonexistentToken.selector);

    return _tokenApprovals[tokenId].value;
}

function setApprovalForAll(address operator, bool approved) public virtual override {
    _operatorApprovals[_msgSenderERC721A()][operator] = approved;
    emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
}

function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
    return _operatorApprovals[owner][operator];
}

function _exists(uint256 tokenId) internal view virtual returns (bool) {
    return
    _startTokenId() <= tokenId &&
    tokenId < _currentIndex && // If within bounds,
    _packedOwnerships[tokenId] & _BITMASK_BURNED == 0; // and not burned.
}

function _isSenderApprovedOrOwner(
    address approvedAddress,
    address owner,
    address msgSender
) private pure returns (bool result) {
    assembly {
        owner := and(owner, _BITMASK_ADDRESS)
        msgSender := and(msgSender, _BITMASK_ADDRESS)
        result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
    }
}

function _getApprovedSlotAndAddress(uint256 tokenId)
    private
    view
    returns (uint256 approvedAddressSlot, address approvedAddress)
{
    TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];
    assembly {
        approvedAddressSlot := tokenApproval.slot
        approvedAddress := sload(approvedAddressSlot)
    }
}

approvedAddressSlot := tokenApproval.slot
approvedAddress := sload(approvedAddressSlot)

function transferFrom(
    address from,
    address to,
    uint256 tokenId
) public payable virtual override {
    uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

    from = address(uint160(uint256(uint160(from)) & _BITMASK_ADDRESS));

    if (address(uint160(prevOwnershipPacked)) != from) _revert(TransferFromIncorrectOwner.selector);

    (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

    if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
        if (!isApprovedForAll(from, _msgSenderERC721A())) _revert(TransferCallerNotOwnerNorApproved.selector);

    _beforeTokenTransfers(from, to, tokenId, 1);

    assembly {
        if approvedAddress {
            sstore(approvedAddressSlot, 0)
        }
    }
    unchecked {
        --_packedAddressData[from]; // Updates: `balance -= 1`.
        ++_packedAddressData[to]; // Updates: `balance += 1`.

        _packedOwnerships[tokenId] = _packOwnershipData(
            to,
            _BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
        );
        if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
            uint256 nextTokenId = tokenId + 1;
            if (_packedOwnerships[nextTokenId] == 0) {
                if (nextTokenId != _currentIndex) {
                    _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                }
            }
        }
    }
    uint256 toMasked = uint256(uint160(to)) & _BITMASK_ADDRESS;
    assembly {
        log4(
            0, // Start of data (0, since no data).
            0, // End of data (0, since no data).
            _TRANSFER_EVENT_SIGNATURE, // Signature.
            from, // `from`.
            toMasked, // `to`.
            tokenId // `tokenId`.
        )
    }
    if (toMasked == 0) _revert(TransferToZeroAddress.selector);

    _afterTokenTransfers(from, to, tokenId, 1);
}

function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId
) public payable virtual override {
    safeTransferFrom(from, to, tokenId, '');
}

function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId,
    bytes memory _data
) public payable virtual override {
    transferFrom(from, to, tokenId);
    if (to.code.length != 0)
        if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
            _revert(TransferToNonERC721ReceiverImplementer.selector);
        }
}

function _beforeTokenTransfers(
    address from,
    address to,
    uint256 startTokenId,
    uint256 quantity
) internal virtual {}

function _afterTokenTransfers(
    address from,
    address to,
    uint256 startTokenId,
    uint256 quantity
) internal virtual {}

function _checkContractOnERC721Received(
    address from,
    address to,
    uint256 tokenId,
    bytes memory _data
) private returns (bool) {
    try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
        bytes4 retval
    ) {
        return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
    } catch (bytes memory reason) {
        if (reason.length == 0) {
            _revert(TransferToNonERC721ReceiverImplementer.selector);
        }
        assembly {
            revert(add(32, reason), mload(reason))
        }
    }
}

function _mint(address to, uint256 quantity) internal virtual {
    uint256 startTokenId = _currentIndex;
    if (quantity == 0) _revert(MintZeroQuantity.selector);

    _beforeTokenTransfers(address(0), to, startTokenId, quantity);

    unchecked {
        _packedOwnerships[startTokenId] = _packOwnershipData(
            to,
            _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
        );

        _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

        uint256 toMasked = uint256(uint160(to)) & _BITMASK_ADDRESS;

        if (toMasked == 0) _revert(MintToZeroAddress.selector);

        uint256 end = startTokenId + quantity;
        uint256 tokenId = startTokenId;

        do {
            assembly {
                log4(
                    0, // Start of data (0, since no data).
                    0, // End of data (0, since no data).
                    _TRANSFER_EVENT_SIGNATURE, // Signature.
                    0, // `address(0)`.
                    toMasked, // `to`.
                    tokenId // `tokenId`.
                )
            }
        } while (++tokenId != end);

        _currentIndex = end;
    }
    _afterTokenTransfers(address(0), to, startTokenId, quantity);
}

function _mintERC2309(address to, uint256 quantity) internal virtual {
    uint256 startTokenId = _currentIndex;
    if (to == address(0)) _revert(MintToZeroAddress.selector);
    if (quantity == 0) _revert(MintZeroQuantity.selector);
    if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) _revert(MintERC2309QuantityExceedsLimit.selector);

    _beforeTokenTransfers(address(0), to, startTokenId, quantity);

    unchecked {
        _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

        _packedOwnerships[startTokenId] = _packOwnershipData(
            to,
            _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
        );

        emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);

        _currentIndex = startTokenId + quantity;
    }
    _afterTokenTransfers(address(0), to, startTokenId, quantity);
}

function _safeMint(
    address to,
    uint256 quantity,
    bytes memory _data
) internal virtual {
    _mint(to, quantity);

    unchecked {
        if (to.code.length != 0) {
            uint256 end = _currentIndex;
            uint256 index = end - quantity;
            do {
                if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                    _revert(TransferToNonERC721ReceiverImplementer.selector);
                }
            } while (index < end);
            if (_currentIndex != end) _revert(bytes4(0));
        }
    }
}

function _safeMint(address to, uint256 quantity) internal virtual {
    _safeMint(to, quantity, '');
}

function _approve(address to, uint256 tokenId) internal virtual {
    _approve(to, tokenId, false);
}

function _approve(
    address to,
    uint256 tokenId,
    bool approvalCheck
) internal virtual {
    address owner = ownerOf(tokenId);

    if (approvalCheck && _msgSenderERC721A() != owner)
        if (!isApprovedForAll(owner, _msgSenderERC721A())) {
            _revert(ApprovalCallerNotOwnerNorApproved.selector);
        }

    _tokenApprovals[tokenId].value = to;
    emit Approval(owner, to, tokenId);
}

function _burn(uint256 tokenId) internal virtual {
    _burn(tokenId, false);
}

function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
    uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

    address from = address(uint160(prevOwnershipPacked));

    (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

    if (approvalCheck) {
        if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
            if (!isApprovedForAll(from, _msgSenderERC721A())) _revert(TransferCallerNotOwnerNorApproved.selector);
    }

    _beforeTokenTransfers(from, address(0), tokenId, 1);

    assembly {
        if approvedAddress {
            sstore(approvedAddressSlot, 0)
        }
    }
er overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
    unchecked {
        _packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;

        _packedOwnerships[tokenId] = _packOwnershipData(
            from,
            (_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
        );

        if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
            uint256 nextTokenId = tokenId + 1;
            if (_packedOwnerships[nextTokenId] == 0) {
                if (nextTokenId != _currentIndex) {
                    _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                }
            }
        }
    }

    emit Transfer(from, address(0), tokenId);
    _afterTokenTransfers(from, address(0), tokenId, 1);

    unchecked {
        _burnCounter++;
    }
}

function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
    uint256 packed = _packedOwnerships[index];
    if (packed == 0) _revert(OwnershipNotInitializedForExtraData.selector);
    uint256 extraDataCasted;
    assembly {
        extraDataCasted := extraData
    }
    packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
    _packedOwnerships[index] = packed;
}

function _extraData(
    address from,
    address to,
    uint24 previousExtraData
) internal view virtual returns (uint24) {}

function _nextExtraData(
    address from,
    address to,
    uint256 prevOwnershipPacked
) private view returns (uint256) {
    uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
    return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;
}

function _msgSenderERC721A() internal view virtual returns (address) {
    return msg.sender;
}

function _toString(uint256 value) internal pure virtual returns (string memory str) {
    assembly {
        let m := add(mload(0x40), 0xa0)
        mstore(0x40, m)
        str := sub(m, 0x20)
        mstore(str, 0)

        let end := str

        for { let temp := value } 1 {} {
            str := sub(str, 1)
            mstore8(str, add(48, mod(temp, 10)))
            temp := div(temp, 10)
            if iszero(temp) { break }
        }

        let length := sub(end, str)
        str := sub(str, 0x20)
        mstore(str, length)
    }
}

function _revert(bytes4 errorSelector) internal pure {
    assembly {
        mstore(0x00, errorSelector)
        revert(0x00, 0x04)
    }
}

$ npm i @openzeppelin/contracts

$ npm install --save-dev erc721a

$ touch contracts/ERC721AContract.sol

pragma solidity ^0.8.4;

import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";

contract ERC721ANFT is ERC721A, ERC721AQueryable {
    constructor() ERC721A("Azuki", "AZUKI") {}

    function mint(uint256 quantity) external payable {
        // `_mint`'s second argument now takes in a `quantity`, not a `tokenId`.
        _mint(msg.sender, quantity);
    }
}

import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";

constructor() ERC721A("Azuki", "AZUKI") {}

function mint(uint256 quantity) external payable {
    // `_mint`'s second argument now takes in a `quantity`, not a `tokenId`.
    _mint(msg.sender, quantity);
}

$ mkdir test/test-ERC721.js

const { expect } = require("chai");

describe("ERC721A", function () {
  beforeEach(async function () {
    [owner, wallet1, wallet2] = await ethers.getSigners();

    // ERC721Aコントラクトを取得。
    ERC721A = await ethers.getContractFactory("ERC721ANFT", owner);

    // ERC721Aコントラクトをデプロイ。
    erc721A = await ERC721A.deploy();

    // トークンをmintする。
    await erc721A.connect(wallet1).mint(10);
    await erc721A.connect(wallet2).mint(20);
    await erc721A.connect(wallet1).mint(5);
    expect(await erc721A.totalSupply()).to.equal(35);
  });

  describe("Check ERC721A Token", function () {
    // トークンの総供給量を確認
    it("Total Supply", async function () {
      expect(await erc721A.totalSupply()).to.equal(35);
    });
    // Wallet1が所有しているトークンの総量を確認
    it("Wallet1 BalanceOf", async function () {
      expect(await erc721A.balanceOf(wallet1.address)).to.equal(15);
    });
    // Wallet2が所有しているトークンの総量を確認
    it("Wallet2 BalanceOf", async function () {
      expect(await erc721A.balanceOf(wallet2.address)).to.equal(20);
    });
    // トークン1の所有者を確認
    it("Token1 ownerOf", async function () {
      expect(await erc721A.ownerOf(1)).to.equal(wallet1.address);
    });
    // トークン15の所有者を確認
    it("Token1 ownerOf", async function () {
      expect(await erc721A.ownerOf(15)).to.equal(wallet2.address);
    });
      ;
  });
  describe("Check ERC721A Token List", function () {
    // wallet1が所有しているトークンの量を確認
      it("wallet1 tokensOfOwner", async function () {
          const wallet1Token = await erc721A.tokensOfOwner(wallet1.address);
        expect(wallet1Token.length).to.equal(15);
    });
    // wallet2が所有しているトークンの量を確認
      it("wallet1 tokensOfOwner", async function () {
          const wallet2Token = await erc721A.tokensOfOwner(wallet2.address);
        expect(wallet2Token.length).to.equal(20);
    });
      ;
  });
});

$ rm test/Lock.js

$ npx hardhat test

  ERC721A
    Check ERC721A Token
      ✔ Total Supply
      ✔ Wallet1 BalanceOf
      ✔ Wallet2 BalanceOf
      ✔ Token1 ownerOf
      ✔ Token1 ownerOf
    Check ERC721A Token List
      ✔ wallet1 tokensOfOwner (41ms)
      ✔ wallet1 tokensOfOwner (39ms)


  7 passing (2s)