ERC-5791: 物理支持代币

interface IERC5791 {
    /// @dev 返回给定芯片地址的 ERC-721 `tokenId`。
    ///      如果 `chipId` 尚未与 `tokenId` 配对，则会恢复。
    ///      为了最小化，如果 `tokenId` 不存在，这将不会恢复。
    ///      如果需要检查代币是否存在，外部合约可以
    ///      调用 `ERC721.ownerOf(uint256 tokenId)` 并检查它是否通过或恢复。
    /// @param chipId 嵌入在物理物品中的芯片的地址
    ///               （从芯片的公钥计算得出）。
    function tokenIdFor(address chipId) external view returns (uint256 tokenId);

    /// @dev 如果 `signature` 是由分配给 `tokenId` 的芯片签名的，则返回 true，否则返回 false。
    ///      如果 `tokenId` 尚未与芯片配对，则会恢复。
    ///      为了最小化，如果 `tokenId` 不存在，这将不会恢复。
    ///      如果需要检查代币是否存在，外部合约可以
    ///      调用 `ERC721.ownerOf(uint256 tokenId)` 并检查它是否通过或恢复。
    /// @param tokenId ERC-721 `tokenId`。
    /// @param data      由芯片签名的任意字节字符串以生成 `signature`。
    /// @param signature 芯片的 EIP-191 签名，用于检查。
    function isChipSignatureForToken(uint256 tokenId, bytes calldata data, bytes calldata signature)
        external
        view
        returns (bool);

    /// @dev 将代币转移到该地址。
    ///      返回转移的 `tokenId`。
    /// @param to                  接收者。 动态允许更容易地转移到金库。
    /// @param chipId              正在转移的芯片的芯片 ID（地址）。
    /// @param chipSignature       芯片的 EIP-191 签名，用于授权转移。
    /// @param signatureTimestamp  `chipSignature` 中使用的时间戳。
    /// @param useSafeTransferFrom 是否应使用 ERC-721 的 `safeTransferFrom`，
    ///                            而不是 `transferFrom`。
    /// @param extras              其他数据，可用于其他逻辑/上下文
    ///                            当 PBT 被转移时。
    function transferToken(
        address to,
        address chipId,
        bytes calldata chipSignature,
        uint256 signatureTimestamp,
        bool useSafeTransferFrom,
        bytes calldata extras
    ) external returns (uint256 tokenId);

    /// @dev 当 `chipId` 与 `tokenId` 配对时发出。
    /// 在分配期间，`tokenId` 可能不一定存在。
    /// 索引器可以将此事件与 {ERC721.Transfer} 事件组合起来，以
    /// 推断哪些代币存在并且与芯片 ID 配对。
    event ChipSet(uint256 indexed tokenId, address indexed chipId);
}

import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';

/// @dev 将分配给 `chipId` 的 `tokenId` 转移到 `to`。
function transferToken(
    address to,
    address chipId,
    bytes memory chipSignature,
    uint256 signatureTimestamp,
    bool useSafeTransfer,
    bytes memory extras
) public virtual returns (uint256 tokenId) {
    tokenId = tokenIdFor(chipId);
    _validateSigAndUpdateNonce(to, chipId, chipSignature, signatureTimestamp, extras);
    if (useSafeTransfer) {
        _safeTransfer(ownerOf(tokenId), to, tokenId, "");
    } else {
        _transfer(ownerOf(tokenId), to, tokenId);
    }
}

/// @dev 验证 `chipSignature` 并更新 `chipId` 未来签名的随机数。
function _validateSigAndUpdateNonce(
    address to,
    address chipId,
    bytes memory chipSignature,
    uint256 signatureTimestamp,
    bytes memory extras
) internal virtual {
    bytes32 hash = _getSignatureHash(signatureTimestamp, chipId, to, extras);
    if (!SignatureCheckerLib.isValidSignatureNow(chipId, hash, chipSignature)) {
        revert InvalidSignature();
    }
    chipNonce[chipId] = bytes32(uint256(hash) ^ uint256(blockhash(block.number - 1)));
}

/// @dev 返回要由 `chipId` 签名的摘要。
function _getSignatureHash(uint256 signatureTimestamp, address chipId, address to, bytes memory extras)
    internal
    virtual
    returns (bytes32)
{
    if (signatureTimestamp > block.timestamp) revert SignatureTimestampInFuture();
    if (signatureTimestamp + maxDurationWindow < block.timestamp) revert SignatureTimestampTooOld();
    bytes32 hash = keccak256(
        abi.encode(address(this), block.chainid, chipNonce[chipId], to, signatureTimestamp, keccak256(extras))
    );
    return ECDSA.toEthSignedMessageHash(hash);
}