{
  "language": "Solidity",
  "sources": {
    "wanderingplanetstake.sol": {
      "content": "// SPDX-License-Identifier: MIT\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/security/ReentrancyGuard.sol\";\n\n\npragma solidity ^0.8.7;\n\ninterface WPInterFace {\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n    function safeTransferFrom( \n        address from,\n        address to,\n        uint256 tokenId\n    ) external;\n    function totalMinted() external view returns (uint256);\n    function balanceOf(address owner) external view returns (uint256 balance);\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n\ncontract WanderingPlanetStake is Ownable, ReentrancyGuard {    \n    event Staked(address indexed owner, uint256 tokenID);\n    event Reclaimed(address indexed owner, uint256 tokenID);\n    event StakeInterrupted(uint256 indexed tokenId);\n    event Withdraw(address indexed account, uint256 amount);\n    event stakeTimeConfigChanged(Period config_);\n    \n    // Interface for Wandering Planet Contract\n    WPInterFace WP_Contract;  \n\n    struct Stake_Info{\n        bool staked;\n        address previous_owner;\n        uint256 stake_time;\n    }\n\n    struct Period {\n        uint256 startTime;\n        uint256 endTime;\n    }\n\n\n    // Stake Data Sturcture\n    mapping(uint256 => Stake_Info) public planetStakeInfo;\n    // Mapping from owner to the list of staked token IDs(only for querying)\n    mapping(address => uint256[]) private addressStakeList;\n    // Mapping from token ID to index of the owner tokens list(support to operate the addressStakeList)\n    mapping(uint256 => uint256) private addressStakeIndex;\n    // List for all the tokens staked\n    uint256 [] private allStakeList;\n    // support to operate the allStake list\n    mapping(uint256 => uint256) private allStakeIndex;\n\n    Period public stakeTime;\n    address public wandering_planet_address;\n    uint256 public rewardPeriod = 1000;\n\n\n    constructor(address wandering_planet_address_, Period memory stake_time_) {\n        require(wandering_planet_address_ != address(0), \"invalid contract address\");\n        wandering_planet_address = wandering_planet_address_;\n        stakeTime = stake_time_;\n        WP_Contract = WPInterFace(wandering_planet_address);\n    }\n        \n    /***********************************|\n    |                Core               |\n    |__________________________________*/\n    \n    /**\n    * @dev Pubilc function for owners to reclaim their plantes\n    * @param tokenID uint256 ID list of the token to be reclaim\n    */\n    function reclaimPlanets(uint256 [] memory tokenID) external callerIsUser nonReentrant{\n        for(uint256 i = 0; i < tokenID.length; i++){\n            _reclaim(tokenID[i]);\n        }\n    }\n\n    /**\n    * @dev Private function to stake one planet and update the state variabies\n    * The function will be called when users transfer their tokens via 'safeTransferFrom'\n    * @param tokenID uint256 ID of the token to be staked\n    */\n    function _stake(address owner, uint256 tokenID) internal{\n        require(isStakeEnabled(), \"stake not enabled\");\n        Stake_Info storage status = planetStakeInfo[tokenID];\n        require(status.staked == false, \"token is staking\");\n        status.staked = true;\n        status.previous_owner = owner;\n        status.stake_time = block.number;\n        addEnumeration(owner, tokenID);\n        addAllEnmeration(tokenID);\n        emit Staked(owner, tokenID);\n    }\n\n    /**\n    * @dev Private function to reclaim one planet and update the state variabies\n    * @param tokenID uint256 ID of the token to be reclaimed\n    */\n    function _reclaim(uint256 tokenID) internal{\n        require(isStakeEnabled(), \"stake not enabled\");\n        Stake_Info storage status = planetStakeInfo[tokenID];\n        require(status.staked == true, \"the planet is freedom\");\n        require(status.previous_owner == msg.sender, \"you are not the owner\");\n        WP_Contract.safeTransferFrom(address(this), msg.sender, tokenID);\n        status.staked = false;\n        status.previous_owner = address(0);\n        status.stake_time = 0;\n        removeEnumeration(msg.sender, tokenID);\n        removeAllEnmeration(tokenID);\n        emit Reclaimed(msg.sender, tokenID);\n    }\n\n   /**\n    * @dev Public function to batach stake this planets\n    * Approval for all the WP balances is needed\n    * @param tokenIDs list of the tokens to be reclaimed\n    */\n    function batchStake(uint256 [] memory tokenIDs) external callerIsUser nonReentrant(){\n        require(WP_Contract.isApprovedForAll(msg.sender, address(this)), \"no authority\");\n        if (tokenIDs.length == 0){\n            tokenIDs = getOwnedPlanets(msg.sender);\n        }\n        for(uint256 i = 0; i < tokenIDs.length; i++){\n            require(WP_Contract.ownerOf(tokenIDs[i]) == msg.sender, \"not the owner\");\n            WP_Contract.safeTransferFrom(msg.sender, address(this), tokenIDs[i]);\n        }\n    }\n\n    /**\n     * @dev Private function to add a token to this extension's token tracking data structures.\n     * @param address_ representing the owner of the given token ID\n     * @param tokenID uint256 ID of the token to be added to the tokens list\n     */\n    function addEnumeration(address address_, uint256 tokenID) internal {\n        addressStakeIndex[tokenID] = addressStakeList[address_].length;\n        addressStakeList[address_].push(tokenID);\n    }\n\n    /**\n    * @dev Private function to remove a token from this extension's ownership-tracking data structures.\n    * @param address_ representing the previous owner of the given token ID\n    * @param tokenID uint256 ID of the token to be removed from the tokens list of the given address\n    */\n    function removeEnumeration(address address_, uint256 tokenID) internal {\n\n        require(addressStakeList[address_].length > 0, \"No token staked by this address\");\n        uint256 lastTokenIndex = addressStakeList[address_].length - 1;\n        uint256 tokenIndex = addressStakeIndex[tokenID];\n\n        if (tokenIndex != lastTokenIndex) {\n            uint256 lastTokenId = addressStakeList[address_][lastTokenIndex];\n\n            addressStakeList[address_][tokenIndex] = lastTokenId;\n            addressStakeIndex[lastTokenId] = tokenIndex; \n        }\n        addressStakeList[address_].pop();\n    }\n\n    /*\n    * @dev Private function to add a token to this extension's token tracking data structures.\n    * @param tokenID uint256 ID of the token to be added to the tokens list\n    */\n    function addAllEnmeration(uint256 tokenID) internal {\n        allStakeIndex[tokenID] = allStakeList.length;\n        allStakeList.push(tokenID);\n    }\n\n    /**\n    * @dev Private function to remove a token from this extension's ownership-tracking data structures.\n    * @param tokenID uint256 ID of the token to be removed from the tokens list of the given address\n    */\n    function removeAllEnmeration(uint256 tokenID) internal {\n        require(allStakeList.length > 0, \"No token staked\");\n        uint256 lastTokenIndex = allStakeList.length - 1;\n        uint256 tokenIndex = allStakeIndex[tokenID];\n\n        if (tokenIndex != lastTokenIndex) {\n            uint256 lastTokenId = allStakeList[lastTokenIndex];\n\n            allStakeList[tokenIndex] = lastTokenId;\n            allStakeIndex[lastTokenId] = tokenIndex; \n        }\n        allStakeList.pop();\n    }\n\n\n    /***********************************|\n    |               State               |\n    |__________________________________*/\n\n    function isStakeEnabled() public view returns (bool){\n        if (stakeTime.endTime > 0 && block.timestamp > stakeTime.endTime) {\n            return false;\n        }\n        return stakeTime.startTime > 0 && \n            block.timestamp > stakeTime.startTime;\n    }\n    \n    function getOwnedPlanets(address address_) public view returns (uint256 [] memory){\n        uint256 max_tokenID = WP_Contract.totalMinted();\n        uint256 balance = WP_Contract.balanceOf(address_);\n        uint256 cnt = 0;\n        uint256 [] memory ownedtokens = new uint256 [](balance);\n        for(uint256 i = 0; i < max_tokenID; i++){\n            if(WP_Contract.ownerOf(i) == address_){\n                ownedtokens[cnt++] = i;\n            }\n        }\n        return ownedtokens;\n    }\n\n    /**\n    * @dev Public function to get the staked tokens of the given address\n    * @param address_ representing owner address\n    */\n    function getStakeList(address address_) public view returns (uint256 [] memory){\n        return addressStakeList[address_];\n    }\n\n    /**\n    * @dev Public function to get all the stake list\n    */\n    function getAllStakeList() public view returns (uint256 [] memory){\n        return allStakeList;\n    }\n\n    /**\n    * @dev Public function to get all the staked tokens which satisify the condition of stake time\n    */\n    function getValidStakes() public view returns (uint256 [] memory, bool [] memory){\n        uint256 stake_count = allStakeList.length;\n        bool [] memory isvalidstake = new bool [](stake_count);\n        for(uint256 i = 0; i < stake_count; i++){\n            uint256 tokenID = allStakeList[i];\n            Stake_Info memory status = planetStakeInfo[tokenID];\n            if(status.staked && block.number - status.stake_time >= rewardPeriod){\n                isvalidstake[i] = true;\n            }\n            else{\n                isvalidstake[i] = false;\n            }\n        }\n        return (allStakeList, isvalidstake);\n    }\n\n    function getStakeInfo(uint256 tokenID) public view returns (Stake_Info memory){\n        return planetStakeInfo[tokenID];\n    }\n\n\n\n    /***********************************|\n    |               Owner               |\n    |__________________________________*/\n    /**\n    * @dev Owner function to write adward list\n    */\n    function setRewardPeriod(uint256 rewardPeriod_) external onlyOwner{\n        require(rewardPeriod_ > 0, \"invalid parameter\");\n        rewardPeriod = rewardPeriod_;\n    }\n\n    function setStakeTime(Period calldata config_) external onlyOwner {\n        stakeTime = config_;\n        emit stakeTimeConfigChanged(config_);\n    }\n\n    /**\n     * This method is used to prevent some users from mistakenly using transferFrom (instead of safeTransferFrom) to transfer NFT into the contract.\n     * @param tokenIds_ the tokenId list\n     * @param accounts_ the address list\n     */\n    function transferUnstakingTokens(uint256[] calldata tokenIds_, address[] calldata accounts_) external onlyOwner {\n        require(tokenIds_.length == accounts_.length, \"tokenIds_ and accounts_ length mismatch\");\n        require(tokenIds_.length > 0, \"no tokenId\");\n        for (uint256 i = 0; i < tokenIds_.length; i++) {\n            uint256 tokenId = tokenIds_[i];\n            address account = accounts_[i];\n            require(planetStakeInfo[tokenId].stake_time == 0, \"token is staking\");\n            WP_Contract.safeTransferFrom(address(this), account, tokenId);\n        }\n    }\n\n    function stopStake(uint256[] calldata tokenIds_) external onlyOwner {\n        for (uint256 i; i < tokenIds_.length; i++) {\n            uint256 tokenId = tokenIds_[i];\n            _reclaim(tokenId);\n            emit StakeInterrupted(tokenId);\n        }\n    }\n\n\n    function withdraw() external onlyOwner nonReentrant {\n        uint256 balance = address(this).balance;\n        payable(_msgSender()).transfer(balance);\n        emit Withdraw(_msgSender(), balance);\n    }\n\n    /***********************************|\n    |              Modifier             |\n    |__________________________________*/\n    modifier callerIsUser() {\n        require(tx.origin == _msgSender(), \"caller is another contract\");\n        _;\n    }\n\n    /***********************************|\n    |                Hook               |\n    |__________________________________*/\n    function onERC721Received(\n        address,\n        address _from,\n        uint256 _tokenId,\n        bytes memory\n    ) public returns (bytes4) {\n        require(msg.sender == wandering_planet_address, \"only for WP\");\n        _stake(_from, _tokenId);\n        return this.onERC721Received.selector;\n    }\n}"
    },
    "@openzeppelin/contracts/security/ReentrancyGuard.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant _NOT_ENTERED = 1;\n    uint256 private constant _ENTERED = 2;\n\n    uint256 private _status;\n\n    constructor() {\n        _status = _NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        // On the first call to nonReentrant, _notEntered will be true\n        require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n        // Any calls to nonReentrant after this point will fail\n        _status = _ENTERED;\n\n        _;\n\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = _NOT_ENTERED;\n    }\n}\n"
    },
    "@openzeppelin/contracts/access/Ownable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"
    },
    "@openzeppelin/contracts/utils/Context.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "abi"
        ]
      }
    }
  }
}