Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC721Receiver
•    - function onERC721Received(
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• interface IMintableERC20
•    - function mint(address to, uint256 amo ...
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
•  contract ConsoleStake is IERC721Re ... *
•    - function stakeConsoles(uint16[] calld ...
•    - function unstakeConsoles(uint16[] cal ...
•    - function claim(uint16[] calldata toke ...
•    - function onERC721Received(
•    - function _stakeConsole(address accoun ...
•    - function _unstakeConsole(address acco ...
•    - function _claim(uint16 tokenId)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-12-16
*/

// File: @openzeppelin\contracts\token\ERC721\IERC721Receiver.sol

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

pragma solidity ^0.8.0;

/**
 * @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);
}

// File: node_modules\@openzeppelin\contracts\utils\introspection\IERC165.sol


// OpenZeppelin Contracts v4.4.0 (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);
}

// File: @openzeppelin\contracts\token\ERC721\IERC721.sol


// OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @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;
}

// File: contracts\lib\IMintableERC20.sol


// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IMintableERC20 {
    function mint(address to, uint256 amount) external;
    /**
     * @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);
}

// File: node_modules\@openzeppelin\contracts\utils\Context.sol


// OpenZeppelin Contracts v4.4.0 (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;
    }
}

// File: @openzeppelin\contracts\access\Ownable.sol


// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @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);
    }
}

// File: @openzeppelin\contracts\utils\math\SafeMath.sol


// OpenZeppelin Contracts v4.4.0 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: contracts\ConsoleStake.sol



pragma solidity ^0.8.0;






contract ConsoleStake is IERC721Receiver, Ownable {
  using SafeMath for uint256;

  uint256 constant SECINDAY = 86400;
  
  IMintableERC20 public gameToken;
  IERC721 public consoleToken;

  // struct to store a stake's token, owner, and earning values
  struct Stake {
    uint256 lastClaim;
    address owner;
  }

  // maps tokenId to stake
  mapping(uint256 => Stake) public stakes; 

  event TokenStaked(address owner, uint256 tokenId);
  event TokenUnStaked(address owner, uint256 tokenId);
  event GameClaimed(uint256 tokenId, uint256 earned);
  
  constructor(IMintableERC20 _gameToken, IERC721 _consoleToken) { 
    gameToken = _gameToken;
    consoleToken = _consoleToken;
  }

  function stakeConsoles(uint16[] calldata tokenIds) external {
    for (uint i = 0; i < tokenIds.length; i++) {
      require(consoleToken.ownerOf(tokenIds[i]) == _msgSender(), "not_token_owner");
      consoleToken.transferFrom(_msgSender(), address(this), tokenIds[i]);
      _stakeConsole(_msgSender(), tokenIds[i]);
    }
  }

  function unstakeConsoles(uint16[] calldata tokenIds) external {
    for (uint i = 0; i < tokenIds.length; i++) { 
      require(stakes[tokenIds[i]].owner == _msgSender(), "not_token_owner");
      consoleToken.transferFrom(address(this), _msgSender(), tokenIds[i]);
      _unstakeConsole(_msgSender(), tokenIds[i]);
    }
  }

  function claim(uint16[] calldata tokenIds) external {
    uint256 amount = 0;
    for (uint i = 0; i < tokenIds.length; i++) {
      require(stakes[tokenIds[i]].owner == _msgSender(), "not_token_owner");
      amount = amount.add(_claim(tokenIds[i]));
    }

    // transfer Game token reward
    if (amount > 0) {
      gameToken.mint(msg.sender, amount * 10 ** 18);
    }
  }

  function onERC721Received(
    address,
    address from,
    uint256,
    bytes calldata
  ) external pure override returns (bytes4) {
    require(from == address(0x0), "Cannot send tokens to Barn directly");
    return IERC721Receiver.onERC721Received.selector;
  }

  function _stakeConsole(address account, uint256 tokenId) internal {
    stakes[tokenId] = Stake({
      lastClaim: block.timestamp,
      owner: account
    });
    emit TokenStaked(account, tokenId);
  }

  function _unstakeConsole(address account, uint256 tokenId) internal {
    delete stakes[tokenId];
    emit TokenUnStaked(account, tokenId);
  }

  /**
    update last claim time for stake, returns amount of Game token be rewarded
   */
  function _claim(uint16 tokenId) internal returns (uint256){
    Stake storage stake = stakes[tokenId];
    uint256 amount = block.timestamp.sub(stake.lastClaim).div(SECINDAY);
    if (amount > 0) {
      stake.lastClaim = stake.lastClaim.add(amount.mul(SECINDAY));
      emit GameClaimed(tokenId, amount);
    }
    return amount;
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IMintableERC20","name":"_gameToken","type":"address"},{"internalType":"contract IERC721","name":"_consoleToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"earned","type":"uint256"}],"name":"GameClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"TokenStaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"TokenUnStaked","type":"event"},{"inputs":[{"internalType":"uint16[]","name":"tokenIds","type":"uint16[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"consoleToken","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gameToken","outputs":[{"internalType":"contract IMintableERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","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":"uint16[]","name":"tokenIds","type":"uint16[]"}],"name":"stakeConsoles","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakes","outputs":[{"internalType":"uint256","name":"lastClaim","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"tokenIds","type":"uint16[]"}],"name":"unstakeConsoles","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000882e5b370d595e50c24b2a0e7a94e87cc32adda10000000000000000000000008ed0e7404675d5c7f5b4f2a829138afcaf53d2ab

-----Decoded View---------------
Arg [0] : _gameToken (address): 0x882e5b370D595E50c24b2a0e7a94e87Cc32ADdA1
Arg [1] : _consoleToken (address): 0x8ed0E7404675d5C7F5b4F2a829138afCAF53d2ab

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000882e5b370d595e50c24b2a0e7a94e87cc32adda1
Arg [1] : 0000000000000000000000008ed0e7404675d5c7f5b4f2a829138afcaf53d2ab

20344:2876:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22132:275;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21738:388;;;;;;:::i;:::-;;:::i;:::-;;12420:103;;;:::i;11769:87::-;;;:::i;:::-;;;;;;;:::i;20510:27::-;;;:::i;21401:331::-;;;;;;:::i;:::-;;:::i;21061:334::-;;;;;;:::i;:::-;;:::i;20474:31::-;;;:::i;20706:39::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;12678:201::-;;;;;;:::i;:::-;;:::i;22132:275::-;22263:6;-1:-1:-1;;;;;22286:20:0;;;22278:68;;;;-1:-1:-1;;;22278:68:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;22132:275:0;;;;;;;:::o;21738:388::-;21797:14;21827:6;21822:178;21839:19;;;21822:178;;;21911:12;:10;:12::i;:::-;-1:-1:-1;;;;;21882:41:0;:6;:19;21889:8;;21898:1;21889:11;;;;;-1:-1:-1;;;21889:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21882:19;;;;;;;;;;;;;-1:-1:-1;21882:19:0;:25;;;-1:-1:-1;;;;;21882:25:0;:41;21874:69;;;;-1:-1:-1;;;21874:69:0;;;;;;;:::i;:::-;21961:31;21972:19;21979:8;;21988:1;21979:11;;;;;-1:-1:-1;;;21979:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21972:6;:19::i;:::-;21961:6;;:10;:31::i;:::-;21952:40;-1:-1:-1;21860:3:0;;;;:::i;:::-;;;;21822:178;;;-1:-1:-1;22047:10:0;;22043:78;;22068:9;;-1:-1:-1;;;;;22068:9:0;:14;22083:10;22095:17;:6;22104:8;22095:17;:::i;:::-;22068:45;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22043:78;21738:388;;;:::o;12420:103::-;12000:12;:10;:12::i;:::-;-1:-1:-1;;;;;11989:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;11989:23:0;;11981:68;;;;-1:-1:-1;;;11981:68:0;;;;;;;:::i;:::-;12485:30:::1;12512:1;12485:18;:30::i;:::-;12420:103::o:0;11769:87::-;11815:7;11842:6;-1:-1:-1;;;;;11842:6:0;11769:87;:::o;20510:27::-;;;-1:-1:-1;;;;;20510:27:0;;:::o;21401:331::-;21475:6;21470:257;21487:19;;;21470:257;;;21560:12;:10;:12::i;:::-;-1:-1:-1;;;;;21531:41:0;:6;:19;21538:8;;21547:1;21538:11;;;;;-1:-1:-1;;;21538:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21531:19;;;;;;;;;;;;;-1:-1:-1;21531:19:0;:25;;;-1:-1:-1;;;;;21531:25:0;:41;21523:69;;;;-1:-1:-1;;;21523:69:0;;;;;;;:::i;:::-;21601:12;;-1:-1:-1;;;;;21601:12:0;:25;21635:4;21642:12;:10;:12::i;:::-;21656:8;;21665:1;21656:11;;;;;-1:-1:-1;;;21656:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21601:67;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21677:42;21693:12;:10;:12::i;:::-;21707:8;;21716:1;21707:11;;;;;-1:-1:-1;;;21707:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21677:42;;:15;:42::i;:::-;21508:3;;;;:::i;:::-;;;;21470:257;;21061:334;21133:6;21128:262;21145:19;;;21128:262;;;21225:12;:10;:12::i;:::-;21188;;-1:-1:-1;;;;;21188:49:0;;;;:12;:20;21209:8;;21218:1;21209:11;;;;;-1:-1:-1;;;21209:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21188:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;21188:49:0;;21180:77;;;;-1:-1:-1;;;21180:77:0;;;;;;;:::i;:::-;21266:12;;-1:-1:-1;;;;;21266:12:0;:25;21292:12;:10;:12::i;:::-;21314:4;21321:8;;21330:1;21321:11;;;;;-1:-1:-1;;;21321:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21266:67;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21342:40;21356:12;:10;:12::i;:::-;21370:8;;21379:1;21370:11;;;;;-1:-1:-1;;;21370:11:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21342:40;;:13;:40::i;:::-;21166:3;;;;:::i;:::-;;;;21128:262;;20474:31;;;-1:-1:-1;;;;;20474:31:0;;:::o;20706:39::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20706:39:0;;:::o;12678:201::-;12000:12;:10;:12::i;:::-;-1:-1:-1;;;;;11989:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;11989:23:0;;11981:68;;;;-1:-1:-1;;;11981:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;12767:22:0;::::1;12759:73;;;;-1:-1:-1::0;;;12759:73:0::1;;;;;;;:::i;:::-;12843:28;12862:8;12843:18;:28::i;:::-;12678:201:::0;:::o;10493:98::-;10573:10;10493:98;:::o;22875:342::-;22962:15;;;22925:7;22962:15;;;:6;:15;;;;;23021;;22925:7;;23001:50;;20460:5;;23001:36;;:15;;:19;:36::i;:::-;:40;;:50::i;:::-;22984:67;-1:-1:-1;23062:10:0;;23058:134;;23101:41;23121:20;:6;20460:5;23121:10;:20::i;:::-;23101:15;;;:19;:41::i;:::-;23083:59;;23156:28;;;;;;23168:7;;23177:6;;23156:28;:::i;:::-;;;;;;;;23058:134;23205:6;22875:342;-1:-1:-1;;;22875:342:0:o;16099:98::-;16157:7;16184:5;16188:1;16184;:5;:::i;13039:191::-;13113:16;13132:6;;-1:-1:-1;;;;;13149:17:0;;;-1:-1:-1;;;;;;13149:17:0;;;;;;13182:40;;13132:6;;;;;;;13182:40;;13113:16;13182:40;13039:191;;:::o;22629:146::-;22711:15;;;;:6;:15;;;;;;22704:22;;;;;;;;;-1:-1:-1;;;;;;22704:22:0;;;22738:31;;;;;22752:7;;22718;;22738:31;:::i;:::-;;;;;;;;22629:146;;:::o;22413:210::-;22504:72;;;;;;;;22530:15;22504:72;;-1:-1:-1;;;;;22504:72:0;;;;;;;;;;-1:-1:-1;22486:15:0;;;:6;:15;;;;;;:90;;;;;;;;;;;-1:-1:-1;;;;;;22486:90:0;;;;;;;;;;;22588:29;;;;;22504:72;;22486:15;;22588:29;:::i;16480:98::-;16538:7;16565:5;16569:1;16565;:5;:::i;17236:98::-;17294:7;17321:5;17325:1;17321;:5;:::i;16837:98::-;16895:7;16922:5;16926:1;16922;:5;:::i;14:259:1:-;;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;210:33;237:5;210:33;:::i;278:263::-;;401:2;389:9;380:7;376:23;372:32;369:2;;;422:6;414;407:22;369:2;459:9;453:16;478:33;505:5;478:33;:::i;546:990::-;;;;;;728:3;716:9;707:7;703:23;699:33;696:2;;;750:6;742;735:22;696:2;794:9;781:23;813:33;840:5;813:33;:::i;:::-;865:5;-1:-1:-1;922:2:1;907:18;;894:32;935:35;894:32;935:35;:::i;:::-;989:7;-1:-1:-1;1043:2:1;1028:18;;1015:32;;-1:-1:-1;1098:2:1;1083:18;;1070:32;1121:18;1151:14;;;1148:2;;;1183:6;1175;1168:22;1148:2;1226:6;1215:9;1211:22;1201:32;;1271:7;1264:4;1260:2;1256:13;1252:27;1242:2;;1298:6;1290;1283:22;1242:2;1343;1330:16;1369:2;1361:6;1358:14;1355:2;;;1390:6;1382;1375:22;1355:2;1440:7;1435:2;1426:6;1422:2;1418:15;1414:24;1411:37;1408:2;;;1466:6;1458;1451:22;1408:2;686:850;;;;-1:-1:-1;686:850:1;;-1:-1:-1;1502:2:1;1494:11;;1524:6;686:850;-1:-1:-1;;;686:850:1:o;1541:665::-;;;1687:2;1675:9;1666:7;1662:23;1658:32;1655:2;;;1708:6;1700;1693:22;1655:2;1753:9;1740:23;1782:18;1823:2;1815:6;1812:14;1809:2;;;1844:6;1836;1829:22;1809:2;1887:6;1876:9;1872:22;1862:32;;1932:7;1925:4;1921:2;1917:13;1913:27;1903:2;;1959:6;1951;1944:22;1903:2;2004;1991:16;2030:2;2022:6;2019:14;2016:2;;;2051:6;2043;2036:22;2016:2;2110:7;2105:2;2099;2091:6;2087:15;2083:2;2079:24;2075:33;2072:46;2069:2;;;2136:6;2128;2121:22;2069:2;2172;2164:11;;;;;2194:6;;-1:-1:-1;1645:561:1;;-1:-1:-1;;;;1645:561:1:o;2211:292::-;;2322:2;2310:9;2301:7;2297:23;2293:32;2290:2;;;2343:6;2335;2328:22;2290:2;2387:9;2374:23;2437:6;2430:5;2426:18;2419:5;2416:29;2406:2;;2464:6;2456;2449:22;2508:190;;2620:2;2608:9;2599:7;2595:23;2591:32;2588:2;;;2641:6;2633;2626:22;2588:2;-1:-1:-1;2669:23:1;;2578:120;-1:-1:-1;2578:120:1:o;2703:203::-;-1:-1:-1;;;;;2867:32:1;;;;2849:51;;2837:2;2822:18;;2804:102::o;2911:387::-;-1:-1:-1;;;;;3168:15:1;;;3150:34;;3220:15;;;;3215:2;3200:18;;3193:43;3284:6;3272:19;;;3267:2;3252:18;;3245:47;3100:2;3085:18;;3067:231::o;3303:274::-;-1:-1:-1;;;;;3495:32:1;;;;3477:51;;3559:2;3544:18;;3537:34;3465:2;3450:18;;3432:145::o;3582:202::-;-1:-1:-1;;;;;;3744:33:1;;;;3726:52;;3714:2;3699:18;;3681:103::o;4242:339::-;4444:2;4426:21;;;4483:2;4463:18;;;4456:30;-1:-1:-1;;;4517:2:1;4502:18;;4495:45;4572:2;4557:18;;4416:165::o;4586:402::-;4788:2;4770:21;;;4827:2;4807:18;;;4800:30;4866:34;4861:2;4846:18;;4839:62;-1:-1:-1;;;4932:2:1;4917:18;;4910:36;4978:3;4963:19;;4760:228::o;4993:399::-;5195:2;5177:21;;;5234:2;5214:18;;;5207:30;5273:34;5268:2;5253:18;;5246:62;-1:-1:-1;;;5339:2:1;5324:18;;5317:33;5382:3;5367:19;;5167:225::o;5397:356::-;5599:2;5581:21;;;5618:18;;;5611:30;5677:34;5672:2;5657:18;;5650:62;5744:2;5729:18;;5571:182::o;5758:189::-;5933:6;5921:19;;;;5903:38;;5891:2;5876:18;;5858:89::o;5952:260::-;6155:6;6143:19;;;;6125:38;;6194:2;6179:18;;6172:34;6113:2;6098:18;;6080:132::o;6217:274::-;6391:25;;;-1:-1:-1;;;;;6452:32:1;6447:2;6432:18;;6425:60;6379:2;6364:18;;6346:145::o;6496:128::-;;6567:1;6563:6;6560:1;6557:13;6554:2;;;6573:18;;:::i;:::-;-1:-1:-1;6609:9:1;;6544:80::o;6629:217::-;;6695:1;6685:2;;-1:-1:-1;;;6720:31:1;;6774:4;6771:1;6764:15;6802:4;6727:1;6792:15;6685:2;-1:-1:-1;6831:9:1;;6675:171::o;6851:168::-;;6957:1;6953;6949:6;6945:14;6942:1;6939:21;6934:1;6927:9;6920:17;6916:45;6913:2;;;6964:18;;:::i;:::-;-1:-1:-1;7004:9:1;;6903:116::o;7024:125::-;;7092:1;7089;7086:8;7083:2;;;7097:18;;:::i;:::-;-1:-1:-1;7134:9:1;;7073:76::o;7154:135::-;;-1:-1:-1;;7214:17:1;;7211:2;;;7234:18;;:::i;:::-;-1:-1:-1;7281:1:1;7270:13;;7201:88::o;7294:127::-;7355:10;7350:3;7346:20;7343:1;7336:31;7386:4;7383:1;7376:15;7410:4;7407:1;7400:15;7426:133;-1:-1:-1;;;;;7503:31:1;;7493:42;;7483:2;;7549:1;7546;7539:12

ipfs://40fa4f65abb930420b6022939a12ea7c713eb80df257643f4d24102474b2c7e3