Request form
LayerZero Examples
  • CrossChain
  • Messaging
  • Protocol
  • Docs
    Source
    ChefGPT

    LayerZero is an omnichain interoperability protocol designed for lightweight message passing across chains. LayerZero provides authentic and guaranteed message delivery with configurable trustlessness.

    OwnableUpgradeable :
    Contract module which provides a basic access control mechanism, where there is an account (an owner) that can be granted exclusive access to specific functions. By default, the owner account will be the one that deploys the contract. This can later be changed with {transferOwnership}. This module is used through inheritance. It will make available the modifier `onlyOwner`, which can be applied to your functions to restrict their use to the owner.
    owner() :
    Returns the address of the current owner.
    renounceOwnership() :
    Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.
    transferOwnership(address) :
    Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.
    Initializable :
    This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. The initialization functions use a version number. Once a version number is used, it is consumed and cannot be reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in case an upgrade adds a module that needs to be initialized. For example: [.hljs-theme-light.nopadding] ``` contract MyToken is ERC20Upgradeable { function initialize() initializer public { __ERC20_init("MyToken", "MTK"); } } contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { function initializeV2() reinitializer(2) public { __ERC20Permit_init("MyToken"); } } ``` TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. [CAUTION] ==== Avoid leaving a contract uninitialized. An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: [.hljs-theme-light.nopadding] ```
    ReentrancyGuardUpgradeable :
    Contract module that helps prevent reentrant calls to a function. Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier available, which can be applied to functions to make sure there are no nested (reentrant) calls to them. Note that because there is a single `nonReentrant` guard, functions marked as `nonReentrant` may not call one another. This can be worked around by making those functions `private`, and then adding `external` `nonReentrant` entry points to them. TIP: If you would like to learn more about reentrancy and alternative ways to protect against it, check out our blog post https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
    ERC1155Upgradeable :
    Implementation of the basic standard multi-token. See https://eips.ethereum.org/EIPS/eip-1155 Originally based on code by Enjin: https://github.com/enjin/erc-1155 _Available since v3.1._
    balanceOf(address,uint256) :
    See {IERC1155-balanceOf}. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    See {IERC1155-balanceOfBatch}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    See {IERC1155-isApprovedForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    See {IERC1155-safeBatchTransferFrom}.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    See {IERC1155-safeTransferFrom}.
    setApprovalForAll(address,bool) :
    See {IERC1155-setApprovalForAll}.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    uri(uint256) :
    See {IERC1155MetadataURI-uri}. This implementation returns the same URI for *all* token types. It relies on the token type ID substitution mechanism https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. Clients calling this function must replace the `\{id\}` substring with the actual token type ID.
    IERC1155ReceiverUpgradeable :
    _Available since v3.1._
    onERC1155BatchReceived(address,address,uint256[],uint256[],bytes) :
    Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a `safeBatchTransferFrom` after the balances have been updated. NOTE: To accept the transfer(s), this must return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81, or its own function selector).
    onERC1155Received(address,address,uint256,uint256,bytes) :
    Handles the receipt of a single ERC1155 token type. This function is called at the end of a `safeTransferFrom` after the balance has been updated. NOTE: To accept the transfer, this must return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61, or its own function selector).
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IERC1155Upgradeable :
    Required interface of an ERC1155 compliant contract, as defined in the https://eips.ethereum.org/EIPS/eip-1155[EIP]. _Available since v3.1._
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IERC1155MetadataURIUpgradeable :
    Interface of the optional ERC1155MetadataExtension interface, as defined in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP]. _Available since v3.1._
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    uri(uint256) :
    Returns the URI for token type `id`. If the `\{id\}` substring is present in the URI, it must be replaced by clients with the actual token type ID.
    ERC20Upgradeable :
    Implementation of the {IERC20} interface. This implementation is agnostic to the way tokens are created. This means that a supply mechanism has to be added in a derived contract using {_mint}. For a generic mechanism see {ERC20PresetMinterPauser}. TIP: For a detailed writeup see our guide https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How to implement supply mechanisms]. We have followed general OpenZeppelin Contracts guidelines: functions revert instead returning `false` on failure. This behavior is nonetheless conventional and does not conflict with the expectations of ERC20 applications. Additionally, an {Approval} event is emitted on calls to {transferFrom}. This allows applications to reconstruct the allowance for all accounts just by listening to said events. Other implementations of the EIP may not emit these events, as it isn't required by the specification. Finally, the non-standard {decreaseAllowance} and {increaseAllowance} functions have been added to mitigate the well-known issues around setting allowances. See {IERC20-approve}.
    allowance(address,address) :
    See {IERC20-allowance}.
    approve(address,uint256) :
    See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.
    balanceOf(address) :
    See {IERC20-balanceOf}.
    decimals() :
    Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.
    decreaseAllowance(address,uint256) :
    Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.
    increaseAllowance(address,uint256) :
    Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token, usually a shorter version of the name.
    totalSupply() :
    See {IERC20-totalSupply}.
    transfer(address,uint256) :
    See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.
    transferFrom(address,address,uint256) :
    See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.
    IERC20Upgradeable :
    Interface of the ERC20 standard as defined in the EIP.
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    IERC20MetadataUpgradeable :
    Interface for the optional metadata functions from the ERC20 standard. _Available since v4.1._
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    decimals() :
    Returns the decimals places of the token.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token.
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    ERC721Upgradeable :
    Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including the Metadata extension, but not including the Enumerable extension, which is available separately as {ERC721Enumerable}.
    approve(address,uint256) :
    See {IERC721-approve}.
    balanceOf(address) :
    See {IERC721-balanceOf}.
    getApproved(uint256) :
    See {IERC721-getApproved}.
    isApprovedForAll(address,address) :
    See {IERC721-isApprovedForAll}.
    name() :
    See {IERC721Metadata-name}.
    ownerOf(uint256) :
    See {IERC721-ownerOf}.
    safeTransferFrom(address,address,uint256) :
    See {IERC721-safeTransferFrom}.
    safeTransferFrom(address,address,uint256,bytes) :
    See {IERC721-safeTransferFrom}.
    setApprovalForAll(address,bool) :
    See {IERC721-setApprovalForAll}.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    symbol() :
    See {IERC721Metadata-symbol}.
    tokenURI(uint256) :
    See {IERC721Metadata-tokenURI}.
    transferFrom(address,address,uint256) :
    See {IERC721-transferFrom}.
    IERC721ReceiverUpgradeable :
    Interface for any contract that wants to support safeTransfers from ERC721 asset contracts.
    onERC721Received(address,address,uint256,bytes) :
    Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} by `operator` from `from`, this function is called. It must return its Solidity selector to confirm the token transfer. If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
    IERC721Upgradeable :
    Required interface of an ERC721 compliant contract.
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IERC721MetadataUpgradeable :
    See https://eips.ethereum.org/EIPS/eip-721
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    name() :
    Returns the token collection name.
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    symbol() :
    Returns the token collection symbol.
    tokenURI(uint256) :
    Returns the Uniform Resource Identifier (URI) for `tokenId` token.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    AddressUpgradeable :
    Collection of functions related to the address type
    ContextUpgradeable :
    Provides information about the current execution context, including the sender of the transaction and its data. While these are generally available via msg.sender and msg.data, they should not be accessed in such a direct manner, since when dealing with meta-transactions the account sending and paying for execution may not be the actual sender (as far as an application is concerned). This contract is only required for intermediate, library-like contracts.
    StringsUpgradeable :
    String operations.
    ERC165Upgradeable :
    Implementation of the {IERC165} interface. Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check for the additional interface id that will be supported. For example: ```solidity function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); } ``` Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    IERC165Upgradeable :
    Interface of the ERC165 standard, as defined in the https://eips.ethereum.org/EIPS/eip-165[EIP]. Implementers can declare support of contract interfaces, which can then be queried by others ({ERC165Checker}). For an implementation, see {ERC165}.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    Ownable :
    Contract module which provides a basic access control mechanism, where there is an account (an owner) that can be granted exclusive access to specific functions. By default, the owner account will be the one that deploys the contract. This can later be changed with {transferOwnership}. This module is used through inheritance. It will make available the modifier `onlyOwner`, which can be applied to your functions to restrict their use to the owner.
    constructor :
    Initializes the contract setting the deployer as the initial owner.
    owner() :
    Returns the address of the current owner.
    renounceOwnership() :
    Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.
    transferOwnership(address) :
    Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.
    Pausable :
    Contract module which allows children to implement an emergency stop mechanism that can be triggered by an authorized account. This module is used through inheritance. It will make available the modifiers `whenNotPaused` and `whenPaused`, which can be applied to the functions of your contract. Note that they will not be pausable by simply including this module, only once the modifiers are put in place.
    constructor :
    Initializes the contract in unpaused state.
    paused() :
    Returns true if the contract is paused, and false otherwise.
    ReentrancyGuard :
    Contract module that helps prevent reentrant calls to a function. Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier available, which can be applied to functions to make sure there are no nested (reentrant) calls to them. Note that because there is a single `nonReentrant` guard, functions marked as `nonReentrant` may not call one another. This can be worked around by making those functions `private`, and then adding `external` `nonReentrant` entry points to them. TIP: If you would like to learn more about reentrancy and alternative ways to protect against it, check out our blog post https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
    ERC1155 :
    Implementation of the basic standard multi-token. See https://eips.ethereum.org/EIPS/eip-1155 Originally based on code by Enjin: https://github.com/enjin/erc-1155 _Available since v3.1._
    balanceOf(address,uint256) :
    See {IERC1155-balanceOf}. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    See {IERC1155-balanceOfBatch}. Requirements: - `accounts` and `ids` must have the same length.
    constructor :
    See {_setURI}.
    isApprovedForAll(address,address) :
    See {IERC1155-isApprovedForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    See {IERC1155-safeBatchTransferFrom}.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    See {IERC1155-safeTransferFrom}.
    setApprovalForAll(address,bool) :
    See {IERC1155-setApprovalForAll}.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    uri(uint256) :
    See {IERC1155MetadataURI-uri}. This implementation returns the same URI for *all* token types. It relies on the token type ID substitution mechanism https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. Clients calling this function must replace the `\{id\}` substring with the actual token type ID.
    IERC1155 :
    Required interface of an ERC1155 compliant contract, as defined in the https://eips.ethereum.org/EIPS/eip-1155[EIP]. _Available since v3.1._
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IERC1155Receiver :
    _Available since v3.1._
    onERC1155BatchReceived(address,address,uint256[],uint256[],bytes) :
    Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a `safeBatchTransferFrom` after the balances have been updated. NOTE: To accept the transfer(s), this must return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81, or its own function selector).
    onERC1155Received(address,address,uint256,uint256,bytes) :
    Handles the receipt of a single ERC1155 token type. This function is called at the end of a `safeTransferFrom` after the balance has been updated. NOTE: To accept the transfer, this must return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61, or its own function selector).
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IERC1155MetadataURI :
    Interface of the optional ERC1155MetadataExtension interface, as defined in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP]. _Available since v3.1._
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    uri(uint256) :
    Returns the URI for token type `id`. If the `\{id\}` substring is present in the URI, it must be replaced by clients with the actual token type ID.
    ERC20 :
    Implementation of the {IERC20} interface. This implementation is agnostic to the way tokens are created. This means that a supply mechanism has to be added in a derived contract using {_mint}. For a generic mechanism see {ERC20PresetMinterPauser}. TIP: For a detailed writeup see our guide https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How to implement supply mechanisms]. The default value of {decimals} is 18. To change this, you should override this function so it returns a different value. We have followed general OpenZeppelin Contracts guidelines: functions revert instead returning `false` on failure. This behavior is nonetheless conventional and does not conflict with the expectations of ERC20 applications. Additionally, an {Approval} event is emitted on calls to {transferFrom}. This allows applications to reconstruct the allowance for all accounts just by listening to said events. Other implementations of the EIP may not emit these events, as it isn't required by the specification. Finally, the non-standard {decreaseAllowance} and {increaseAllowance} functions have been added to mitigate the well-known issues around setting allowances. See {IERC20-approve}.
    allowance(address,address) :
    See {IERC20-allowance}.
    approve(address,uint256) :
    See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.
    balanceOf(address) :
    See {IERC20-balanceOf}.
    constructor :
    Sets the values for {name} and {symbol}. All two of these values are immutable: they can only be set once during construction.
    decimals() :
    Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.
    decreaseAllowance(address,uint256) :
    Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.
    increaseAllowance(address,uint256) :
    Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token, usually a shorter version of the name.
    totalSupply() :
    See {IERC20-totalSupply}.
    transfer(address,uint256) :
    See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.
    transferFrom(address,address,uint256) :
    See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.
    IERC20 :
    Interface of the ERC20 standard as defined in the EIP.
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    ERC20Capped :
    Extension of {ERC20} that adds a cap to the supply of tokens.
    allowance(address,address) :
    See {IERC20-allowance}.
    approve(address,uint256) :
    See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.
    balanceOf(address) :
    See {IERC20-balanceOf}.
    cap() :
    Returns the cap on the token's total supply.
    constructor :
    Sets the value of the `cap`. This value is immutable, it can only be set once during construction.
    decimals() :
    Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.
    decreaseAllowance(address,uint256) :
    Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.
    increaseAllowance(address,uint256) :
    Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token, usually a shorter version of the name.
    totalSupply() :
    See {IERC20-totalSupply}.
    transfer(address,uint256) :
    See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.
    transferFrom(address,address,uint256) :
    See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.
    IERC20Metadata :
    Interface for the optional metadata functions from the ERC20 standard. _Available since v4.1._
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    decimals() :
    Returns the decimals places of the token.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token.
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    IERC20Permit :
    Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't need to send a transaction, and thus is not required to hold Ether at all.
    DOMAIN_SEPARATOR() :
    Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
    nonces(address) :
    Returns the current nonce for `owner`. This value must be included whenever a signature is generated for {permit}. Every successful call to {permit} increases ``owner``'s nonce by one. This prevents a signature from being used multiple times.
    permit(address,address,uint256,uint256,uint8,bytes32,bytes32) :
    Sets `value` as the allowance of `spender` over ``owner``'s tokens, given ``owner``'s signed approval. IMPORTANT: The same issues {IERC20-approve} has related to transaction ordering also apply here. Emits an {Approval} event. Requirements: - `spender` cannot be the zero address. - `deadline` must be a timestamp in the future. - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` over the EIP712-formatted function arguments. - the signature must use ``owner``'s current nonce (see {nonces}). For more information on the signature format, see the https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP section].
    SafeERC20 :
    Wrappers around ERC20 operations that throw on failure (when the token contract returns false). Tokens that return no value (and instead revert or throw on failure) are also supported, non-reverting calls are assumed to be successful. To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
    ERC721 :
    Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including the Metadata extension, but not including the Enumerable extension, which is available separately as {ERC721Enumerable}.
    approve(address,uint256) :
    See {IERC721-approve}.
    balanceOf(address) :
    See {IERC721-balanceOf}.
    constructor :
    Initializes the contract by setting a `name` and a `symbol` to the token collection.
    getApproved(uint256) :
    See {IERC721-getApproved}.
    isApprovedForAll(address,address) :
    See {IERC721-isApprovedForAll}.
    name() :
    See {IERC721Metadata-name}.
    ownerOf(uint256) :
    See {IERC721-ownerOf}.
    safeTransferFrom(address,address,uint256) :
    See {IERC721-safeTransferFrom}.
    safeTransferFrom(address,address,uint256,bytes) :
    See {IERC721-safeTransferFrom}.
    setApprovalForAll(address,bool) :
    See {IERC721-setApprovalForAll}.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    symbol() :
    See {IERC721Metadata-symbol}.
    tokenURI(uint256) :
    See {IERC721Metadata-tokenURI}.
    transferFrom(address,address,uint256) :
    See {IERC721-transferFrom}.
    IERC721 :
    Required interface of an ERC721 compliant contract.
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IERC721Receiver :
    Interface for any contract that wants to support safeTransfers from ERC721 asset contracts.
    onERC721Received(address,address,uint256,bytes) :
    Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} by `operator` from `from`, this function is called. It must return its Solidity selector to confirm the token transfer. If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
    IERC721Metadata :
    See https://eips.ethereum.org/EIPS/eip-721
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    name() :
    Returns the token collection name.
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    symbol() :
    Returns the token collection symbol.
    tokenURI(uint256) :
    Returns the Uniform Resource Identifier (URI) for `tokenId` token.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    Address :
    Collection of functions related to the address type
    Context :
    Provides information about the current execution context, including the sender of the transaction and its data. While these are generally available via msg.sender and msg.data, they should not be accessed in such a direct manner, since when dealing with meta-transactions the account sending and paying for execution may not be the actual sender (as far as an application is concerned). This contract is only required for intermediate, library-like contracts.
    Strings :
    String operations.
    ERC165 :
    Implementation of the {IERC165} interface. Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check for the additional interface id that will be supported. For example: ```solidity function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); } ``` Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    ERC165Checker :
    Library used to query support of an interface declared via {IERC165}. Note that these functions return the actual result of the query: they do not `revert` if an interface is not supported. It is up to the caller to decide what to do in these cases.
    IERC165 :
    Interface of the ERC165 standard, as defined in the https://eips.ethereum.org/EIPS/eip-165[EIP]. Implementers can declare support of contract interfaces, which can then be queried by others ({ERC165Checker}). For an implementation, see {ERC165}.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    Math :
    Standard math utilities missing in the Solidity language.
    SafeMath :
    Wrappers over Solidity's arithmetic operations. NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler now has built in overflow checking.
    SignedMath :
    Standard signed math utilities missing in the Solidity language.
    IOFTCoreUpgradeable :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    IOFTUpgradeable :
    Interface of the OFT standard
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    IONFT1155CoreUpgradeable :
    Interface of the ONFT Core standard
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT1155Upgradeable :
    Interface of the ONFT standard
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT721CoreUpgradeable :
    Interface of the ONFT Core Upgradeable standard
    estimateSendBatchFee(uint16,bytes,uint256[],bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenIds[] - token Ids to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenId - token Id to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    sendBatchFrom(address,uint16,bytes,uint256[],address,address,bytes) :
    send tokens `_tokenIds[]` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send token `_tokenId` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT721Upgradeable :
    Interface of the ONFT Upgradeable standard
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    estimateSendBatchFee(uint16,bytes,uint256[],bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenIds[] - token Ids to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenId - token Id to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    sendBatchFrom(address,uint16,bytes,uint256[],address,address,bytes) :
    send tokens `_tokenIds[]` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send token `_tokenId` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IOFT :
    Interface of the OFT standard
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    IOFTCore :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    GlobalCappedOFT :
    Extension of {OFT} that adds a global cap to the supply of tokens across all chains.
    allowance(address,address) :
    See {IERC20-allowance}.
    approve(address,uint256) :
    See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.
    balanceOf(address) :
    See {IERC20-balanceOf}.
    cap() :
    Returns the cap on the token's total supply.
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    decimals() :
    Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.
    decreaseAllowance(address,uint256) :
    Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    increaseAllowance(address,uint256) :
    Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.
    name() :
    Returns the name of the token.
    owner() :
    Returns the address of the current owner.
    renounceOwnership() :
    Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    symbol() :
    Returns the symbol of the token, usually a shorter version of the name.
    token() :
    returns the address of the ERC20 token
    totalSupply() :
    See {IERC20-totalSupply}.
    transfer(address,uint256) :
    See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.
    transferFrom(address,address,uint256) :
    See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.
    transferOwnership(address) :
    Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.
    ICommonOFT :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes32,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    IOFTV2 :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes32,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes32,uint256,(address,address,bytes)) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    IOFTWithFee :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes32,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes32,uint256,uint256,(address,address,bytes)) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_minAmount` the minimum amount of tokens to receive on dstChain `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    IONFT1155 :
    Interface of the ONFT standard
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT1155Core :
    Interface of the ONFT Core standard
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT721 :
    Interface of the ONFT standard
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    estimateSendBatchFee(uint16,bytes,uint256[],bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenIds[] - token Ids to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenId - token Id to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    sendBatchFrom(address,uint16,bytes,uint256[],address,address,bytes) :
    send tokens `_tokenIds[]` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send token `_tokenId` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IONFT721Core :
    Interface of the ONFT Core standard
    estimateSendBatchFee(uint16,bytes,uint256[],bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenIds[] - token Ids to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenId - token Id to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    sendBatchFrom(address,uint16,bytes,uint256[],address,address,bytes) :
    send tokens `_tokenIds[]` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send token `_tokenId` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    ERC721A :
    Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721) Non-Fungible Token Standard, including the Metadata extension. Optimized for lower gas during batch mints. Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...) starting from `_startTokenId()`. Assumptions: - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply. - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in `owner`'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}.
    name() :
    Returns the token collection name.
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified) to learn more about how these ids are created. This function call must use less than 30000 gas.
    symbol() :
    Returns the token collection symbol.
    tokenURI(uint256) :
    Returns the Uniform Resource Identifier (URI) for `tokenId` token.
    totalSupply() :
    Returns the total number of tokens in existence. Burned tokens will reduce the count. To get the total number of tokens minted, please see {_totalMinted}.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IERC721A :
    Interface of ERC721A.
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in `owner`'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}.
    name() :
    Returns the token collection name.
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified) to learn more about how these ids are created. This function call must use less than 30000 gas.
    symbol() :
    Returns the token collection symbol.
    tokenURI(uint256) :
    Returns the Uniform Resource Identifier (URI) for `tokenId` token.
    totalSupply() :
    Returns the total number of tokens in existence. Burned tokens will reduce the count. To get the total number of tokens minted, please see {_totalMinted}.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` from `from` to `to`. WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    OwnableUpgradeable.sol
    Initializable.sol
    ReentrancyGuardUpgradeable.sol
    ERC1155Upgradeable.sol
    IERC1155ReceiverUpgradeable.sol
    IERC1155Upgradeable.sol
    IERC1155MetadataURIUpgradeable.sol
    ERC20Upgradeable.sol
    IERC20Upgradeable.sol
    IERC20MetadataUpgradeable.sol
    ERC721Upgradeable.sol
    IERC721ReceiverUpgradeable.sol
    IERC721Upgradeable.sol
    IERC721MetadataUpgradeable.sol
    AddressUpgradeable.sol
    ContextUpgradeable.sol
    StringsUpgradeable.sol
    ERC165Upgradeable.sol
    IERC165Upgradeable.sol
    Ownable.sol
    Pausable.sol
    ReentrancyGuard.sol
    ERC1155.sol
    IERC1155.sol
    IERC1155Receiver.sol
    IERC1155MetadataURI.sol
    ERC20.sol
    IERC20.sol
    ERC20Capped.sol
    IERC20Metadata.sol
    IERC20Permit.sol
    SafeERC20.sol
    ERC721.sol
    IERC721.sol
    IERC721Receiver.sol
    IERC721Metadata.sol
    Address.sol
    Context.sol
    Strings.sol
    ERC165.sol
    ERC165Checker.sol
    IERC165.sol
    Math.sol
    SafeMath.sol
    SignedMath.sol
    IUniswapV2Router01.sol
    IUniswapV2Router02.sol
    StargateComposed.sol
    ExampleOFTUpgradeable.sol
    ExampleONFT1155Upgradeable.sol
    ExampleONFT721Upgradeable.sol
    ILayerZeroEndpointUpgradeable.sol
    ILayerZeroReceiverUpgradeable.sol
    ILayerZeroUserApplicationConfigUpgradeable.sol
    LzAppUpgradeable.sol
    NonblockingLzAppUpgradeable.sol
    IOFTCoreUpgradeable.sol
    IOFTUpgradeable.sol
    OFTCoreUpgradeable.sol
    OFTUpgradeable.sol
    IONFT1155CoreUpgradeable.sol
    IONFT1155Upgradeable.sol
    ONFT1155CoreUpgradeable.sol
    ONFT1155Upgradable.sol
    IONFT721CoreUpgradeable.sol
    IONFT721Upgradeable.sol
    ONFT721CoreUpgradeable.sol
    ONFT721Upgradeable.sol
    ExampleBasedOFT20.sol
    ExampleOFT.sol
    ExampleOFTV2.sol
    ExampleUniversalONFT721.sol
    OmniCounter.sol
    PingPong.sol
    ILayerZeroEndpoint.sol
    ILayerZeroReceiver.sol
    ILayerZeroUserApplicationConfig.sol
    IStargateFactory.sol
    IStargatePool.sol
    IStargateReceiver.sol
    IStargateRouter.sol
    IStargateRouterETH.sol
    IStargateWidget.sol
    LzLib.sol
    LzApp.sol
    NonblockingLzApp.sol
    DistributeONFT721Mock.sol
    ERC1155Mock.sol
    ERC20Mock.sol
    ERC721Mock.sol
    LZEndpointMock.sol
    MockToken.sol
    OFTStakingMockV2.sol
    ONFT721AMock.sol
    ONFT721Mock.sol
    StargateSwap.sol
    IOFT.sol
    IOFTCore.sol
    OFT.sol
    OFTCore.sol
    BasedOFT.sol
    GlobalCappedOFT.sol
    NativeOFT.sol
    PausableOFT.sol
    ProxyOFT.sol
    BaseOFTV2.sol
    ICommonOFT.sol
    IOFTReceiverV2.sol
    IOFTV2.sol
    NativeOFTV2.sol
    OFTCoreV2.sol
    OFTV2.sol
    ProxyOFTV2.sol
    BaseOFTWithFee.sol
    Fee.sol
    IOFTWithFee.sol
    NativeOFTWithFee.sol
    OFTWithFee.sol
    ProxyOFTWithFee.sol
    IONFT1155.sol
    IONFT1155Core.sol
    IONFT721.sol
    IONFT721Core.sol
    ONFT1155.sol
    ONFT1155Core.sol
    ONFT721.sol
    ONFT721Core.sol
    DistributeONFT721.sol
    ONFT721A.sol
    ProxyONFT1155.sol
    ProxyONFT721.sol
    UniversalONFT721.sol
    BitLib.sol
    BytesLib.sol
    ExcessivelySafeCall.sol
    ERC721A.sol
    IERC721A.sol
    Proxied.sol
    WidgetSwap.sol

    7 downloads

    Chains

    Authors

    LayerZero Examples
  • CrossChain
  • Messaging
  • Protocol
  • Info
    Docs
    Source
    ChefGPT
    Expand
    Share
    LayerZero

    LayerZero Omnichain Contract Examples

    • Formal audit(s) (May 21, 2022) can be found in /audit

    Install & Run tests

    yarn install
    npx hardhat test 
    
    • The code in the /contracts folder demonstrates LayerZero behaviours.
    • NonblockingLzApp is a great contract to extend. Take a look at how OmniCounter overrides _nonblockingLzReceive and _LzReceive to easily handle messaging. There are also example for OFT and ONFT which illustrate erc20 and erc721 cross chain functionality.
    • Always audit your own code and test extensively on testnet before going to mainnet 🙏

    The examples below use two chains, however you could substitute any LayerZero supported chain!

    OmnichainFungibleToken (OFT)

    About OFTV2

    NOTE: the OFTV2 uses uint64 to encode value transfer for compatability of aptos and solana. 
    
    The deployer is expected to set a lower decimal points like 6 or 8. 
    
    If the decimal point is 18, then uint64 can only represent approximately 18 tokens (uint64.max ~= 18 * 10^18).
    

    Deploy Setup

    1. Add a .env file (to the root project directory) with your MNEMONIC="" and fund your wallet in order to deploy!
    2. Follow any of the tutorials below

    OFTV2.sol - an omnichain ERC20

    WARNING: You must perform the setTrustedRemote() (step 2).

    1. Deploy two contracts:
    npx hardhat --network goerli deploy --tags ExampleOFTV2
    npx hardhat --network fuji deploy --tags ExampleOFTV2
    
    1. Set the "trusted remotes" (ie: your contracts) so each of them can receive messages from one another, and only one another.
    npx hardhat --network goerli setTrustedRemote --target-network fuji --contract ExampleOFTV2
    npx hardhat --network fuji setTrustedRemote --target-network goerli --contract ExampleOFTV2
    
    1. Send tokens from goerli to fuji
    npx hardhat --network goerli oftv2Send --target-network fuji --qty 42 --contract ExampleOFTV2
    

    Pro-tip: Check the ERC20 transactions tab of the destination chain block explorer and await your tokens!

    OmnichainNonFungibleToken721 (ONFT721)

    This ONFT contract allows minting of nftIds on separate chains. To ensure two chains can not mint the same nfId each contract on each chain is only allowed to mintnftIds in certain ranges. Check constants/onftArgs.json for the specific test configuration used in this demo.

    UniversalONFT.sol

    WARNING: You must perform the setTrustedRemote() (step 2).

    1. Deploy two contracts:
     npx hardhat --network bsc-testnet deploy --tags ExampleUniversalONFT721
     npx hardhat --network fuji deploy --tags ExampleUniversalONFT721
    
    1. Set the "trusted remotes", so each contract can send & receive messages from one another, and only one another.
    npx hardhat --network bsc-testnet setTrustedRemote --target-network fuji --contract ExampleUniversalONFT721
    npx hardhat --network fuji setTrustedRemote --target-network bsc-testnet --contract ExampleUniversalONFT721
    
    1. Set the min gas required on the destination
    npx hardhat --network bsc-testnet setMinDstGas --target-network fuji --contract ExampleUniversalONFT721 --packet-type 1 --min-gas 100000
    npx hardhat --network fuji setMinDstGas --target-network bsc-testnet --contract ExampleUniversalONFT721 --packet-type 1 --min-gas 100000
    
    1. Mint an NFT on each chain!
    npx hardhat --network bsc-testnet onftMint --contract ExampleUniversalONFT721
    npx hardhat --network fuji onftMint --contract ExampleUniversalONFT721
    
    1. [Optional] Show the token owner(s)
    npx hardhat --network bsc-testnet ownerOf --token-id 1 --contract ExampleUniversalONFT721
    npx hardhat --network fuji ownerOf --token-id 11 --contract ExampleUniversalONFT721
    
    1. Send ONFT across chains
    npx hardhat --network bsc-testnet onftSend --target-network fuji --token-id 1 --contract ExampleUniversalONFT721
    npx hardhat --network fuji onftSend --target-network bsc-testnet --token-id 11 --contract ExampleUniversalONFT721 
    
    1. Verify your token no longer exists in your wallet on the source chain & wait for it to reach the destination side.
    npx hardhat --network bsc-testnet ownerOf --token-id 1 --contract ExampleUniversalONFT721
    npx hardhat --network fuji ownerOf --token-id 1 --contract ExampleUniversalONFT721
    

    OmniCounter.sol

    OmniCounter is a simple contract with a counter. You can only remotely increment the counter!

    1. Deploy both OmniCounters:
    npx hardhat --network bsc-testnet deploy --tags OmniCounter
    npx hardhat --network fuji deploy --tags OmniCounter
    
    1. Set the remote addresses, so each contract can receive messages
    npx hardhat --network bsc-testnet setTrustedRemote --target-network fuji --contract OmniCounter
    npx hardhat --network fuji setTrustedRemote --target-network bsc-testnet --contract OmniCounter
    
    1. Send a cross chain message from bsc-testnet to fuji !
    npx hardhat --network bsc-testnet incrementCounter --target-network fuji
    

    Optionally use this command in a separate terminal to watch the counter increment in real-time.

    npx hardhat --network fuji ocPoll    
    

    Check your setTrustedRemote's are wired up correctly

    Just use our checkWireUpAll task to check if your contracts are wired up correctly. You can use it on the example contracts deployed above.

    1. ExampleBasedOFT and ExampleOFT
    npx hardhat checkWireUpAll --e testnet --contract ExampleOFT --proxy-contract ExampleBasedOFT --proxy-chain goerli
    
    1. UniversalONFT
    npx hardhat checkWireUpAll --e testnet --contract ExampleUniversalONFT721
    
    1. OmniCounter
    npx hardhat checkWireUpAll --e testnet --contract OmniCounter
    

    See some examples in /contracts 🙌

    Many of the example contracts make use of LayerZeroEndpointMock.sol which is a nice way to test LayerZero locally!

    For further reading, and a list of endpoint ids and deployed LayerZero contract addresses please take a look at the Gitbook here: https://layerzero.gitbook.io/

    See testnet and mainnet chainIds and addresses, and the format for connecting contracts on different chains:

    https://github.com/LayerZero-Labs/set-trusted-remotes https://layerzero.gitbook.io/docs/technical-reference/testnet/testnet-addresses https://layerzero.gitbook.io/docs/technical-reference/mainnet/supported-chain-ids

    Most recently tested with node version 16.13.1

    LayerZero is an omnichain interoperability protocol designed for lightweight message passing across chains. LayerZero provides authentic and guaranteed message delivery with configurable trustlessness.
    OwnableUpgradeable :
    Contract module which provides a basic access control mechanism, where there is an account (an owner) that can be granted exclusive access to specific functions. By default, the owner account will be the one that deploys the contract. This can later be changed with {transferOwnership}. This module is used through inheritance. It will make available the modifier `onlyOwner`, which can be applied to your functions to restrict their use to the owner.
    owner() :
    Returns the address of the current owner.
    renounceOwnership() :
    Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.
    transferOwnership(address) :
    Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.
    Initializable :
    This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. The initialization functions use a version number. Once a version number is used, it is consumed and cannot be reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in case an upgrade adds a module that needs to be initialized. For example: [.hljs-theme-light.nopadding] ``` contract MyToken is ERC20Upgradeable { function initialize() initializer public { __ERC20_init("MyToken", "MTK"); } } contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { function initializeV2() reinitializer(2) public { __ERC20Permit_init("MyToken"); } } ``` TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. [CAUTION] ==== Avoid leaving a contract uninitialized. An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: [.hljs-theme-light.nopadding] ```
    ReentrancyGuardUpgradeable :
    Contract module that helps prevent reentrant calls to a function. Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier available, which can be applied to functions to make sure there are no nested (reentrant) calls to them. Note that because there is a single `nonReentrant` guard, functions marked as `nonReentrant` may not call one another. This can be worked around by making those functions `private`, and then adding `external` `nonReentrant` entry points to them. TIP: If you would like to learn more about reentrancy and alternative ways to protect against it, check out our blog post https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
    ERC1155Upgradeable :
    Implementation of the basic standard multi-token. See https://eips.ethereum.org/EIPS/eip-1155 Originally based on code by Enjin: https://github.com/enjin/erc-1155 _Available since v3.1._
    balanceOf(address,uint256) :
    See {IERC1155-balanceOf}. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    See {IERC1155-balanceOfBatch}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    See {IERC1155-isApprovedForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    See {IERC1155-safeBatchTransferFrom}.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    See {IERC1155-safeTransferFrom}.
    setApprovalForAll(address,bool) :
    See {IERC1155-setApprovalForAll}.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    uri(uint256) :
    See {IERC1155MetadataURI-uri}. This implementation returns the same URI for *all* token types. It relies on the token type ID substitution mechanism https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. Clients calling this function must replace the `\{id\}` substring with the actual token type ID.
    IERC1155ReceiverUpgradeable :
    _Available since v3.1._
    onERC1155BatchReceived(address,address,uint256[],uint256[],bytes) :
    Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a `safeBatchTransferFrom` after the balances have been updated. NOTE: To accept the transfer(s), this must return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81, or its own function selector).
    onERC1155Received(address,address,uint256,uint256,bytes) :
    Handles the receipt of a single ERC1155 token type. This function is called at the end of a `safeTransferFrom` after the balance has been updated. NOTE: To accept the transfer, this must return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61, or its own function selector).
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IERC1155Upgradeable :
    Required interface of an ERC1155 compliant contract, as defined in the https://eips.ethereum.org/EIPS/eip-1155[EIP]. _Available since v3.1._
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IERC1155MetadataURIUpgradeable :
    Interface of the optional ERC1155MetadataExtension interface, as defined in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP]. _Available since v3.1._
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    uri(uint256) :
    Returns the URI for token type `id`. If the `\{id\}` substring is present in the URI, it must be replaced by clients with the actual token type ID.
    ERC20Upgradeable :
    Implementation of the {IERC20} interface. This implementation is agnostic to the way tokens are created. This means that a supply mechanism has to be added in a derived contract using {_mint}. For a generic mechanism see {ERC20PresetMinterPauser}. TIP: For a detailed writeup see our guide https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How to implement supply mechanisms]. We have followed general OpenZeppelin Contracts guidelines: functions revert instead returning `false` on failure. This behavior is nonetheless conventional and does not conflict with the expectations of ERC20 applications. Additionally, an {Approval} event is emitted on calls to {transferFrom}. This allows applications to reconstruct the allowance for all accounts just by listening to said events. Other implementations of the EIP may not emit these events, as it isn't required by the specification. Finally, the non-standard {decreaseAllowance} and {increaseAllowance} functions have been added to mitigate the well-known issues around setting allowances. See {IERC20-approve}.
    allowance(address,address) :
    See {IERC20-allowance}.
    approve(address,uint256) :
    See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.
    balanceOf(address) :
    See {IERC20-balanceOf}.
    decimals() :
    Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.
    decreaseAllowance(address,uint256) :
    Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.
    increaseAllowance(address,uint256) :
    Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token, usually a shorter version of the name.
    totalSupply() :
    See {IERC20-totalSupply}.
    transfer(address,uint256) :
    See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.
    transferFrom(address,address,uint256) :
    See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.
    IERC20Upgradeable :
    Interface of the ERC20 standard as defined in the EIP.
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    IERC20MetadataUpgradeable :
    Interface for the optional metadata functions from the ERC20 standard. _Available since v4.1._
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    decimals() :
    Returns the decimals places of the token.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token.
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    ERC721Upgradeable :
    Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including the Metadata extension, but not including the Enumerable extension, which is available separately as {ERC721Enumerable}.
    approve(address,uint256) :
    See {IERC721-approve}.
    balanceOf(address) :
    See {IERC721-balanceOf}.
    getApproved(uint256) :
    See {IERC721-getApproved}.
    isApprovedForAll(address,address) :
    See {IERC721-isApprovedForAll}.
    name() :
    See {IERC721Metadata-name}.
    ownerOf(uint256) :
    See {IERC721-ownerOf}.
    safeTransferFrom(address,address,uint256) :
    See {IERC721-safeTransferFrom}.
    safeTransferFrom(address,address,uint256,bytes) :
    See {IERC721-safeTransferFrom}.
    setApprovalForAll(address,bool) :
    See {IERC721-setApprovalForAll}.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    symbol() :
    See {IERC721Metadata-symbol}.
    tokenURI(uint256) :
    See {IERC721Metadata-tokenURI}.
    transferFrom(address,address,uint256) :
    See {IERC721-transferFrom}.
    IERC721ReceiverUpgradeable :
    Interface for any contract that wants to support safeTransfers from ERC721 asset contracts.
    onERC721Received(address,address,uint256,bytes) :
    Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} by `operator` from `from`, this function is called. It must return its Solidity selector to confirm the token transfer. If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
    IERC721Upgradeable :
    Required interface of an ERC721 compliant contract.
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IERC721MetadataUpgradeable :
    See https://eips.ethereum.org/EIPS/eip-721
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    name() :
    Returns the token collection name.
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    symbol() :
    Returns the token collection symbol.
    tokenURI(uint256) :
    Returns the Uniform Resource Identifier (URI) for `tokenId` token.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    AddressUpgradeable :
    Collection of functions related to the address type
    ContextUpgradeable :
    Provides information about the current execution context, including the sender of the transaction and its data. While these are generally available via msg.sender and msg.data, they should not be accessed in such a direct manner, since when dealing with meta-transactions the account sending and paying for execution may not be the actual sender (as far as an application is concerned). This contract is only required for intermediate, library-like contracts.
    StringsUpgradeable :
    String operations.
    ERC165Upgradeable :
    Implementation of the {IERC165} interface. Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check for the additional interface id that will be supported. For example: ```solidity function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); } ``` Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    IERC165Upgradeable :
    Interface of the ERC165 standard, as defined in the https://eips.ethereum.org/EIPS/eip-165[EIP]. Implementers can declare support of contract interfaces, which can then be queried by others ({ERC165Checker}). For an implementation, see {ERC165}.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    Ownable :
    Contract module which provides a basic access control mechanism, where there is an account (an owner) that can be granted exclusive access to specific functions. By default, the owner account will be the one that deploys the contract. This can later be changed with {transferOwnership}. This module is used through inheritance. It will make available the modifier `onlyOwner`, which can be applied to your functions to restrict their use to the owner.
    constructor :
    Initializes the contract setting the deployer as the initial owner.
    owner() :
    Returns the address of the current owner.
    renounceOwnership() :
    Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.
    transferOwnership(address) :
    Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.
    Pausable :
    Contract module which allows children to implement an emergency stop mechanism that can be triggered by an authorized account. This module is used through inheritance. It will make available the modifiers `whenNotPaused` and `whenPaused`, which can be applied to the functions of your contract. Note that they will not be pausable by simply including this module, only once the modifiers are put in place.
    constructor :
    Initializes the contract in unpaused state.
    paused() :
    Returns true if the contract is paused, and false otherwise.
    ReentrancyGuard :
    Contract module that helps prevent reentrant calls to a function. Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier available, which can be applied to functions to make sure there are no nested (reentrant) calls to them. Note that because there is a single `nonReentrant` guard, functions marked as `nonReentrant` may not call one another. This can be worked around by making those functions `private`, and then adding `external` `nonReentrant` entry points to them. TIP: If you would like to learn more about reentrancy and alternative ways to protect against it, check out our blog post https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
    ERC1155 :
    Implementation of the basic standard multi-token. See https://eips.ethereum.org/EIPS/eip-1155 Originally based on code by Enjin: https://github.com/enjin/erc-1155 _Available since v3.1._
    balanceOf(address,uint256) :
    See {IERC1155-balanceOf}. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    See {IERC1155-balanceOfBatch}. Requirements: - `accounts` and `ids` must have the same length.
    constructor :
    See {_setURI}.
    isApprovedForAll(address,address) :
    See {IERC1155-isApprovedForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    See {IERC1155-safeBatchTransferFrom}.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    See {IERC1155-safeTransferFrom}.
    setApprovalForAll(address,bool) :
    See {IERC1155-setApprovalForAll}.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    uri(uint256) :
    See {IERC1155MetadataURI-uri}. This implementation returns the same URI for *all* token types. It relies on the token type ID substitution mechanism https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. Clients calling this function must replace the `\{id\}` substring with the actual token type ID.
    IERC1155 :
    Required interface of an ERC1155 compliant contract, as defined in the https://eips.ethereum.org/EIPS/eip-1155[EIP]. _Available since v3.1._
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IERC1155Receiver :
    _Available since v3.1._
    onERC1155BatchReceived(address,address,uint256[],uint256[],bytes) :
    Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a `safeBatchTransferFrom` after the balances have been updated. NOTE: To accept the transfer(s), this must return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81, or its own function selector).
    onERC1155Received(address,address,uint256,uint256,bytes) :
    Handles the receipt of a single ERC1155 token type. This function is called at the end of a `safeTransferFrom` after the balance has been updated. NOTE: To accept the transfer, this must return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61, or its own function selector).
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IERC1155MetadataURI :
    Interface of the optional ERC1155MetadataExtension interface, as defined in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP]. _Available since v3.1._
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    uri(uint256) :
    Returns the URI for token type `id`. If the `\{id\}` substring is present in the URI, it must be replaced by clients with the actual token type ID.
    ERC20 :
    Implementation of the {IERC20} interface. This implementation is agnostic to the way tokens are created. This means that a supply mechanism has to be added in a derived contract using {_mint}. For a generic mechanism see {ERC20PresetMinterPauser}. TIP: For a detailed writeup see our guide https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How to implement supply mechanisms]. The default value of {decimals} is 18. To change this, you should override this function so it returns a different value. We have followed general OpenZeppelin Contracts guidelines: functions revert instead returning `false` on failure. This behavior is nonetheless conventional and does not conflict with the expectations of ERC20 applications. Additionally, an {Approval} event is emitted on calls to {transferFrom}. This allows applications to reconstruct the allowance for all accounts just by listening to said events. Other implementations of the EIP may not emit these events, as it isn't required by the specification. Finally, the non-standard {decreaseAllowance} and {increaseAllowance} functions have been added to mitigate the well-known issues around setting allowances. See {IERC20-approve}.
    allowance(address,address) :
    See {IERC20-allowance}.
    approve(address,uint256) :
    See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.
    balanceOf(address) :
    See {IERC20-balanceOf}.
    constructor :
    Sets the values for {name} and {symbol}. All two of these values are immutable: they can only be set once during construction.
    decimals() :
    Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.
    decreaseAllowance(address,uint256) :
    Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.
    increaseAllowance(address,uint256) :
    Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token, usually a shorter version of the name.
    totalSupply() :
    See {IERC20-totalSupply}.
    transfer(address,uint256) :
    See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.
    transferFrom(address,address,uint256) :
    See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.
    IERC20 :
    Interface of the ERC20 standard as defined in the EIP.
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    ERC20Capped :
    Extension of {ERC20} that adds a cap to the supply of tokens.
    allowance(address,address) :
    See {IERC20-allowance}.
    approve(address,uint256) :
    See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.
    balanceOf(address) :
    See {IERC20-balanceOf}.
    cap() :
    Returns the cap on the token's total supply.
    constructor :
    Sets the value of the `cap`. This value is immutable, it can only be set once during construction.
    decimals() :
    Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.
    decreaseAllowance(address,uint256) :
    Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.
    increaseAllowance(address,uint256) :
    Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token, usually a shorter version of the name.
    totalSupply() :
    See {IERC20-totalSupply}.
    transfer(address,uint256) :
    See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.
    transferFrom(address,address,uint256) :
    See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.
    IERC20Metadata :
    Interface for the optional metadata functions from the ERC20 standard. _Available since v4.1._
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    decimals() :
    Returns the decimals places of the token.
    name() :
    Returns the name of the token.
    symbol() :
    Returns the symbol of the token.
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    IERC20Permit :
    Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't need to send a transaction, and thus is not required to hold Ether at all.
    DOMAIN_SEPARATOR() :
    Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
    nonces(address) :
    Returns the current nonce for `owner`. This value must be included whenever a signature is generated for {permit}. Every successful call to {permit} increases ``owner``'s nonce by one. This prevents a signature from being used multiple times.
    permit(address,address,uint256,uint256,uint8,bytes32,bytes32) :
    Sets `value` as the allowance of `spender` over ``owner``'s tokens, given ``owner``'s signed approval. IMPORTANT: The same issues {IERC20-approve} has related to transaction ordering also apply here. Emits an {Approval} event. Requirements: - `spender` cannot be the zero address. - `deadline` must be a timestamp in the future. - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` over the EIP712-formatted function arguments. - the signature must use ``owner``'s current nonce (see {nonces}). For more information on the signature format, see the https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP section].
    SafeERC20 :
    Wrappers around ERC20 operations that throw on failure (when the token contract returns false). Tokens that return no value (and instead revert or throw on failure) are also supported, non-reverting calls are assumed to be successful. To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
    ERC721 :
    Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including the Metadata extension, but not including the Enumerable extension, which is available separately as {ERC721Enumerable}.
    approve(address,uint256) :
    See {IERC721-approve}.
    balanceOf(address) :
    See {IERC721-balanceOf}.
    constructor :
    Initializes the contract by setting a `name` and a `symbol` to the token collection.
    getApproved(uint256) :
    See {IERC721-getApproved}.
    isApprovedForAll(address,address) :
    See {IERC721-isApprovedForAll}.
    name() :
    See {IERC721Metadata-name}.
    ownerOf(uint256) :
    See {IERC721-ownerOf}.
    safeTransferFrom(address,address,uint256) :
    See {IERC721-safeTransferFrom}.
    safeTransferFrom(address,address,uint256,bytes) :
    See {IERC721-safeTransferFrom}.
    setApprovalForAll(address,bool) :
    See {IERC721-setApprovalForAll}.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    symbol() :
    See {IERC721Metadata-symbol}.
    tokenURI(uint256) :
    See {IERC721Metadata-tokenURI}.
    transferFrom(address,address,uint256) :
    See {IERC721-transferFrom}.
    IERC721 :
    Required interface of an ERC721 compliant contract.
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IERC721Receiver :
    Interface for any contract that wants to support safeTransfers from ERC721 asset contracts.
    onERC721Received(address,address,uint256,bytes) :
    Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} by `operator` from `from`, this function is called. It must return its Solidity selector to confirm the token transfer. If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
    IERC721Metadata :
    See https://eips.ethereum.org/EIPS/eip-721
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    name() :
    Returns the token collection name.
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    symbol() :
    Returns the token collection symbol.
    tokenURI(uint256) :
    Returns the Uniform Resource Identifier (URI) for `tokenId` token.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    Address :
    Collection of functions related to the address type
    Context :
    Provides information about the current execution context, including the sender of the transaction and its data. While these are generally available via msg.sender and msg.data, they should not be accessed in such a direct manner, since when dealing with meta-transactions the account sending and paying for execution may not be the actual sender (as far as an application is concerned). This contract is only required for intermediate, library-like contracts.
    Strings :
    String operations.
    ERC165 :
    Implementation of the {IERC165} interface. Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check for the additional interface id that will be supported. For example: ```solidity function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); } ``` Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
    supportsInterface(bytes4) :
    See {IERC165-supportsInterface}.
    ERC165Checker :
    Library used to query support of an interface declared via {IERC165}. Note that these functions return the actual result of the query: they do not `revert` if an interface is not supported. It is up to the caller to decide what to do in these cases.
    IERC165 :
    Interface of the ERC165 standard, as defined in the https://eips.ethereum.org/EIPS/eip-165[EIP]. Implementers can declare support of contract interfaces, which can then be queried by others ({ERC165Checker}). For an implementation, see {ERC165}.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    Math :
    Standard math utilities missing in the Solidity language.
    SafeMath :
    Wrappers over Solidity's arithmetic operations. NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler now has built in overflow checking.
    SignedMath :
    Standard signed math utilities missing in the Solidity language.
    IOFTCoreUpgradeable :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    IOFTUpgradeable :
    Interface of the OFT standard
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    IONFT1155CoreUpgradeable :
    Interface of the ONFT Core standard
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT1155Upgradeable :
    Interface of the ONFT standard
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT721CoreUpgradeable :
    Interface of the ONFT Core Upgradeable standard
    estimateSendBatchFee(uint16,bytes,uint256[],bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenIds[] - token Ids to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenId - token Id to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    sendBatchFrom(address,uint16,bytes,uint256[],address,address,bytes) :
    send tokens `_tokenIds[]` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send token `_tokenId` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT721Upgradeable :
    Interface of the ONFT Upgradeable standard
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    estimateSendBatchFee(uint16,bytes,uint256[],bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenIds[] - token Ids to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenId - token Id to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    sendBatchFrom(address,uint16,bytes,uint256[],address,address,bytes) :
    send tokens `_tokenIds[]` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send token `_tokenId` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IOFT :
    Interface of the OFT standard
    allowance(address,address) :
    Returns the remaining number of tokens that `spender` will be allowed to spend on behalf of `owner` through {transferFrom}. This is zero by default. This value changes when {approve} or {transferFrom} are called.
    approve(address,uint256) :
    Sets `amount` as the allowance of `spender` over the caller's tokens. Returns a boolean value indicating whether the operation succeeded. IMPORTANT: Beware that changing an allowance with this method brings the risk that someone may use both the old and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 Emits an {Approval} event.
    balanceOf(address) :
    Returns the amount of tokens owned by `account`.
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    totalSupply() :
    Returns the amount of tokens in existence.
    transfer(address,uint256) :
    Moves `amount` tokens from the caller's account to `to`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    transferFrom(address,address,uint256) :
    Moves `amount` tokens from `from` to `to` using the allowance mechanism. `amount` is then deducted from the caller's allowance. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.
    IOFTCore :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    GlobalCappedOFT :
    Extension of {OFT} that adds a global cap to the supply of tokens across all chains.
    allowance(address,address) :
    See {IERC20-allowance}.
    approve(address,uint256) :
    See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.
    balanceOf(address) :
    See {IERC20-balanceOf}.
    cap() :
    Returns the cap on the token's total supply.
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    decimals() :
    Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.
    decreaseAllowance(address,uint256) :
    Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    increaseAllowance(address,uint256) :
    Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.
    name() :
    Returns the name of the token.
    owner() :
    Returns the address of the current owner.
    renounceOwnership() :
    Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    symbol() :
    Returns the symbol of the token, usually a shorter version of the name.
    token() :
    returns the address of the ERC20 token
    totalSupply() :
    See {IERC20-totalSupply}.
    transfer(address,uint256) :
    See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.
    transferFrom(address,address,uint256) :
    See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.
    transferOwnership(address) :
    Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.
    ICommonOFT :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes32,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    IOFTV2 :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes32,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes32,uint256,(address,address,bytes)) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    IOFTWithFee :
    Interface of the IOFT core standard
    circulatingSupply() :
    returns the circulating amount of tokens on current chain
    estimateSendFee(uint16,bytes32,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _amount - amount of the tokens to transfer _useZro - indicates to use zro to pay L0 fees _adapterParam - flexible bytes array to indicate messaging adapter services in L0
    sendFrom(address,uint16,bytes32,uint256,uint256,(address,address,bytes)) :
    send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from` `_from` the owner of token `_dstChainId` the destination chain identifier `_toAddress` can be any size depending on the `dstChainId`. `_amount` the quantity of tokens in wei `_minAmount` the minimum amount of tokens to receive on dstChain `_refundAddress` the address LayerZero refunds if too much message fee is sent `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    token() :
    returns the address of the ERC20 token
    IONFT1155 :
    Interface of the ONFT standard
    balanceOf(address,uint256) :
    Returns the amount of tokens of token type `id` owned by `account`. Requirements: - `account` cannot be the zero address.
    balanceOfBatch(address[],uint256[]) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. Requirements: - `accounts` and `ids` must have the same length.
    isApprovedForAll(address,address) :
    Returns true if `operator` is approved to transfer ``account``'s tokens. See {setApprovalForAll}.
    safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) :
    xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. Emits a {TransferBatch} event. Requirements: - `ids` and `amounts` must have the same length. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
    safeTransferFrom(address,address,uint256,uint256,bytes) :
    Transfers `amount` tokens of token type `id` from `from` to `to`. Emits a {TransferSingle} event. Requirements: - `to` cannot be the zero address. - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. - `from` must have a balance of tokens of type `id` of at least `amount`. - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value.
    setApprovalForAll(address,bool) :
    Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, Emits an {ApprovalForAll} event. Requirements: - `operator` cannot be the caller.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT1155Core :
    Interface of the ONFT Core standard
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    IONFT721 :
    Interface of the ONFT standard
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in ``owner``'s account.
    estimateSendBatchFee(uint16,bytes,uint256[],bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenIds[] - token Ids to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenId - token Id to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    sendBatchFrom(address,uint16,bytes,uint256[],address,address,bytes) :
    send tokens `_tokenIds[]` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send token `_tokenId` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` token from `from` to `to`. WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a reentrancy vulnerability. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IONFT721Core :
    Interface of the ONFT Core standard
    estimateSendBatchFee(uint16,bytes,uint256[],bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenIds[] - token Ids to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    estimateSendFee(uint16,bytes,uint256,bool,bytes) :
    estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`) _dstChainId - L0 defined chain id to send tokens too _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain _tokenId - token Id to transfer _useZro - indicates to use zro to pay L0 fees _adapterParams - flexible bytes array to indicate messaging adapter services in L0
    sendBatchFrom(address,uint16,bytes,uint256[],address,address,bytes) :
    send tokens `_tokenIds[]` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    sendFrom(address,uint16,bytes,uint256,address,address,bytes) :
    send token `_tokenId` to (`_dstChainId`, `_toAddress`) from `_from` `_toAddress` can be any size depending on the `dstChainId`. `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token) `_adapterParams` is a flexible bytes array to indicate messaging adapter services
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] to learn more about how these ids are created. This function call must use less than 30 000 gas.
    ERC721A :
    Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721) Non-Fungible Token Standard, including the Metadata extension. Optimized for lower gas during batch mints. Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...) starting from `_startTokenId()`. Assumptions: - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply. - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in `owner`'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}.
    name() :
    Returns the token collection name.
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified) to learn more about how these ids are created. This function call must use less than 30000 gas.
    symbol() :
    Returns the token collection symbol.
    tokenURI(uint256) :
    Returns the Uniform Resource Identifier (URI) for `tokenId` token.
    totalSupply() :
    Returns the total number of tokens in existence. Burned tokens will reduce the count. To get the total number of tokens minted, please see {_totalMinted}.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` from `from` to `to`. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    IERC721A :
    Interface of ERC721A.
    approve(address,uint256) :
    Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred. Only a single account can be approved at a time, so approving the zero address clears previous approvals. Requirements: - The caller must own the token or be an approved operator. - `tokenId` must exist. Emits an {Approval} event.
    balanceOf(address) :
    Returns the number of tokens in `owner`'s account.
    getApproved(uint256) :
    Returns the account approved for `tokenId` token. Requirements: - `tokenId` must exist.
    isApprovedForAll(address,address) :
    Returns if the `operator` is allowed to manage all of the assets of `owner`. See {setApprovalForAll}.
    name() :
    Returns the token collection name.
    ownerOf(uint256) :
    Returns the owner of the `tokenId` token. Requirements: - `tokenId` must exist.
    safeTransferFrom(address,address,uint256) :
    Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
    safeTransferFrom(address,address,uint256,bytes) :
    Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients are aware of the ERC721 protocol to prevent tokens from being forever locked. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must exist and be owned by `from`. - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. Emits a {Transfer} event.
    setApprovalForAll(address,bool) :
    Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. Requirements: - The `operator` cannot be the caller. Emits an {ApprovalForAll} event.
    supportsInterface(bytes4) :
    Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified) to learn more about how these ids are created. This function call must use less than 30000 gas.
    symbol() :
    Returns the token collection symbol.
    tokenURI(uint256) :
    Returns the Uniform Resource Identifier (URI) for `tokenId` token.
    totalSupply() :
    Returns the total number of tokens in existence. Burned tokens will reduce the count. To get the total number of tokens minted, please see {_totalMinted}.
    transferFrom(address,address,uint256) :
    Transfers `tokenId` from `from` to `to`. WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requirements: - `from` cannot be the zero address. - `to` cannot be the zero address. - `tokenId` token must be owned by `from`. - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. Emits a {Transfer} event.
    OwnableUpgradeable.sol
    Initializable.sol
    ReentrancyGuardUpgradeable.sol
    ERC1155Upgradeable.sol
    IERC1155ReceiverUpgradeable.sol
    IERC1155Upgradeable.sol
    IERC1155MetadataURIUpgradeable.sol
    ERC20Upgradeable.sol
    IERC20Upgradeable.sol
    IERC20MetadataUpgradeable.sol
    ERC721Upgradeable.sol
    IERC721ReceiverUpgradeable.sol
    IERC721Upgradeable.sol
    IERC721MetadataUpgradeable.sol
    AddressUpgradeable.sol
    ContextUpgradeable.sol
    StringsUpgradeable.sol
    ERC165Upgradeable.sol
    IERC165Upgradeable.sol
    Ownable.sol
    Pausable.sol
    ReentrancyGuard.sol
    ERC1155.sol
    IERC1155.sol
    IERC1155Receiver.sol
    IERC1155MetadataURI.sol
    ERC20.sol
    IERC20.sol
    ERC20Capped.sol
    IERC20Metadata.sol
    IERC20Permit.sol
    SafeERC20.sol
    ERC721.sol
    IERC721.sol
    IERC721Receiver.sol
    IERC721Metadata.sol
    Address.sol
    Context.sol
    Strings.sol
    ERC165.sol
    ERC165Checker.sol
    IERC165.sol
    Math.sol
    SafeMath.sol
    SignedMath.sol
    IUniswapV2Router01.sol
    IUniswapV2Router02.sol
    StargateComposed.sol
    ExampleOFTUpgradeable.sol
    ExampleONFT1155Upgradeable.sol
    ExampleONFT721Upgradeable.sol
    ILayerZeroEndpointUpgradeable.sol
    ILayerZeroReceiverUpgradeable.sol
    ILayerZeroUserApplicationConfigUpgradeable.sol
    LzAppUpgradeable.sol
    NonblockingLzAppUpgradeable.sol
    IOFTCoreUpgradeable.sol
    IOFTUpgradeable.sol
    OFTCoreUpgradeable.sol
    OFTUpgradeable.sol
    IONFT1155CoreUpgradeable.sol
    IONFT1155Upgradeable.sol
    ONFT1155CoreUpgradeable.sol
    ONFT1155Upgradable.sol
    IONFT721CoreUpgradeable.sol
    IONFT721Upgradeable.sol
    ONFT721CoreUpgradeable.sol
    ONFT721Upgradeable.sol
    ExampleBasedOFT20.sol
    ExampleOFT.sol
    ExampleOFTV2.sol
    ExampleUniversalONFT721.sol
    OmniCounter.sol
    PingPong.sol
    ILayerZeroEndpoint.sol
    ILayerZeroReceiver.sol
    ILayerZeroUserApplicationConfig.sol
    IStargateFactory.sol
    IStargatePool.sol
    IStargateReceiver.sol
    IStargateRouter.sol
    IStargateRouterETH.sol
    IStargateWidget.sol
    LzLib.sol
    LzApp.sol
    NonblockingLzApp.sol
    DistributeONFT721Mock.sol
    ERC1155Mock.sol
    ERC20Mock.sol
    ERC721Mock.sol
    LZEndpointMock.sol
    MockToken.sol
    OFTStakingMockV2.sol
    ONFT721AMock.sol
    ONFT721Mock.sol
    StargateSwap.sol
    IOFT.sol
    IOFTCore.sol
    OFT.sol
    OFTCore.sol
    BasedOFT.sol
    GlobalCappedOFT.sol
    NativeOFT.sol
    PausableOFT.sol
    ProxyOFT.sol
    BaseOFTV2.sol
    ICommonOFT.sol
    IOFTReceiverV2.sol
    IOFTV2.sol
    NativeOFTV2.sol
    OFTCoreV2.sol
    OFTV2.sol
    ProxyOFTV2.sol
    BaseOFTWithFee.sol
    Fee.sol
    IOFTWithFee.sol
    NativeOFTWithFee.sol
    OFTWithFee.sol
    ProxyOFTWithFee.sol
    IONFT1155.sol
    IONFT1155Core.sol
    IONFT721.sol
    IONFT721Core.sol
    ONFT1155.sol
    ONFT1155Core.sol
    ONFT721.sol
    ONFT721Core.sol
    DistributeONFT721.sol
    ONFT721A.sol
    ProxyONFT1155.sol
    ProxyONFT721.sol
    UniversalONFT721.sol
    BitLib.sol
    BytesLib.sol
    ExcessivelySafeCall.sol
    ERC721A.sol
    IERC721A.sol
    Proxied.sol
    WidgetSwap.sol

    Get Cookin'

    7 downloads

    Authors