gotake-contracts/artifacts/build-info/91488a2fffb709f19c25df4fdc168728.json

TypeChain generated types and ABIs for GoTake contracts

{"id":"91488a2fffb709f19c25df4fdc168728","_format":"hh-sol-build-info-1","solcVersion":"0.8.28","solcLongVersion":"0.8.28+commit.7893614a","input":{"language":"Solidity","sources":{"@openzeppelin/contracts/interfaces/IERC1271.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (interfaces/IERC1271.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-1271 standard signature validation method for\n * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].\n */\ninterface IERC1271 {\n    /**\n     * @dev Should return whether the signature provided is valid for the provided data\n     * @param hash      Hash of the data to be signed\n     * @param signature Signature byte array associated with `hash`\n     */\n    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC-721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC-721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or\n     *   {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n     *   a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the address zero.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @title ERC-721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC-721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS\n    }\n\n    /**\n     * @dev The signature derives the `address(0)`.\n     */\n    error ECDSAInvalidSignature();\n\n    /**\n     * @dev The signature has an invalid length.\n     */\n    error ECDSAInvalidSignatureLength(uint256 length);\n\n    /**\n     * @dev The signature has an S value that is in the upper half order.\n     */\n    error ECDSAInvalidSignatureS(bytes32 s);\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n     * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n     * and a bytes32 providing additional information about the error.\n     *\n     * If no error is returned, then the address can be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes memory signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly (\"memory-safe\") {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        unchecked {\n            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n            // We do not check for an overflow here since the shift operation results in 0 or 1.\n            uint8 v = uint8((uint256(vs) >> 255) + 27);\n            return tryRecover(hash, v, r, s);\n        }\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     */\n    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS, s);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature, bytes32(0));\n        }\n\n        return (signer, RecoverError.NoError, bytes32(0));\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n     */\n    function _throwError(RecoverError error, bytes32 errorArg) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert ECDSAInvalidSignature();\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert ECDSAInvalidSignatureLength(uint256(errorArg));\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert ECDSAInvalidSignatureS(errorArg);\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/SignatureChecker.sol)\n\npragma solidity ^0.8.20;\n\nimport {ECDSA} from \"./ECDSA.sol\";\nimport {IERC1271} from \"../../interfaces/IERC1271.sol\";\n\n/**\n * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA\n * signatures from externally owned accounts (EOAs) as well as ERC-1271 signatures from smart contract wallets like\n * Argent and Safe Wallet (previously Gnosis Safe).\n */\nlibrary SignatureChecker {\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the\n     * signature is validated against that smart contract using ERC-1271, otherwise it's validated using `ECDSA.recover`.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {\n        if (signer.code.length == 0) {\n            (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);\n            return err == ECDSA.RecoverError.NoError && recovered == signer;\n        } else {\n            return isValidERC1271SignatureNow(signer, hash, signature);\n        }\n    }\n\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated\n     * against the signer smart contract using ERC-1271.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidERC1271SignatureNow(\n        address signer,\n        bytes32 hash,\n        bytes memory signature\n    ) internal view returns (bool) {\n        (bool success, bytes memory result) = signer.staticcall(\n            abi.encodeCall(IERC1271.isValidSignature, (hash, signature))\n        );\n        return (success &&\n            result.length >= 32 &&\n            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"contracts/ERC6551Account.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport \"@openzeppelin/contracts/token/ERC721/IERC721.sol\";\nimport \"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\";\nimport \"@openzeppelin/contracts/interfaces/IERC1271.sol\";\nimport \"@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol\";\nimport \"./interfaces/IERC6551Account.sol\";\nimport \"./interfaces/IERC6551Executable.sol\";\n\n/**\n * @title A simple implementation of ERC6551Account\n * @author ERC6551 Team\n */\ncontract ERC6551Account is\n    IERC165,\n    IERC1271,\n    IERC6551Account,\n    IERC6551Executable,\n    IERC721Receiver\n{\n    /**\n     * @dev Account state nonce, incremented on each transaction\n     */\n    uint256 public state;\n\n    /**\n     * @dev Storage slot for token data\n     * This is written during initialization by the registry\n     * Structure: chainId (uint256), tokenContract (address), tokenId (uint256)\n     */\n    bytes32 private constant TOKEN_DATA_SLOT =\n        keccak256(\"erc6551.account.token\");\n\n    /**\n     * @dev Allows the account to receive ETH\n     */\n    receive() external payable {}\n\n    /**\n     * @dev Executes a transaction from the token owner\n     */\n    function execute(\n        address to,\n        uint256 value,\n        bytes calldata data,\n        uint8 operation\n    ) external payable returns (bytes memory result) {\n        require(_isValidSigner(msg.sender), \"Invalid signer\");\n\n        ++state;\n\n        if (operation == 0) {\n            // Call\n            (bool success, bytes memory ret) = to.call{value: value}(data);\n            require(success, \"Call failed\");\n            return ret;\n        } else if (operation == 1) {\n            // Delegatecall\n            (bool success, bytes memory ret) = to.delegatecall(data);\n            require(success, \"Delegatecall failed\");\n            return ret;\n        } else {\n            revert(\"Unsupported operation\");\n        }\n    }\n\n    /**\n     * @dev Returns the token bound to this account\n     */\n    function token()\n        external\n        view\n        returns (uint256 chainId, address tokenContract, uint256 tokenId)\n    {\n        // Read the token data from storage\n        bytes32 slot = TOKEN_DATA_SLOT;\n        assembly {\n            chainId := sload(slot)\n            tokenContract := sload(add(slot, 1))\n            tokenId := sload(add(slot, 2))\n        }\n    }\n\n    /**\n     * @dev Initialization function that stores token data\n     * This is called by the registry during account creation\n     */\n    function initialize(\n        uint256 chainId,\n        address tokenContract,\n        uint256 tokenId\n    ) external {\n        // Ensure this can only be called once during creation\n        bytes32 slot = TOKEN_DATA_SLOT;\n        uint256 storedChainId;\n        assembly {\n            storedChainId := sload(slot)\n        }\n        require(storedChainId == 0, \"Already initialized\");\n\n        // Store token data in storage\n        assembly {\n            sstore(slot, chainId)\n            sstore(add(slot, 1), tokenContract)\n            sstore(add(slot, 2), tokenId)\n        }\n    }\n\n    /**\n     * @dev Validates if a signer is authorized to perform actions\n     */\n    function isValidSigner(\n        address signer,\n        bytes calldata\n    ) external view returns (bytes4) {\n        if (_isValidSigner(signer)) {\n            return IERC6551Account.isValidSigner.selector;\n        }\n\n        return bytes4(0);\n    }\n\n    /**\n     * @dev Validates signatures according to ERC-1271\n     */\n    function isValidSignature(\n        bytes32 hash,\n        bytes memory signature\n    ) external view returns (bytes4 magicValue) {\n        (uint256 chainId, address tokenContract, uint256 tokenId) = this\n            .token();\n\n        if (chainId != block.chainid) return bytes4(0);\n\n        address owner = IERC721(tokenContract).ownerOf(tokenId);\n\n        if (SignatureChecker.isValidSignatureNow(owner, hash, signature)) {\n            return IERC1271.isValidSignature.selector;\n        }\n\n        return bytes4(0);\n    }\n\n    /**\n     * @dev Implements IERC721Receiver interface to allow the account to receive ERC721 tokens\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external override returns (bytes4) {\n        return IERC721Receiver.onERC721Received.selector;\n    }\n\n    /**\n     * @dev Implements interface detection\n     */\n    function supportsInterface(\n        bytes4 interfaceId\n    ) external pure returns (bool) {\n        return (interfaceId == type(IERC165).interfaceId ||\n            interfaceId == type(IERC6551Account).interfaceId ||\n            interfaceId == type(IERC6551Executable).interfaceId ||\n            interfaceId == type(IERC721Receiver).interfaceId);\n    }\n\n    /**\n     * @dev Internal helper to check if a signer is valid\n     */\n    function _isValidSigner(address signer) internal view returns (bool) {\n        (uint256 chainId, address tokenContract, uint256 tokenId) = this\n            .token();\n\n        if (chainId != block.chainid) return false;\n\n        return signer == IERC721(tokenContract).ownerOf(tokenId);\n    }\n}\n"},"contracts/interfaces/IERC6551Account.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @dev the ERC-165 identifier for this interface is `0x6faff5f1`\ninterface IERC6551Account {\n    /**\n     * @dev Allows the account to receive Ether.\n     *\n     * Accounts MUST implement a `receive` function.\n     *\n     * Accounts MAY perform arbitrary logic to restrict conditions\n     * under which Ether can be received.\n     */\n    receive() external payable;\n\n    /**\n     * @dev Returns the identifier of the non-fungible token which owns the account.\n     *\n     * The return value of this function MUST be constant - it MUST NOT change over time.\n     *\n     * @return chainId       The EIP-155 ID of the chain the token exists on\n     * @return tokenContract The contract address of the token\n     * @return tokenId       The ID of the token\n     */\n    function token()\n        external\n        view\n        returns (uint256 chainId, address tokenContract, uint256 tokenId);\n\n    /**\n     * @dev Returns a value that SHOULD be modified each time the account changes state.\n     *\n     * @return The current account state\n     */\n    function state() external view returns (uint256);\n\n    /**\n     * @dev Returns a magic value indicating whether a given signer is authorized to act on behalf\n     * of the account.\n     *\n     * MUST return the bytes4 magic value 0x523e3260 if the given signer is valid.\n     *\n     * By default, the holder of the non-fungible token the account is bound to MUST be considered\n     * a valid signer.\n     *\n     * Accounts MAY implement additional authorization logic which invalidates the holder as a\n     * signer or grants signing permissions to other non-holder accounts.\n     *\n     * @param  signer     The address to check signing authorization for\n     * @param  context    Additional data used to determine whether the signer is valid\n     * @return magicValue Magic value indicating whether the signer is valid\n     */\n    function isValidSigner(address signer, bytes calldata context)\n        external\n        view\n        returns (bytes4 magicValue);\n}\n"},"contracts/interfaces/IERC6551Executable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @dev the ERC-165 identifier for this interface is `0x51945447`\ninterface IERC6551Executable {\n    /**\n     * @dev Executes a low-level operation if the caller is a valid signer on the account.\n     *\n     * Reverts and bubbles up error if operation fails.\n     *\n     * Accounts implementing this interface MUST accept the following operation parameter values:\n     * - 0 = CALL\n     * - 1 = DELEGATECALL\n     * - 2 = CREATE\n     * - 3 = CREATE2\n     *\n     * Accounts implementing this interface MAY support additional operations or restrict a signer's\n     * ability to execute certain operations.\n     *\n     * @param to        The target address of the operation\n     * @param value     The Ether value to be sent to the target\n     * @param data      The encoded operation calldata\n     * @param operation A value indicating the type of operation to perform\n     * @return The result of the operation\n     */\n    function execute(address to, uint256 value, bytes calldata data, uint8 operation)\n        external\n        payable\n        returns (bytes memory);\n}\n"}},"settings":{"optimizer":{"enabled":true,"runs":200},"evmVersion":"paris","outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","devdoc","userdoc","storageLayout","evm.gasEstimates"],"":["ast"]}},"metadata":{"useLiteralContent":true}}},"output":{"errors":[{"component":"general","errorCode":"5667","formattedMessage":"Warning: Unused function parameter. Remove or comment out the variable name to silence this warning.\n   --> contracts/ERC6551Account.sol:150:9:\n    |\n150 |         address operator,\n    |         ^^^^^^^^^^^^^^^^\n\n","message":"Unused function parameter. Remove or comment out the variable name to silence this warning.","severity":"warning","sourceLocation":{"end":4255,"file":"contracts/ERC6551Account.sol","start":4239},"type":"Warning"},{"component":"general","errorCode":"5667","formattedMessage":"Warning: Unused function parameter. Remove or comment out the variable name to silence this warning.\n   --> contracts/ERC6551Account.sol:151:9:\n    |\n151 |         address from,\n    |         ^^^^^^^^^^^^\n\n","message":"Unused function parameter. Remove or comment out the variable name to silence this warning.","severity":"warning","sourceLocation":{"end":4277,"file":"contracts/ERC6551Account.sol","start":4265},"type":"Warning"},{"component":"general","errorCode":"5667","formattedMessage":"Warning: Unused function parameter. Remove or comment out the variable name to silence this warning.\n   --> contracts/ERC6551Account.sol:152:9:\n    |\n152 |         uint256 tokenId,\n    |         ^^^^^^^^^^^^^^^\n\n","message":"Unused function parameter. Remove or comment out the variable name to silence this warning.","severity":"warning","sourceLocation":{"end":4302,"file":"contracts/ERC6551Account.sol","start":4287},"type":"Warning"},{"component":"general","errorCode":"5667","formattedMessage":"Warning: Unused function parameter. Remove or comment out the variable name to silence this warning.\n   --> contracts/ERC6551Account.sol:153:9:\n    |\n153 |         bytes calldata data\n    |         ^^^^^^^^^^^^^^^^^^^\n\n","message":"Unused function parameter. Remove or comment out the variable name to silence this warning.","severity":"warning","sourceLocation":{"end":4331,"file":"contracts/ERC6551Account.sol","start":4312},"type":"Warning"},{"component":"general","errorCode":"2018","formattedMessage":"Warning: Function state mutability can be restricted to pure\n   --> contracts/ERC6551Account.sol:149:5:\n    |\n149 |     function onERC721Received(\n    |     ^ (Relevant source part starts here and spans across multiple lines).\n\n","message":"Function state mutability can be restricted to pure","severity":"warning","sourceLocation":{"end":4438,"file":"contracts/ERC6551Account.sol","start":4204},"type":"Warning"}],"sources":{"@openzeppelin/contracts/interfaces/IERC1271.sol":{"ast":{"absolutePath":"@openzeppelin/contracts/interfaces/IERC1271.sol","exportedSymbols":{"IERC1271":[13]},"id":14,"license":"MIT","nodeType":"SourceUnit","nodes":[{"id":1,"literals":["solidity","^","0.8",".20"],"nodeType":"PragmaDirective","src":"107:24:0"},{"abstract":false,"baseContracts":[],"canonicalName":"IERC1271","contractDependencies":[],"contractKind":"interface","documentation":{"id":2,"nodeType":"StructuredDocumentation","src":"133:160:0","text":" @dev Interface of the ERC-1271 standard signature validation method for\n contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271]."},"fullyImplemented":false,"id":13,"linearizedBaseContracts":[13],"name":"IERC1271","nameLocation":"304:8:0","nodeType":"ContractDefinition","nodes":[{"documentation":{"id":3,"nodeType":"StructuredDocumentation","src":"319:221:0","text":" @dev Should return whether the signature provided is valid for the provided data\n @param hash      Hash of the data to be signed\n @param signature Signature byte array associated with `hash`"},"functionSelector":"1626ba7e","id":12,"implemented":false,"kind":"function","modifiers":[],"name":"isValidSignature","nameLocation":"554:16:0","nodeType":"FunctionDefinition","parameters":{"id":8,"nodeType":"ParameterList","parameters":[{"constant":false,"id":5,"mutability":"mutable","name":"hash","nameLocation":"579:4:0","nodeType":"VariableDeclaration","scope":12,"src":"571:12:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":4,"name":"bytes32","nodeType":"ElementaryTypeName","src":"571:7:0","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"},{"constant":false,"id":7,"mutability":"mutable","name":"signature","nameLocation":"598:9:0","nodeType":"VariableDeclaration","scope":12,"src":"585:22:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_bytes_memory_ptr","typeString":"bytes"},"typeName":{"id":6,"name":"bytes","nodeType":"ElementaryTypeName","src":"585:5:0","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"src":"570:38:0"},"returnParameters":{"id":11,"nodeType":"ParameterList","parameters":[{"constant":false,"id":10,"mutability":"mutable","name":"magicValue","nameLocation":"639:10:0","nodeType":"VariableDeclaration","scope":12,"src":"632:17:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"},"typeName":{"id":9,"name":"bytes4","nodeType":"ElementaryTypeName","src":"632:6:0","typeDescriptions":{"typeIdentifier":"t_bytes4","typeString":"bytes4"}},"visibility":"internal"}],"src":"631:19:0"},"scope":13,"src":"545:106:0","stateMutability":"view","virtual":false,"visibility":"external"}],"scope":14,"src":"294:359:0","usedErrors":[],"usedEvents":[]}],"src":"107:547:0"},"id":0},"@openzeppelin/contracts/token/ERC721/IERC721.sol":{"ast":{"absolutePath":"@openzeppelin/contracts/token/ERC721/IERC721.sol","exportedSymbols":{"IERC165":[616],"IERC721":[130]},"id":131,"license":"MIT","nodeType":"SourceUnit","nodes":[{"id":15,"literals":["solidity","^","0.8",".20"],"nodeType":"PragmaDirective","src":"108:24:1"},{"absolutePath":"@openzeppelin/contracts/utils/introspection/IERC165.sol","file":"../../utils/introspection/IERC165.sol","id":17,"nameLocation":"-1:-1:-1","nodeType":"ImportDirective","scope":131,"sourceUnit":617,"src":"134:62:1","symbolAliases":[{"foreign":{"id":16,"name":"IERC165","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":616,"src":"142:7:1","typeDescriptions":{}},"nameLocation":"-1:-1:-1"}],"unitAlias":""},{"abstract":false,"baseContracts":[{"baseName":{"id":19,"name":"IERC165","nameLocations":["288:7:1"],"nodeType":"IdentifierPath","referencedDeclaration":616,"src":"288:7:1"},"id":20,"nodeType":"InheritanceSpecifier","src":"288:7:1"}],"canonicalName":"IERC721","contractDependencies":[],"contractKind":"interface","documentation":{"id":18,"nodeType":"StructuredDocumentation","src":"198:68:1","text":" @dev Required interface of an ERC-721 compliant contract."},"fullyImplemented":false,"id":130,"linearizedBaseContracts":[130,616],"name":"IERC721","nameLocation":"277:7:1","nodeType":"ContractDefinition","nodes":[{"anonymous":false,"documentation":{"id":21,"nodeType":"StructuredDocumentation","src":"302:88:1","text":" @dev Emitted when `tokenId` token is transferred from `from` to `to`."},"eventSelector":"ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","id":29,"name":"Transfer","nameLocation":"401:8:1","nodeType":"EventDefinition","parameters":{"id":28,"nodeType":"ParameterList","parameters":[{"constant":false,"id":23,"indexed":true,"mutability":"mutable","name":"from","nameLocation":"426:4:1","nodeType":"VariableDeclaration","scope":29,"src":"410:20:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":22,"name":"address","nodeType":"ElementaryTypeName","src":"410:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":25,"indexed":true,"mutability":"mutable","name":"to","nameLocation":"448:2:1","nodeType":"VariableDeclaration","scope":29,"src":"432:18:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":24,"name":"address","nodeType":"ElementaryTypeName","src":"432:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":27,"indexed":true,"mutability":"mutable","name":"tokenId","nameLocation":"468:7:1","nodeType":"VariableDeclaration","scope":29,"src":"452:23:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":26,"name":"uint256","nodeType":"ElementaryTypeName","src":"452:7:1","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"409:67:1"},"src":"395:82:1"},{"anonymous":false,"documentation":{"id":30,"nodeType":"StructuredDocumentation","src":"483:94:1","text":" @dev Emitted when `owner` enables `approved` to manage the `tokenId` token."},"eventSelector":"8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925","id":38,"name":"Approval","nameLocation":"588:8:1","nodeType":"EventDefinition","parameters":{"id":37,"nodeType":"ParameterList","parameters":[{"constant":false,"id":32,"indexed":true,"mutability":"mutable","name":"owner","nameLocation":"613:5:1","nodeType":"VariableDeclaration","scope":38,"src":"597:21:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":31,"name":"address","nodeType":"ElementaryTypeName","src":"597:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":34,"indexed":true,"mutability":"mutable","name":"approved","nameLocation":"636:8:1","nodeType":"VariableDeclaration","scope":38,"src":"620:24:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":33,"name":"address","nodeType":"ElementaryTypeName","src":"620:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":36,"indexed":true,"mutability":"mutable","name":"tokenId","nameLocation":"662:7:1","nodeType":"VariableDeclaration","scope":38,"src":"646:23:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":35,"name":"uint256","nodeType":"ElementaryTypeName","src":"646:7:1","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"596:74:1"},"src":"582:89:1"},{"anonymous":false,"documentation":{"id":39,"nodeType":"StructuredDocumentation","src":"677:117:1","text":" @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets."},"eventSelector":"17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31","id":47,"name":"ApprovalForAll","nameLocation":"805:14:1","nodeType":"EventDefinition","parameters":{"id":46,"nodeType":"ParameterList","parameters":[{"constant":false,"id":41,"indexed":true,"mutability":"mutable","name":"owner","nameLocation":"836:5:1","nodeType":"VariableDeclaration","scope":47,"src":"820:21:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":40,"name":"address","nodeType":"ElementaryTypeName","src":"820:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":43,"indexed":true,"mutability":"mutable","name":"operator","nameLocation":"859:8:1","nodeType":"VariableDeclaration","scope":47,"src":"843:24:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":42,"name":"address","nodeType":"ElementaryTypeName","src":"843:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":45,"indexed":false,"mutability":"mutable","name":"approved","nameLocation":"874:8:1","nodeType":"VariableDeclaration","scope":47,"src":"869:13:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":44,"name":"bool","nodeType":"ElementaryTypeName","src":"869:4:1","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"819:64:1"},"src":"799:85:1"},{"documentation":{"id":48,"nodeType":"StructuredDocumentation","src":"890:76:1","text":" @dev Returns the number of tokens in ``owner``'s account."},"functionSelector":"70a08231","id":55,"implemented":false,"kind":"function","modifiers":[],"name":"balanceOf","nameLocation":"980:9:1","nodeType":"FunctionDefinition","parameters":{"id":51,"nodeType":"ParameterList","parameters":[{"constant":false,"id":50,"mutability":"mutable","name":"owner","nameLocation":"998:5:1","nodeType":"VariableDeclaration","scope":55,"src":"990:13:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":49,"name":"address","nodeType":"ElementaryTypeName","src":"990:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"989:15:1"},"returnParameters":{"id":54,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53,"mutability":"mutable","name":"balance","nameLocation":"1036:7:1","nodeType":"VariableDeclaration","scope":55,"src":"1028:15:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":52,"name":"uint256","nodeType":"ElementaryTypeName","src":"1028:7:1","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"1027:17:1"},"scope":130,"src":"971:74:1","stateMutability":"view","virtual":false,"visibility":"external"},{"documentation":{"id":56,"nodeType":"StructuredDocumentation","src":"1051:131:1","text":" @dev Returns the owner of the `tokenId` token.\n Requirements:\n - `tokenId` must exist."},"functionSelector":"6352211e","id":63,"implemented":false,"kind":"function","modifiers":[],"name":"ownerOf","nameLocation":"1196:7:1","nodeType":"FunctionDefinition","parameters":{"id":59,"nodeType":"ParameterList","parameters":[{"constant":false,"id":58,"mutability":"mutable","name":"tokenId","nameLocation":"1212:7:1","nodeType":"VariableDeclaration","scope":63,"src":"1204:15:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":57,"name":"uint256","nodeType":"ElementaryTypeName","src":"1204:7:1","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"1203:17:1"},"returnParameters":{"id":62,"nodeType":"ParameterList","parameters":[{"constant":false,"id":61,"mutability":"mutable","name":"owner","nameLocation":"1252:5:1","nodeType":"VariableDeclaration","scope":63,"src":"1244:13:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":60,"name":"address","nodeType":"ElementaryTypeName","src":"1244:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"}],"src":"1243:15:1"},"scope":130,"src":"1187:72:1","stateMutability":"view","virtual":false,"visibility":"external"},{"documentation":{"id":64,"nodeType":"StructuredDocumentation","src":"1265:565:1","text":" @dev Safely transfers `tokenId` token from `from` to `to`.\n Requirements:\n - `from` cannot be the zero address.\n - `to` cannot be the zero address.\n - `tokenId` token must exist and be owned by `from`.\n - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n   a safe transfer.\n Emits a {Transfer} event."},"functionSelector":"b88d4fde","id":75,"implemented":false,"kind":"function","modifiers":[],"name":"safeTransferFrom","nameLocation":"1844:16:1","nodeType":"FunctionDefinition","parameters":{"id":73,"nodeType":"ParameterList","parameters":[{"constant":false,"id":66,"mutability":"mutable","name":"from","nameLocation":"1869:4:1","nodeType":"VariableDeclaration","scope":75,"src":"1861:12:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":65,"name":"address","nodeType":"ElementaryTypeName","src":"1861:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":68,"mutability":"mutable","name":"to","nameLocation":"1883:2:1","nodeType":"VariableDeclaration","scope":75,"src":"1875:10:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":67,"name":"address","nodeType":"ElementaryTypeName","src":"1875:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":70,"mutability":"mutable","name":"tokenId","nameLocation":"1895:7:1","nodeType":"VariableDeclaration","scope":75,"src":"1887:15:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":69,"name":"uint256","nodeType":"ElementaryTypeName","src":"1887:7:1","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"},{"constant":false,"id":72,"mutability":"mutable","name":"data","nameLocation":"1919:4:1","nodeType":"VariableDeclaration","scope":75,"src":"1904:19:1","stateVariable":false,"storageLocation":"calldata","typeDescriptions":{"typeIdentifier":"t_bytes_calldata_ptr","typeString":"bytes"},"typeName":{"id":71,"name":"bytes","nodeType":"ElementaryTypeName","src":"1904:5:1","typeDescriptions":{"typeIdentifier":"t_bytes_storage_ptr","typeString":"bytes"}},"visibility":"internal"}],"src":"1860:64:1"},"returnParameters":{"id":74,"nodeType":"ParameterList","parameters":[],"src":"1933:0:1"},"scope":130,"src":"1835:99:1","stateMutability":"nonpayable","virtual":false,"visibility":"external"},{"documentation":{"id":76,"nodeType":"StructuredDocumentation","src":"1940:706:1","text":" @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n are aware of the ERC-721 protocol to prevent tokens from being forever locked.\n Requirements:\n - `from` cannot be the zero address.\n - `to` cannot be the zero address.\n - `tokenId` token must exist and be owned by `from`.\n - If the caller is not `from`, it must have been allowed to move this token by either {approve} or\n   {setApprovalForAll}.\n - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon\n   a safe transfer.\n Emits a {Transfer} event."},"functionSelector":"42842e0e","id":85,"implemented":false,"kind":"function","modifiers":[],"name":"safeTransferFrom","nameLocation":"2660:16:1","nodeType":"FunctionDefinition","parameters":{"id":83,"nodeType":"ParameterList","parameters":[{"constant":false,"id":78,"mutability":"mutable","name":"from","nameLocation":"2685:4:1","nodeType":"VariableDeclaration","scope":85,"src":"2677:12:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":77,"name":"address","nodeType":"ElementaryTypeName","src":"2677:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":80,"mutability":"mutable","name":"to","nameLocation":"2699:2:1","nodeType":"VariableDeclaration","scope":85,"src":"2691:10:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"},"typeName":{"id":79,"name":"address","nodeType":"ElementaryTypeName","src":"2691:7:1","stateMutability":"nonpayable","typeDescriptions":{"typeIdentifier":"t_address","typeString":"address"}},"visibility":"internal"},{"constant":false,"id":82,"mutability":"mutable","name":"tokenId","nameLocation":"2711:7:1","nodeType":"VariableDeclaration","scope":85,"src":"2703:15:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":81,"name":"uint256","nodeType":"ElementaryTypeName","src":"2703:7:1","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"2676:43:1"},"returnParameters":{"id":84,"nodeType":"ParameterList","parameters":[],"src":"2728:0:1"},"scope":130,"src":"2651:78:1","stateMutability":"nonpayable","virtual":false,"visibility":"external"},{"documentation":{"id":86,"nodeType":"StructuredDocumentation","src":"2735:733:1","text":" @dev Transfers `tokenId` token from `from` to `to`.\n WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721\n or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n understand this adds an external call which potentially creates a reentrancy vulnerability.\n Requirements:\n - `from` cannot be the zero address.\n - `to` cannot be the zero address.\n - `tokenId` token must be owned by `from`.\n - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n Emits a {Transfer} event."},"functionSelector":"23b872dd","id":95,"implemented"