Decode ERC404

/// @notice Function for fractional transfers
function transfer(
    address to,
    uint256 amount
) public virtual returns (bool) {
    return _transfer(msg.sender, to, amount);
}

/// @notice Internal function for fractional transfers
function _transfer(
    address from,
    address to,
    uint256 amount
) internal returns (bool) {
    uint256 unit = _getUnit();
    uint256 balanceBeforeSender = balanceOf[from];
    uint256 balanceBeforeReceiver = balanceOf[to];

    balanceOf[from] -= amount;

    unchecked {
        balanceOf[to] += amount;
    }

    // Skip burn for certain addresses to save gas
    if (!whitelist[from]) {
        uint256 tokens_to_burn = (balanceBeforeSender / unit) -
            (balanceOf[from] / unit);
        for (uint256 i = 0; i < tokens_to_burn; i++) {
            _burn(from);
        }
    }

    // Skip minting for certain addresses to save gas
    if (!whitelist[to]) {
        uint256 tokens_to_mint = (balanceOf[to] / unit) -
            (balanceBeforeReceiver / unit);
        for (uint256 i = 0; i < tokens_to_mint; i++) {
            _mint(to);
        }
    }

    emit ERC20Transfer(from, to, amount);
    return true;
}

/// @dev Decimals for fractional representation
uint8 public immutable decimals;

// Internal utility logic
function _getUnit() internal view returns (uint256) {
    return 10 ** decimals;
}

• _ownerOf : NFT的所有者

• _owned : 账户的所有NFT的Id

• _ownedIndex: NFT在账户拥有的NFT的数组里的index

/// @dev Owner of id in native representation
mapping(uint256 => address) internal _ownerOf;

/// @dev Array of owned ids in native representation
mapping(address => uint256[]) internal _owned;

/// @dev Tracks indices for the _owned mapping
mapping(uint256 => uint256) internal _ownedIndex;

function _mint(address to) internal virtual {
    if (to == address(0)) {
        revert InvalidRecipient();
    }

    unchecked {
        minted++;
    }

    uint256 id = minted;

    if (_ownerOf[id] != address(0)) {
        revert AlreadyExists();
    }

    _ownerOf[id] = to;
    _owned[to].push(id);
    _ownedIndex[id] = _owned[to].length - 1;

    emit Transfer(address(0), to, id);
}

function _burn(address from) internal virtual {
    if (from == address(0)) {
        revert InvalidSender();
    }

    uint256 id = _owned[from][_owned[from].length - 1];
    _owned[from].pop();
    delete _ownedIndex[id];
    delete _ownerOf[id];
    delete getApproved[id];

    emit Transfer(from, address(0), id);
}

In it's current implementation, ERC404 effectively isolates ERC20 / ERC721 standard logic or introduces pathing where possible. Pathing could best be described as a lossy encoding scheme in which token amount data and ids occupy shared space under the assumption that negligible token transfers occupying id space do not or do not need to occur.

/// @notice Function for mixed transfers
/// @dev This function assumes id / native if amount less than or equal to current max id
function transferFrom(
    address from,
    address to,
    uint256 amountOrId
) public virtual {
    if (amountOrId <= minted) {
        if (from != _ownerOf[amountOrId]) {
            revert InvalidSender();
        }

        if (to == address(0)) {
            revert InvalidRecipient();
        }

        if (
            msg.sender != from &&
            !isApprovedForAll[from][msg.sender] &&
            msg.sender != getApproved[amountOrId]
        ) {
            revert Unauthorized();
        }

        balanceOf[from] -= _getUnit();

        unchecked {
            balanceOf[to] += _getUnit();
        }

        _ownerOf[amountOrId] = to;
        delete getApproved[amountOrId];

        // update _owned for sender
        uint256 updatedId = _owned[from][_owned[from].length - 1];
        _owned[from][_ownedIndex[amountOrId]] = updatedId;
        // pop
        _owned[from].pop();
        // update index for the moved id
        _ownedIndex[updatedId] = _ownedIndex[amountOrId];
        // push token to to owned
        _owned[to].push(amountOrId);
        // update index for to owned
        _ownedIndex[amountOrId] = _owned[to].length - 1;

        emit Transfer(from, to, amountOrId);
        emit ERC20Transfer(from, to, _getUnit());
    } else {
        uint256 allowed = allowance[from][msg.sender];

        if (allowed != type(uint256).max)
            allowance[from][msg.sender] = allowed - amountOrId;

        _transfer(from, to, amountOrId);
    }
}

• approve

• setApprovalForAll

• safeTransferFrom

• tokenURI