[ERC7628] ERC721のNFTの所有権を分割する仕組みを理解しよう！

pragma solidity ^0.8.0;

interface IERC7628 /* is IERC721 */ {
    /// @notice Returns the number of decimal places used for ownership shares.
    /// @return The number of decimal places for ownership shares.
    function shareDecimals() external view returns (uint8);

    /// @notice Returns the total sum of ownership shares in existence for all tokens.
    /// @return The total sum of ownership shares.
    function totalShares() external view returns (uint256);

    /// @notice Returns the ownership share of the specified token.
    /// @param tokenId The identifier of the token.
    /// @return The ownership share of the token.
    function shareOf(uint256 tokenId) external view returns (uint256);

    /// @notice Returns the share allowance granted to the specified spender by the owner for the specified token.
    /// @param tokenId The identifier of the token.
    /// @param spender The address of the spender.
    /// @return The share allowance granted to the spender.
    function shareAllowance(uint256 tokenId, address spender) external view returns (uint256);

    /// @notice Approves the specified address to spend a specified amount of shares on behalf of the caller.
    /// @param tokenId The identifier of the token.
    /// @param spender The address of the spender.
    /// @param shares The amount of shares to approve.
    function approveShare(uint256 tokenId, address spender, uint256 shares) external;

    /// @notice Transfers ownership shares from one token to another.
    /// @param fromTokenId The identifier of the sender token.
    /// @param toTokenId The identifier of the recipient token.
    /// @param shares The amount of shares to transfer.
    function transferShares(uint256 fromTokenId, uint256 toTokenId, uint256 shares) external;

    /// @notice Transfers ownership shares from one token to another address (resulting in a new token or increased shares at the recipient address).
    /// @param fromTokenId The identifier of the sender token.
    /// @param to The address of the recipient.
    /// @param shares The amount of shares to transfer.
    function transferSharesToAddress(uint256 fromTokenId, address to, uint256 shares) external; 

    /// @notice Adds a specified amount of shares to a token, only callable by the contract owner.
    /// @param tokenId The identifier of the token.
    /// @param shares The amount of shares to add.
    function addSharesToToken(uint256 tokenId, uint256 shares) external;

    /// @notice Emitted when ownership shares are transferred from one token to another.
    /// @param fromTokenId The identifier of the sender token.
    /// @param toTokenId The identifier of the recipient token.
    /// @param amount The amount of shares transferred.
    event SharesTransfered(uint256 indexed fromTokenId, uint256 indexed toTokenId, uint256 amount);

    /// @notice Emitted when an approval is granted for a spender to spend shares on behalf of an owner.
    /// @param tokenId The token identifier.
    /// @param spender The address of the spender.
    /// @param amount The amount of shares approved.
    event SharesApproved(uint256 indexed tokenId, address indexed spender, uint256 amount);
}

function shareDecimals() external view returns (uint8);

function totalShares() external view returns (uint256);

function shareOf(uint256 tokenId) external view returns (uint256);

function shareAllowance(uint256 tokenId, address spender) external view returns (uint256);

function approveShare(uint256 tokenId, address spender, uint256 shares) external;

function transferShares(uint256 fromTokenId, uint256 toTokenId, uint256 shares) external;

function transferSharesToAddress(uint256 fromTokenId, address to, uint256 shares) external;

function addSharesToToken(uint256 tokenId, uint256 shares) external;

event SharesTransfered(uint256 indexed fromTokenId, uint256 indexed toTokenId, uint256 amount);

event SharesApproved(uint256 indexed tokenId, address indexed spender, uint256 amount);

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract ERC7628 is IERC7628, ERC721, Ownable, ReentrancyGuard {
    mapping(uint256 => uint256) private _shareBalances;
    mapping(uint256 => mapping(address => uint256)) private _shareAllowances;
    uint256 private _totalShares;
    uint256 private _nextTokenId;

    constructor(address initialOwner)
        ERC721("MyToken", "MTK")
        Ownable(initialOwner)
    {}

    function addSharesToToken(uint256 tokenId, uint256 shares) public override onlyOwner {
        require(tokenId > 0, "ERC7628: tokenId cannot be zero");
        _shareBalances[tokenId] += shares;
        _totalShares += shares;
        emit SharesTransfered(0, tokenId, shares);
    }

    function shareDecimals() external pure override returns (uint8) {
        return 18;
    }

    function totalShares() external view override returns (uint256) {
        return _totalShares;
    }

    function shareOf(uint256 tokenId) external view override returns (uint256) {
        return _shareBalances[tokenId];
    }

    function shareAllowance(uint256 tokenId, address spender) external view override returns (uint256) {
        return _shareAllowances[tokenId][spender];
    }

    function approveShare(uint256 tokenId, address spender, uint256 shares) external override {
        require(spender != ownerOf(tokenId), "ERC7628: approval to current owner");
        require(msg.sender == ownerOf(tokenId), "ERC7628: approve caller is not owner");

        _shareAllowances[tokenId][spender] = shares;
        emit SharesApproved(tokenId, spender, shares);
    }

    function transferShares(uint256 fromTokenId, uint256 toTokenId, uint256 shares) external override nonReentrant {
        require(_shareBalances[fromTokenId] >= shares, "ERC7628: insufficient shares for transfer");
        require(_isApprovedOrOwner(msg.sender, fromTokenId), "ERC7628: transfer caller is not owner nor approved");

        _shareBalances[fromTokenId] -= shares;
        _shareBalances[toTokenId] += shares;
        emit SharesTransfered(fromTokenId, toTokenId, shares);
    }

    function transferSharesToAddress(uint256 fromTokenId, address to, uint256 shares) external override nonReentrant {
        require(_shareBalances[fromTokenId] >= shares, "ERC7628: insufficient shares for transfer");
        require(_isApprovedOrOwner(msg.sender, fromTokenId), "ERC7628: transfer caller is not owner nor approved");

        _nextTokenId++;
        _safeMint(to, _nextTokenId);
        _shareBalances[_nextTokenId] = shares;
        emit SharesTransfered(fromTokenId, _nextTokenId, shares);
    }

    // Helper function to check if an address is the owner or approved
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
        return (spender == ownerOf(tokenId) || getApproved(tokenId) == spender || isApprovedForAll(ownerOf(tokenId), spender));
    }
}