Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import {Ownable} from "./Ownable.sol";
import {IERC20, SafeERC20} from "./SafeERC20.sol";
import {IERC721} from "./IERC721.sol";

contract TokenTransferProxy  is Ownable{
    using SafeERC20 for IERC20;

                        address public SocMetaMarket;
    address public SocMetaverse;

    function updateMarket(address exchange) public onlyOwner{
        require(exchange != address(0), "TokenTransferProxy: Exchange address invalid.");
        SocMetaMarket = exchange;
    }

    function updateMetaverse(address exchange) public onlyOwner{
        require(exchange != address(0), "TokenTransferProxy: Exchange address invalid.");
        SocMetaverse = exchange;
    }

    /**
     * @notice Transfer ERC721 token
     * @param collection address of the collection
     * @param from address of the sender
     * @param to address of the recipient
     * @param tokenId tokenId
     * @dev For ERC721, amount is not used
     */
    function transferERC721Token(
        address collection,
        address from,
        address to,
        uint256 tokenId
)  external {
        require(msg.sender == SocMetaMarket || msg.sender == SocMetaverse , "TokenTransferProxy: Only MasterNFT Exchange");
        // https://docs.openzeppelin.com/contracts/2.x/api/token/erc721#IERC721-safeTransferFrom
        require(from != address(0), "TokenTransferProxy: Invalid from");
        require(to != address(0), "TokenTransferProxy: Invalid to");
        require(IERC721(collection).ownerOf(tokenId) == from, "TokenTransferProxy: from is not the owner.");

        IERC721(collection).safeTransferFrom(from, to, tokenId);
    }

    /**
     * @dev Transfer tokens
     * @param token Token to transfer
     * @param from Address to charge fees
     * @param to Address to receive fees
     * @param amount Amount of protocol tokens to charge
     */
    function transferERC20Tokens(
        address token,
        address from,
        address to,
        uint256 amount
) external  {
        require(msg.sender == SocMetaMarket || msg.sender == SocMetaverse , "TokenTransferProxy: Only MasterNFT Exchange");
        require(from != address(0), "TokenTransferProxy: Invalid from");
        require(to != address(0), "TokenTransferProxy: Invalid to");
        require(amount <= IERC20(token).balanceOf(from), "TokenTransferProxy: have no enough balance");
        if (amount > 0) {
            IERC20(token).safeTransferFrom(from, to, amount);
        }
    }


}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev 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.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 *
 * _Available since v4.1._
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev 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}.
 */
interface IERC165 {
    /**
     * @dev 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.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev 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.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev 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.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` 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.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev 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.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
) external;

    /**
     * @dev 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.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
) external;

    /**
     * @dev 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.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev 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.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev 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.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
) external;
}

// SPDX-License-Identifier: GNU
pragma solidity >=0.5.0;

interface IWETH {
    function deposit() external payable;

    function transfer(address to, uint256 value) external returns (bool);

    function withdraw(uint256) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @dev 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.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev 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.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./Address.sol";

/**
 * @title SafeERC20
 * @dev 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.
 */
library SafeERC20 {
    using Address for address;

                      function safeTransfer(
                          IERC20 token,
                          address to,
            uint256 value
) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {Address} from "./Address.sol";
import {IERC1271} from "./IERC1271.sol";

/**
 * @title SignatureChecker
 * @notice This library allows verification of signatures for both EOAs and contracts.
 */
library SignatureChecker {
    /**
     * @notice Recovers the signer of a signature (for EOA)
     * @param hash the hash containing the signed mesage
     * @param v parameter (27 or 28). This prevents maleability since the public key recovery equation has two possible solutions.
     * @param r parameter
     * @param s parameter
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
) internal pure returns (address) {
        // https://ethereum.stackexchange.com/questions/83174/is-it-best-practice-to-check-signature-malleability-in-ecrecover
        // https://crypto.iacr.org/2019/affevents/wac/medias/Heninger-BiasedNonceSense.pdf
        require(
            uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
            "Signature: Invalid s parameter"
        );

        require(v == 27 || v == 28, "Signature: Invalid v parameter");

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0), "Signature: Invalid signer");

        return signer;
    }

    /**
     * @notice Returns whether the signer matches the signed message
     * @param hash the hash containing the signed mesage
     * @param signer the signer address to confirm message validity
     * @param v parameter (27 or 28)
     * @param r parameter
     * @param s parameter
     * @param domainSeparator paramer to prevent signature being executed in other chains and environments
     * @return true --> if valid // false --> if invalid
     */
    function verify(
        bytes32 hash,
        address signer,
        uint8 v,
        bytes32 r,
        bytes32 s,
        bytes32 domainSeparator
    ) internal view returns (bool) {
        // \x19\x01 is the standardized encoding prefix
        // https://eips.ethereum.org/EIPS/eip-712#specification
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, hash));
        if (Address.isContract(signer)) {
            // 0x1626ba7e is the interfaceId for signature contracts (see IERC1271)
            return IERC1271(signer).isValidSignature(digest, abi.encodePacked(r, s, v)) == 0x1626ba7e;
        } else {
            return recover(digest, v, r, s) == signer;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.1;

import {Ownable} from "./Ownable.sol";
import {IERC20, SafeERC20} from "./SafeERC20.sol";
import {IERC721} from "./IERC721.sol";
import {SignatureChecker} from "./SignatureChecker.sol";

interface TokenTransferManager {
    function transferERC721Token(address collection, address from, address to,uint256 tokenId) external;
    function transferERC20Tokens(address token, address from, address to, uint amount ) external;
}

contract SocMarket  is Ownable{
    using SafeERC20 for IERC20;

    // keccak256("SellOrder(uint8 saleKind,address maker,address collection,uint256 tokenId,address fToken,uint256 price,uint256 nonce,uint256 startTime,uint256 endTime)")
    bytes32 internal constant SELL_ORDER_HASH = 0x179868c752420cd3366071e2bfc82d70428afb225a818c94ae9a2acbb53c6a30;

    struct SellOrder {
        uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
        address maker; // maker of the sell order
        address collection; // collection address
        uint256 tokenId; // id of the token
        address fToken; // FungibleToke address, 0x : ETH
        uint256 price; // price (used as )
        uint256 nonce; // order nonce (must be unique unless new maker order is meant to override existing one e.g., lower ask price)
        uint256 startTime; // startTime in timestamp
        uint256 endTime; // endTime in timestamp
    }

    struct BuyOrder {
        uint8 saleKind; // 0: FungibleToken , 1: NonFungibleToken
        address maker; // maker of the buy order
        address collection; // collection address
        uint256 tokenId; // id of the token
        address fToken; // FungibleToke address, 0x : ETH
        uint256 price; // price (used as )
    }

    struct Sig {
        uint8 v; // v: parameter (27 or 28)
        bytes32 r; // r: parameter
        bytes32 s; // s: parameter
    }

    uint256 public maxFee = 10000; // 100%
    uint256 public protocolFee = 500; //2.5%

    mapping(address => uint256) public vipBalance;
    mapping(address => uint256) public addressMinNonce;
    /* Cancelled / finalized orders, by hash. */
    mapping(bytes32 => bool) internal cancelledOrFinalized;

    bytes32 public DOMAIN_SEPARATOR;
    address public protocolFeeRecipient;
    address public tokenTransferProxy;

    event OrderCancelled          (bytes32 indexed hash);

    /**
    * @notice Constructor
    * @param _protocolFeeRecipient protocol fee recipient
    */
    constructor(
        address _protocolFeeRecipient,
        address _tokenTransferProxy
    ) {
        // Calculate the domain separator
        //0xc778417e063141139fce010982780140aa0cd5ab, 0x30e3178f621f552707F5419569360ef17C39Af69
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f, // keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
                0x1c1b2235c991f3ce05809fcc1344ce9a62eed16b1318e97cbc80edf4de923088, // keccak256("SocMarket")
                0x4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45, // keccak256(bytes("1")) for versionId = 1
                block.chainid,
                address(this)
            )
        );

        protocolFeeRecipient = _protocolFeeRecipient;
        tokenTransferProxy = _tokenTransferProxy;
    }

    //sell nft or other token.
    function hash(SellOrder memory order) internal pure returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    SELL_ORDER_HASH,
                    order.saleKind,
                    order.maker,
                    order.collection,
                    order.tokenId,
                    order.fToken,
                    order.price,
                    order.nonce,
                    order.startTime,
                    order.endTime
                )
            );
    }

    function updateProtocolFeeRecipient(address _protocolFeeRecipient) public onlyOwner{
        require(_protocolFeeRecipient != address(0), "SocMarket: Invalid recipient.");
        protocolFeeRecipient = _protocolFeeRecipient;
    }

    function updateTokenTransferProxy(address _tokenTransferProxy) public onlyOwner{
        require(_tokenTransferProxy != address(0), "SocMarket: Invalid proxy.");
        tokenTransferProxy = _tokenTransferProxy;
    }

    function updateAddressMinNonce(uint256 nonce) public {
        require(addressMinNonce[msg.sender] < nonce, "SocMarket: nonce too small");
        addressMinNonce[msg.sender] = nonce;
    }

    /**
    * @notice Verify the validity of the maker order
    * @param sell maker order
    * @param orderHash computed hash for the order
    */
    function _validateOrder(
        SellOrder memory sell,
        bytes32 orderHash,
        Sig memory sig
    ) internal view {
        /* Order must have not been canceled or already filled. */
        require(
            cancelledOrFinalized[orderHash] != true,
            "Order: order was cancelled or finalized."
        );

        // Verify the maker is not address(0)
        require(sell.maker != address(0), "Order: Invalid signer");

        // Verify whether order nonce has expired
        require(
            sell.nonce >= addressMinNonce[sell.maker],
            "Order: Matching order expired"
        );


        // Verify the validity of the signature
        require(SignatureChecker.verify(
                orderHash,
                sell.maker,
                sig.v,
                sig.r,
                sig.s,
                DOMAIN_SEPARATOR
            ),
            "Order: Invalid signer");

    }

    /**
    * @notice Transfer ERC721 token
    * @param collection address of the collection
    * @param from address of the sender
    * @param to address of the recipient
    * @param tokenId tokenId
    * @dev For ERC721, amount is not used
    */
    function transferERC721Token(
        address collection,
        address from,
        address to,
        uint256 tokenId
    ) internal {
        require(from != address(0), "SocMarket: Invalid from");
        require(to != address(0), "SocMarket: Invalid to");

        TokenTransferManager(tokenTransferProxy).transferERC721Token(collection, from, to, tokenId);
    }

    /**
    * @dev Transfer tokens
    * @param token Token to transfer
    * @param from Address to charge fees
    * @param to Address to receive fees
    * @param amount Amount of protocol tokens to charge
    */
    function transferERC20Tokens(
        address token,
        address from,
        address to,
        uint amount
    ) internal {
        require(from != address(0), "SocMarket: Invalid from");
        require(to != address(0), "SocMarket: Invalid to");
        if (from == address(this)){
            IERC20(token).transfer(to, amount);
        }else {
            TokenTransferManager(tokenTransferProxy).transferERC20Tokens(token, from, to, amount);
        }
    }

    /**
    * @notice Check whether a taker bid order can be executed against a maker ask
    * @param buy taker bid order
    * @param sell maker ask order
    */
    function _orderMatch(
        BuyOrder memory buy,
        SellOrder memory sell
    ) internal view {
        require(
            ((sell.fToken == buy.fToken) &&
                (sell.price == buy.price) &&
                (sell.collection == buy.collection) &&
                (sell.tokenId == buy.tokenId) &&
                (sell.saleKind != buy.saleKind) &&
                (sell.startTime <= block.timestamp) &&
                (sell.endTime >= block.timestamp)
            ), "SocMarket: buy and sell does not match."
        );
    }

    /**
    * Call atomicMatch_ to exchange NFT with Token
    */
    function atomicMatch_(
        address[6] memory addrs,
        uint8[2] memory saleKinds,
        uint256[4] memory tokenAndPrice,
        uint256[3] memory nonceAndTimes,
        uint8 v,
        bytes32[2] memory rss
    ) public {
        require(msg.sender == addrs[3], "SocMarket: buy.maker not equal to msg.sender");
        return atomicMatch(
            //kind, maker,collection,tokenid,ftoken,price,nonce, startTime,endTime
            SellOrder(saleKinds[0],addrs[0],addrs[1],tokenAndPrice[0],addrs[2],tokenAndPrice[1],nonceAndTimes[0],nonceAndTimes[1],nonceAndTimes[2]),
            // v, r, s
            Sig(v, rss[0], rss[1]),
            //kind, maker,collection,tokenid,ftoken,price
            BuyOrder(saleKinds[1],addrs[3],addrs[4],tokenAndPrice[2],addrs[5],tokenAndPrice[3])
        );
    }

    //msg.sender always equals to buy.taker
    function atomicMatch(
        SellOrder memory sell,
        Sig memory sellSig,
        BuyOrder memory buy
    ) internal {
        require(
            //Only ERC20 token
            (msg.value == 0 && sell.fToken != address(0)),
            "Order: Invalid msg.value or token Type."
        );

        bytes32 _orderHash = hash(sell);
        _orderMatch(buy, sell);
        _validateOrder(sell, _orderHash, sellSig);

        //default sellOrder maker is NFT owner
        address nftOwner = sell.maker;
        address ftOwner = buy.maker;

        //sellOrder maker is FungibleToken owner
        if(sell.saleKind == 0 && buy.saleKind == 1){
            nftOwner = buy.maker;
            ftOwner = sell.maker;
        }

        uint256 protocolFeeAmount = sell.price * protocolFee / maxFee;
        uint256 sellAmount = sell.price  - protocolFeeAmount;

        // PART1.2.2: Transfer ERC20 Token
        if(sell.fToken != address(0)){
            //Transfer sellAmount to nftOwner
            transferERC20Tokens(sell.fToken, ftOwner ,nftOwner, sellAmount);

            //Transfer protocol FEE
            transferERC20Tokens(sell.fToken, ftOwner, protocolFeeRecipient, protocolFeeAmount);

            // PART2: Transfer NFT
            transferERC721Token(sell.collection, nftOwner, ftOwner, sell.tokenId);
        }

        cancelledOrFinalized[_orderHash] = true;
    }

    function cancelOrder_(
        uint8 saleKind,
        address maker,
        address collection,
        uint256 tokenId,
        address ftoken,
        uint256 price,
        uint256 nonce,
        uint256 startTime,
        uint256 endTime
    ) public {
        cancelOrder(SellOrder(saleKind,maker,collection,tokenId,ftoken,price,nonce, startTime,endTime));
    }

    function cancelOrder(SellOrder memory order)
        internal
    {
        /* Assert sender is authorized to cancel order. */
        require(msg.sender == order.maker);

        /* Calculate order hash. */
        bytes32 _orderHash = hash(order);

        /* Mark order as cancelled, preventing it from being matched. */
        cancelledOrFinalized[_orderHash] = true;

        /* Log cancel event. */
        emit OrderCancelled(_orderHash);
    }
}

/**
 *Submitted for verification at Etherscan.io on 2021-10-28
 */

/**
 *Submitted for verification at Etherscan.io on 2021-08-27
 */

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev 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}.
 */
interface IERC165 {
    /**
     * @dev 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.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}



/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev 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.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
) external;

    /**
     * @dev 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.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
) external;

    /**
     * @dev 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.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev 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.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev 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.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
) external;
}


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}




/*
 * @dev 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.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


/**
 * @dev 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.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev 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.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}





/**
 * @dev 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].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}














/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev 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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
) external returns (bytes4);
}







/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}





/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}



/**
 * @dev 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.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


/**
 * @dev 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}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
                      using Strings for uint256;

            // Token name
                                        string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;


    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    // Base URI
    string private _baseURI;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    // function withdraw() public onlyOwner {
    //     uint balance = address(this).balance;
    //     msg.sender.transfer(balance);
    // }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
        interfaceId == type(IERC721).interfaceId ||
        interfaceId == type(IERC721Metadata).interfaceId ||
        super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory base = baseURI();
        return bytes(base).length > 0 ? string(abi.encodePacked(base, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function baseURI() internal view virtual returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev 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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        //return _tokenOwners.contains(tokenId);
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;
        //_tokenOwners.set(tokenId, to);
        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];
        //_tokenOwners.remove(tokenId);

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;
        //_tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver(to).onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
) internal virtual {}
}

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}


/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _allTokens.length;
    }

    function tokenByAddr() public view virtual returns (uint256) {
        uint256 length = ERC721.balanceOf(msg.sender) - 1;
        return _ownedTokens[msg.sender][length];
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

interface TokenTransferManager {
    function transferERC721Token(address collection, address from, address to,uint256 tokenId) external;
    function transferERC20Tokens(address token, address from, address to, uint amount ) external;
}

contract SocMetaverse is ERC721Enumerable, ReentrancyGuard, Ownable, IERC721Receiver {

    bytes32 public DOMAIN_SEPARATOR;
    uint256 public mintedCount = 0;
    uint256 public minted3SCount = 0;

    uint256 public MAX_CUPCAT = 2623;
    uint256 public S3_PLAYER_MAX_CUPCAT = 200;
    uint256 public S3_PLAYER_MAX_MINTED = 3;


    address public cSigner;
    address public cupcatMananger;

    address public tokenTransferProxy;
    address public payToken;
    address public buyBackAddress;
    address public rewardAddress;

    mapping(bytes32 => bool) internal _rewardMap;
    mapping(uint256 => address) public stakeMap;
    mapping(address => uint256[]) public stakeList;
    mapping(address => uint256) public S3_mintedCount;

    uint256[] public S3_PLAYER;
    uint256[] public S2_PLAYER;

    event Reward(address indexed to, uint256 indexed price,  uint256 indexed tokenId, uint256 roundId);

    function setManager(address newCM) public onlyOwner{
        require(newCM != address(0), "SocMetaverse: Invalid newCM.");
        cupcatMananger = newCM;
    }

    function addCupcat(uint256 cupcat) public {
        require(msg.sender == cupcatMananger, "SocMetaverse: Invalid cupcatMananger.");
        require(cupcat > MAX_CUPCAT, "SocMetaverse: Invalid newCM.");
        MAX_CUPCAT = cupcat;
    }

    function setPayToken(address _soc) public  onlyOwner{
        require(_soc != address(0), "SocMetaverse: Invalid _soc.");
        payToken = _soc;
    }

    function setBuyBackAddress(address _buyBackAddress) public onlyOwner{
        require(_buyBackAddress != address(0), "SocMetaverse: Invalid _buyBackAddress.");
        buyBackAddress = _buyBackAddress;
    }

    function setRewardAddress(address _reward) public onlyOwner{
        require(_reward != address(0), "SocMetaverse: Invalid _reward.");
        rewardAddress = _reward;
    }

    function updateTokenTransferProxy(address _tokenTransferProxy) public onlyOwner{
        require(_tokenTransferProxy != address(0), "SocMetaverse: Invalid proxy.");
        tokenTransferProxy = _tokenTransferProxy;
    }


    function claim(uint256 startId, uint256 count, uint256 price, uint256 ptype, uint8 v, bytes32 r, bytes32 s) public {
        require(mintedCount + count <= MAX_CUPCAT, "SocMetaverse: Exceed max supply.");
        require(checkSigner(startId,count,price,ptype,v,r,s), "SocMetaverse: Invalid signer.");

        if(ptype == 1){
            require(minted3SCount + count <= S3_PLAYER_MAX_CUPCAT, "SocMetaverse: Exceed max supply.");
            require(S3_mintedCount[msg.sender] + count <= S3_PLAYER_MAX_MINTED, "SocMetaverse: Exceed max supply.");
            minted3SCount += count;
            S3_mintedCount[msg.sender] += count;

        }

        TokenTransferManager(tokenTransferProxy).transferERC20Tokens(payToken, msg.sender, buyBackAddress, price * 8/10);
        TokenTransferManager(tokenTransferProxy).transferERC20Tokens(payToken, msg.sender, rewardAddress, price * 2/10);

        for(uint i=0; i < count; i++){
            _safeMint(msg.sender, startId+i);
            if(ptype == 1){
                S3_PLAYER.push(startId+i);
            }else{
                S2_PLAYER.push(startId+i);
            }
            mintedCount++;
        }
    }

    function buyBack(uint256 tokenId, uint256 price, uint8 v, bytes32 r, bytes32 s) public returns (bool){
        require(ownerOf(tokenId) == msg.sender, "SocMetaverse: msg.sender invalid.");
        require(checkSigner(tokenId,1,price,0,v,r,s), "SocMetaverse: Invalid signer.");

        TokenTransferManager(tokenTransferProxy).transferERC721Token(address(this), msg.sender, buyBackAddress, tokenId);
        TokenTransferManager(tokenTransferProxy).transferERC20Tokens(payToken, buyBackAddress, msg.sender, price);
        return true;
    }

    //stake reward
    function reward(uint256 tokenId, uint256 roundId, uint256 amount, uint8 v, bytes32 r, bytes32 s) public {
        require(stakeMap[tokenId] == msg.sender, "SocMetaverse: Invalid tokenId.");
        require(checkSigner(tokenId,roundId,amount,0,v,r,s), "SocMetaverse: Invalid signer.");

        bytes32 hash = keccak256(abi.encode(msg.sender, tokenId, roundId, amount, v, r, s));
        require(!_rewardMap[hash], "SocMetaverse: Invalid reward.");
        _rewardMap[hash] = true;
        TokenTransferManager(tokenTransferProxy).transferERC20Tokens(payToken, rewardAddress, msg.sender, amount);
        emit Reward(msg.sender, amount, tokenId, roundId);
    }

    function checkSigner(uint256 u1, uint256 u2, uint256 u3, uint256 u4, uint8 v, bytes32 r, bytes32 s)internal view returns (bool){
        bytes32 digest = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
            keccak256(abi.encode(DOMAIN_SEPARATOR, msg.sender, u1, u2, u3, u4)))
        );
        address signer = ecrecover(digest, v, r, s);
        return signer == cSigner;
    }

    function stakeToken(uint256 tokenId) public {
        require(ownerOf(tokenId) == msg.sender, "SocMetaverse: msg.sender invalid.");
        _safeTransfer(msg.sender, address(this), tokenId, "");

        stakeMap[tokenId] = msg.sender;
        stakeList[msg.sender].push(tokenId);
    }

    function unstakeToken(uint256 tokenId) public {
        require(stakeMap[tokenId] == msg.sender, "SocMetaverse: msg.sender invalid.");
        _safeTransfer(address(this), msg.sender, tokenId, "");

        for(uint i=0; i<stakeList[msg.sender].length; i++){
            uint256 _tokenId = stakeList[msg.sender][i];
            if(_tokenId == tokenId){
                delete stakeList[msg.sender][i];
                break;

            }
        }
        delete stakeMap[tokenId];
    }

    function rewardAndUnstake(uint256 tokenId, uint256 roundId, uint256 amount, uint8 v, bytes32 r, bytes32 s) public {
        reward(tokenId, roundId, amount, v, r, s);
        unstakeToken(tokenId);
    }

    function getStakeList(address _addr) public view returns(uint256[] memory){
        return stakeList[_addr];
    }

    function getS3Players() public view returns(uint256[] memory){
        return S3_PLAYER;
    }

    function getS2Players() public view returns(uint256[] memory){
        return S2_PLAYER;
    }

    function setBaseURI(string memory baseURI) public onlyOwner {
        _setBaseURI(baseURI);
    }

    function onERC721Received( address , address , uint256 , bytes calldata) public override pure returns (bytes4) {
        return this.onERC721Received.selector;
    }

    constructor(address _signer, address _tokenTransferProxy, address _buyBackAddress, address _rewardAddress, address _soc) ERC721("SocMetaverse", "SocMeta") {
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f, // keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
                0x684490a1e8535a446249747cd25a5692377ddfbc9e6f986d84c52267c30ca878, // keccak256("SocMetaverse")
                0xe6bbd6277e1bf288eed5e8d1780f9a50b239e86b153736bceebccf4ea79d90b3, // keccak256(1.0) for versionId = 1.0
                block.chainid,
                address(this)
            )
        );
        cSigner = _signer;
        tokenTransferProxy = _tokenTransferProxy;
        buyBackAddress = _buyBackAddress;
        rewardAddress = _rewardAddress;
        payToken = _soc;

    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"SocMetaMarket","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SocMetaverse","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferERC20Tokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"collection","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferERC721Token","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"exchange","type":"address"}],"name":"updateMarket","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"exchange","type":"address"}],"name":"updateMetaverse","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

188:2332:12:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;547:189;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;320:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1911:605;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;286:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1662:101:7;;;:::i;:::-;;354:187:12;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1030:85:7;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1002:681:12;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1912:198:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;547:189:12;1253:12:7;:10;:12::i;:::-;1242:23;;:7;:5;:7::i;:::-;:23;;;1234:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;644:1:12::1;624:22;;:8;:22;;;;616:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;721:8;706:12;;:23;;;;;;;;;;;;;;;;;;547:189:::0;:::o;320:27::-;;;;;;;;;;;;;:::o;1911:605::-;2073:13;;;;;;;;;;;2059:27;;:10;:27;;;:57;;;;2104:12;;;;;;;;;;;2090:26;;:10;:26;;;2059:57;2051:114;;;;;;;;;;;;:::i;:::-;;;;;;;;;2199:1;2183:18;;:4;:18;;;;2175:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;2270:1;2256:16;;:2;:16;;;;2248:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;2342:5;2335:23;;;2359:4;2335:29;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2325:6;:39;;2317:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;2434:1;2425:6;:10;2421:89;;;2451:48;2482:4;2488:2;2492:6;2458:5;2451:30;;;;:48;;;;;;:::i;:::-;2421:89;1911:605;;;;:::o;286:28::-;;;;;;;;;;;;;:::o;1662:101:7:-;1253:12;:10;:12::i;:::-;1242:23;;:7;:5;:7::i;:::-;:23;;;1234:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1726:30:::1;1753:1;1726:18;:30::i;:::-;1662:101::o:0;354:187:12:-;1253:12:7;:10;:12::i;:::-;1242:23;;:7;:5;:7::i;:::-;:23;;;1234:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;448:1:12::1;428:22;;:8;:22;;;;420:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;526:8;510:13;;:24;;;;;;;;;;;;;;;;;;354:187:::0;:::o;1030:85:7:-;1076:7;1102:6;;;;;;;;;;;1095:13;;1030:85;:::o;1002:681:12:-;1170:13;;;;;;;;;;;1156:27;;:10;:27;;;:57;;;;1201:12;;;;;;;;;;;1187:26;;:10;:26;;;1156:57;1148:114;;;;;;;;;;;;:::i;:::-;;;;;;;;;1393:1;1377:18;;:4;:18;;;;1369:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;1464:1;1450:16;;:2;:16;;;;1442:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;1559:4;1519:44;;1527:10;1519:27;;;1547:7;1519:36;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;;;1511:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;1629:10;1621:36;;;1658:4;1664:2;1668:7;1621:55;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1002:681;;;;:::o;1912:198:7:-;1253:12;:10;:12::i;:::-;1242:23;;:7;:5;:7::i;:::-;:23;;;1234:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2020:1:::1;2000:22;;:8;:22;;;;1992:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2075:28;2094:8;2075:18;:28::i;:::-;1912:198:::0;:::o;640:96:1:-;693:7;719:10;712:17;;640:96;:::o;952:237:8:-;1086:96;1106:5;1136:27;;;1165:4;1171:2;1175:5;1113:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1086:19;:96::i;:::-;952:237;;;;:::o;2264:187:7:-;2337:16;2356:6;;;;;;;;;;;2337:25;;2381:8;2372:6;;:17;;;;;;;;;;;;;;;;;;2435:8;2404:40;;2425:8;2404:40;;;;;;;;;;;;2264:187;;:::o;3231:706:8:-;3650:23;3676:69;3704:4;3676:69;;;;;;;;;;;;;;;;;3684:5;3676:27;;;;:69;;;;;:::i;:::-;3650:95;;3779:1;3759:10;:17;:21;3755:176;;;3854:10;3843:30;;;;;;;;;;;;:::i;:::-;3835:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;3755:176;3231:706;;;:::o;3515:219:0:-;3644:12;3675:52;3697:6;3705:4;3711:1;3714:12;3675:21;:52::i;:::-;3668:59;;3515:219;;;;;:::o;4594:495::-;4755:12;4812:5;4787:21;:30;;4779:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;4878:18;4889:6;4878:10;:18::i;:::-;4870:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;4942:12;4956:23;4983:6;:11;;5002:5;5009:4;4983:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4941:73;;;;5031:51;5048:7;5057:10;5069:12;5031:16;:51::i;:::-;5024:58;;;;4594:495;;;;;;:::o;772:377::-;832:4;1035:12;1100:7;1088:20;1080:28;;1141:1;1134:4;:8;1127:15;;;772:377;;;:::o;7195:688::-;7337:12;7365:7;7361:516;;;7395:10;7388:17;;;;7361:516;7526:1;7506:10;:17;:21;7502:365;;;7700:10;7694:17;7760:15;7747:10;7743:2;7739:19;7732:44;7649:145;7839:12;7832:20;;;;;;;;;;;:::i;:::-;;;;;;;;7195:688;;;;;;:::o;7:139:13:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:143::-;;240:6;234:13;225:22;;256:33;283:5;256:33;:::i;:::-;215:80;;;;:::o;301:137::-;;386:6;380:13;371:22;;402:30;426:5;402:30;:::i;:::-;361:77;;;;:::o;444:139::-;;528:6;515:20;506:29;;544:33;571:5;544:33;:::i;:::-;496:87;;;;:::o;589:143::-;;677:6;671:13;662:22;;693:33;720:5;693:33;:::i;:::-;652:80;;;;:::o;738:262::-;;846:2;834:9;825:7;821:23;817:32;814:2;;;862:1;859;852:12;814:2;905:1;930:53;975:7;966:6;955:9;951:22;930:53;:::i;:::-;920:63;;876:117;804:196;;;;:::o;1006:284::-;;1125:2;1113:9;1104:7;1100:23;1096:32;1093:2;;;1141:1;1138;1131:12;1093:2;1184:1;1209:64;1265:7;1256:6;1245:9;1241:22;1209:64;:::i;:::-;1199:74;;1155:128;1083:207;;;;:::o;1296:698::-;;;;;1455:3;1443:9;1434:7;1430:23;1426:33;1423:2;;;1472:1;1469;1462:12;1423:2;1515:1;1540:53;1585:7;1576:6;1565:9;1561:22;1540:53;:::i;:::-;1530:63;;1486:117;1642:2;1668:53;1713:7;1704:6;1693:9;1689:22;1668:53;:::i;:::-;1658:63;;1613:118;1770:2;1796:53;1841:7;1832:6;1821:9;1817:22;1796:53;:::i;:::-;1786:63;;1741:118;1898:2;1924:53;1969:7;1960:6;1949:9;1945:22;1924:53;:::i;:::-;1914:63;;1869:118;1413:581;;;;;;;:::o;2000:278::-;;2116:2;2104:9;2095:7;2091:23;2087:32;2084:2;;;2132:1;2129;2122:12;2084:2;2175:1;2200:61;2253:7;2244:6;2233:9;2229:22;2200:61;:::i;:::-;2190:71;;2146:125;2074:204;;;;:::o;2284:284::-;;2403:2;2391:9;2382:7;2378:23;2374:32;2371:2;;;2419:1;2416;2409:12;2371:2;2462:1;2487:64;2543:7;2534:6;2523:9;2519:22;2487:64;:::i;:::-;2477:74;;2433:128;2361:207;;;;:::o;2574:118::-;2661:24;2679:5;2661:24;:::i;:::-;2656:3;2649:37;2639:53;;:::o;2698:373::-;;2830:38;2862:5;2830:38;:::i;:::-;2884:88;2965:6;2960:3;2884:88;:::i;:::-;2877:95;;2981:52;3026:6;3021:3;3014:4;3007:5;3003:16;2981:52;:::i;:::-;3058:6;3053:3;3049:16;3042:23;;2806:265;;;;;:::o;3077:364::-;;3193:39;3226:5;3193:39;:::i;:::-;3248:71;3312:6;3307:3;3248:71;:::i;:::-;3241:78;;3328:52;3373:6;3368:3;3361:4;3354:5;3350:16;3328:52;:::i;:::-;3405:29;3427:6;3405:29;:::i;:::-;3400:3;3396:39;3389:46;;3169:272;;;;;:::o;3447:366::-;;3610:67;3674:2;3669:3;3610:67;:::i;:::-;3603:74;;3686:93;3775:3;3686:93;:::i;:::-;3804:2;3799:3;3795:12;3788:19;;3593:220;;;:::o;3819:366::-;;3982:67;4046:2;4041:3;3982:67;:::i;:::-;3975:74;;4058:93;4147:3;4058:93;:::i;:::-;4176:2;4171:3;4167:12;4160:19;;3965:220;;;:::o;4191:366::-;;4354:67;4418:2;4413:3;4354:67;:::i;:::-;4347:74;;4430:93;4519:3;4430:93;:::i;:::-;4548:2;4543:3;4539:12;4532:19;;4337:220;;;:::o;4563:366::-;;4726:67;4790:2;4785:3;4726:67;:::i;:::-;4719:74;;4802:93;4891:3;4802:93;:::i;:::-;4920:2;4915:3;4911:12;4904:19;;4709:220;;;:::o;4935:366::-;;5098:67;5162:2;5157:3;5098:67;:::i;:::-;5091:74;;5174:93;5263:3;5174:93;:::i;:::-;5292:2;5287:3;5283:12;5276:19;;5081:220;;;:::o;5307:366::-;;5470:67;5534:2;5529:3;5470:67;:::i;:::-;5463:74;;5546:93;5635:3;5546:93;:::i;:::-;5664:2;5659:3;5655:12;5648:19;;5453:220;;;:::o;5679:366::-;;5842:67;5906:2;5901:3;5842:67;:::i;:::-;5835:74;;5918:93;6007:3;5918:93;:::i;:::-;6036:2;6031:3;6027:12;6020:19;;5825:220;;;:::o;6051:366::-;;6214:67;6278:2;6273:3;6214:67;:::i;:::-;6207:74;;6290:93;6379:3;6290:93;:::i;:::-;6408:2;6403:3;6399:12;6392:19;;6197:220;;;:::o;6423:366::-;;6586:67;6650:2;6645:3;6586:67;:::i;:::-;6579:74;;6662:93;6751:3;6662:93;:::i;:::-;6780:2;6775:3;6771:12;6764:19;;6569:220;;;:::o;6795:366::-;;6958:67;7022:2;7017:3;6958:67;:::i;:::-;6951:74;;7034:93;7123:3;7034:93;:::i;:::-;7152:2;7147:3;7143:12;7136:19;;6941:220;;;:::o;7167:366::-;;7330:67;7394:2;7389:3;7330:67;:::i;:::-;7323:74;;7406:93;7495:3;7406:93;:::i;:::-;7524:2;7519:3;7515:12;7508:19;;7313:220;;;:::o;7539:118::-;7626:24;7644:5;7626:24;:::i;:::-;7621:3;7614:37;7604:53;;:::o;7663:271::-;;7815:93;7904:3;7895:6;7815:93;:::i;:::-;7808:100;;7925:3;7918:10;;7797:137;;;;:::o;7940:222::-;;8071:2;8060:9;8056:18;8048:26;;8084:71;8152:1;8141:9;8137:17;8128:6;8084:71;:::i;:::-;8038:124;;;;:::o;8168:442::-;;8355:2;8344:9;8340:18;8332:26;;8368:71;8436:1;8425:9;8421:17;8412:6;8368:71;:::i;:::-;8449:72;8517:2;8506:9;8502:18;8493:6;8449:72;:::i;:::-;8531;8599:2;8588:9;8584:18;8575:6;8531:72;:::i;:::-;8322:288;;;;;;:::o;8616:313::-;;8767:2;8756:9;8752:18;8744:26;;8816:9;8810:4;8806:20;8802:1;8791:9;8787:17;8780:47;8844:78;8917:4;8908:6;8844:78;:::i;:::-;8836:86;;8734:195;;;;:::o;8935:419::-;;9139:2;9128:9;9124:18;9116:26;;9188:9;9182:4;9178:20;9174:1;9163:9;9159:17;9152:47;9216:131;9342:4;9216:131;:::i;:::-;9208:139;;9106:248;;;:::o;9360:419::-;;9564:2;9553:9;9549:18;9541:26;;9613:9;9607:4;9603:20;9599:1;9588:9;9584:17;9577:47;9641:131;9767:4;9641:131;:::i;:::-;9633:139;;9531:248;;;:::o;9785:419::-;;9989:2;9978:9;9974:18;9966:26;;10038:9;10032:4;10028:20;10024:1;10013:9;10009:17;10002:47;10066:131;10192:4;10066:131;:::i;:::-;10058:139;;9956:248;;;:::o;10210:419::-;;10414:2;10403:9;10399:18;10391:26;;10463:9;10457:4;10453:20;10449:1;10438:9;10434:17;10427:47;10491:131;10617:4;10491:131;:::i;:::-;10483:139;;10381:248;;;:::o;10635:419::-;;10839:2;10828:9;10824:18;10816:26;;10888:9;10882:4;10878:20;10874:1;10863:9;10859:17;10852:47;10916:131;11042:4;10916:131;:::i;:::-;10908:139;;10806:248;;;:::o;11060:419::-;;11264:2;11253:9;11249:18;11241:26;;11313:9;11307:4;11303:20;11299:1;11288:9;11284:17;11277:47;11341:131;11467:4;11341:131;:::i;:::-;11333:139;;11231:248;;;:::o;11485:419::-;;11689:2;11678:9;11674:18;11666:26;;11738:9;11732:4;11728:20;11724:1;11713:9;11709:17;11702:47;11766:131;11892:4;11766:131;:::i;:::-;11758:139;;11656:248;;;:::o;11910:419::-;;12114:2;12103:9;12099:18;12091:26;;12163:9;12157:4;12153:20;12149:1;12138:9;12134:17;12127:47;12191:131;12317:4;12191:131;:::i;:::-;12183:139;;12081:248;;;:::o;12335:419::-;;12539:2;12528:9;12524:18;12516:26;;12588:9;12582:4;12578:20;12574:1;12563:9;12559:17;12552:47;12616:131;12742:4;12616:131;:::i;:::-;12608:139;;12506:248;;;:::o;12760:419::-;;12964:2;12953:9;12949:18;12941:26;;13013:9;13007:4;13003:20;12999:1;12988:9;12984:17;12977:47;13041:131;13167:4;13041:131;:::i;:::-;13033:139;;12931:248;;;:::o;13185:419::-;;13389:2;13378:9;13374:18;13366:26;;13438:9;13432:4;13428:20;13424:1;13413:9;13409:17;13402:47;13466:131;13592:4;13466:131;:::i;:::-;13458:139;;13356:248;;;:::o;13610:222::-;;13741:2;13730:9;13726:18;13718:26;;13754:71;13822:1;13811:9;13807:17;13798:6;13754:71;:::i;:::-;13708:124;;;;:::o;13838:98::-;;13923:5;13917:12;13907:22;;13896:40;;;:::o;13942:99::-;;14028:5;14022:12;14012:22;;14001:40;;;:::o;14047:147::-;;14185:3;14170:18;;14160:34;;;;:::o;14200:169::-;;14318:6;14313:3;14306:19;14358:4;14353:3;14349:14;14334:29;;14296:73;;;;:::o;14375:96::-;;14441:24;14459:5;14441:24;:::i;:::-;14430:35;;14420:51;;;:::o;14477:90::-;;14554:5;14547:13;14540:21;14529:32;;14519:48;;;:::o;14573:126::-;;14650:42;14643:5;14639:54;14628:65;;14618:81;;;:::o;14705:77::-;;14771:5;14760:16;;14750:32;;;:::o;14788:307::-;14856:1;14866:113;14880:6;14877:1;14874:13;14866:113;;;14965:1;14960:3;14956:11;14950:18;14946:1;14941:3;14937:11;14930:39;14902:2;14899:1;14895:10;14890:15;;14866:113;;;14997:6;14994:1;14991:13;14988:2;;;15077:1;15068:6;15063:3;15059:16;15052:27;14988:2;14837:258;;;;:::o;15101:102::-;;15193:2;15189:7;15184:2;15177:5;15173:14;15169:28;15159:38;;15149:54;;;:::o;15209:229::-;15349:34;15345:1;15337:6;15333:14;15326:58;15418:12;15413:2;15405:6;15401:15;15394:37;15315:123;:::o;15444:229::-;15584:34;15580:1;15572:6;15568:14;15561:58;15653:12;15648:2;15640:6;15636:15;15629:37;15550:123;:::o;15679:225::-;15819:34;15815:1;15807:6;15803:14;15796:58;15888:8;15883:2;15875:6;15871:15;15864:33;15785:119;:::o;15910:225::-;16050:34;16046:1;16038:6;16034:14;16027:58;16119:8;16114:2;16106:6;16102:15;16095:33;16016:119;:::o;16141:182::-;16281:34;16277:1;16269:6;16265:14;16258:58;16247:76;:::o;16329:180::-;16469:32;16465:1;16457:6;16453:14;16446:56;16435:74;:::o;16515:230::-;16655:34;16651:1;16643:6;16639:14;16632:58;16724:13;16719:2;16711:6;16707:15;16700:38;16621:124;:::o;16751:182::-;16891:34;16887:1;16879:6;16875:14;16868:58;16857:76;:::o;16939:179::-;17079:31;17075:1;17067:6;17063:14;17056:55;17045:73;:::o;17124:232::-;17264:34;17260:1;17252:6;17248:14;17241:58;17333:15;17328:2;17320:6;17316:15;17309:40;17230:126;:::o;17362:229::-;17502:34;17498:1;17490:6;17486:14;17479:58;17571:12;17566:2;17558:6;17554:15;17547:37;17468:123;:::o;17597:122::-;17670:24;17688:5;17670:24;:::i;:::-;17663:5;17660:35;17650:2;;17709:1;17706;17699:12;17650:2;17640:79;:::o;17725:116::-;17795:21;17810:5;17795:21;:::i;:::-;17788:5;17785:32;17775:2;;17831:1;17828;17821:12;17775:2;17765:76;:::o;17847:122::-;17920:24;17938:5;17920:24;:::i;:::-;17913:5;17910:35;17900:2;;17959:1;17956;17949:12;17900:2;17890:79;:::o

ipfs://a13c3c184f80391f916255e0ec82083a69a08b11e899d48c241c14a066b7852a