{
  "language": "Solidity",
  "sources": {
    "contracts/KingsStake.sol": {
      "content": "// SPDX-License-Identifier: MIT\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/security/ReentrancyGuard.sol\";\n\npragma solidity ^0.8.15;\n\ninterface IERC20 {\n    function decimals() external view returns (uint8);\n    function symbol() external view returns (string memory);\n    function name() external view returns (string memory);\n    function balanceOf(address account) external view returns (uint256);\n    function transfer(address recipient, uint256 amount)\n        external\n        returns (bool);\n    function allowance(address _owner, address spender)\n        external\n        view\n        returns (uint256);\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) external returns (bool);\n}\n\ncontract KingsStake is Ownable, ReentrancyGuard {\n    \n    struct user{\n        uint256 id;\n        uint256 totalStakedBalance;\n        uint256 totalClaimedRewards;\n        uint256 createdTime;\n    }\n\n    struct stakePool{\n        uint256 id;\n        uint256 duration;\n        uint256 multiplier; // Used for dynamic APY\n        uint256 APY; // Used for fixed APY\n        uint256 withdrawalFee;\n        uint256 unstakeFee;\n        uint256 earlyUnstakePenalty;\n        uint256 stakedTokens;\n        uint256 claimedRewards;\n        uint256 claimFrequency;\n        uint256 status; //1: created, 2: active, 3: cancelled\n        uint256 createdTime;\n    }\n\n    stakePool[] public stakePoolArray;\n\n    struct userStake{\n        uint256 id;\n        uint256 stakePoolId;\n\t    uint256 stakeBalance;\n    \tuint256 totalClaimedRewards;\n    \tuint256 lastClaimedTime;\n        uint256 nextClaimTime;\n        uint256 status; //0 : Unstaked, 1 : Staked\n        address owner;\n    \tuint256 createdTime;\n        uint256 unlockTime;\n        uint256 lockDuration;\n    }\n\n    userStake[] public userStakeArray;\n\n\n    mapping (uint256 => stakePool) public stakePoolsById;\n    mapping (uint256 => userStake) public userStakesById;\n\n    mapping (address => uint256[]) public userStakeIds;\n    mapping (address => userStake[]) public userStakeLists;\n\n    mapping (address => user) public users;\n\n    uint256 public totalStakedBalance;\n    uint256 public totalClaimedBalance;\n  \n    uint256 public magnitude = 100000000;\n\n    uint256 public userIndex;\n    uint256 public poolIndex;\n    uint256 public stakeIndex;\n\n    bool public dynamicApy;\n    bool public unstakePenalty;\n    bool public isPaused;\n\n    address public baseTokenAddress;\n    IERC20 stakeToken = IERC20(baseTokenAddress);\n\n    address public rewardTokensAddress;\n    IERC20 rewardToken = IERC20(rewardTokensAddress);\n    \n\n    modifier unpaused {\n      require(isPaused == false);\n      _;\n    }\n\n    modifier paused {\n      require(isPaused == true);\n      _;\n    }\n\n    uint256[] _durationArray = [30,60,90];\n    uint256[] _multiplierArray = [0,0,0];\n    uint256[] _apyArray = [11500,15500,21500]; \n    uint256[] _withdrawalFeeArray = [0,0,0];\n    uint256[] _unstakePenaltyArray = [50,50,50];\n    uint256[] _claimFrequencyArray = [30,60,90];\n    \n    constructor() {\n        address _baseTokenAddress = 0xA1B26B9918b350e9657D9Ab43A45088805d65E4e; \n        address _rewardTokensAddress = 0xA1B26B9918b350e9657D9Ab43A45088805d65E4e;\n\n        dynamicApy = false;\n        unstakePenalty = true; \n\n        baseTokenAddress = _baseTokenAddress;\n        rewardTokensAddress = _rewardTokensAddress;\n        \n        stakeToken = IERC20(baseTokenAddress);\n        rewardToken = IERC20(rewardTokensAddress);\n\n        for(uint256 i = 0; i < _durationArray.length; i++){\n            addStakePool(\n                _durationArray[i], // Duration in days\n                _multiplierArray[i], // Multiplier for Dynamic APY\n                _apyArray[i], // APY percentage for static APY\n                _withdrawalFeeArray[i], // Withdrawal fees percentage\n                _unstakePenaltyArray[i], // Early unstake penalty\n                _claimFrequencyArray[i]\n            );\n        }\n    }\n    \n    function addStakePool(uint256 _duration, uint256 _multiplier, uint256 _apy, uint256 _withdrawalFee, uint256 _unstakePenalty, uint256 _claimFrequency ) public onlyOwner returns (bool){\n        if(dynamicApy == true){\n            require(_multiplier > 0,\"Multipier is required for dynamic APY pools\");\n            require(_apy == 0,\"Fixed APY percentage must be 0 for dynamic APY pools\");\n        }else{\n            require(_apy > 0,\"Fixed APY percentage is required for fixed APY pools\");\n            require(_multiplier == 0,\"Multipier must be 0 for fixed APY pools\");\n        }\n\n        if(unstakePenalty == true) {\n            require(_unstakePenalty > 0,\"Unstake penalty must be greater than 0 if unstake penalty is enabled\");\n        }else {\n            require(_unstakePenalty == 0,\"Unstake penalty must be 0 if unstake penalty is disabled\");\n        }\n\n        stakePool memory stakePoolDetails;\n        \n        stakePoolDetails.id = poolIndex;\n        stakePoolDetails.duration = _duration;\n        stakePoolDetails.multiplier = _multiplier;\n        stakePoolDetails.APY = _apy;\n        stakePoolDetails.withdrawalFee = _withdrawalFee;\n        stakePoolDetails.earlyUnstakePenalty = _unstakePenalty;\n        stakePoolDetails.claimFrequency = _claimFrequency;\n        \n        stakePoolDetails.createdTime = block.timestamp;\n       \n        stakePoolArray.push(stakePoolDetails);\n        stakePoolsById[poolIndex++] = stakePoolDetails;\n\n        return true;\n    }\n\n    function getDPR(uint256 _stakePoolId) public view returns (uint256){\n        uint256 apy;\n        uint256 dpr;\n\n        stakePool memory stakePoolDetails = getStakePoolDetailsById(_stakePoolId);\n\n        if(dynamicApy == false){\n            \n            apy = stakePoolDetails.APY;\n            dpr = (apy * magnitude) / (365 * 100);\n        }else{\n            uint256 rewardTokenBalance = rewardToken.balanceOf(address(this));\n            \n            uint256 poolMultiplier = stakePoolDetails.multiplier;\n            uint256 totalPoolsAPY = rewardTokenBalance / totalStakedBalance;\n            apy = totalPoolsAPY * poolMultiplier;\n            dpr = (apy * magnitude) / (365 * 100);\n        }\n        return (dpr);\n    }\n\n    function getAPYOfAllPools() public view returns (uint256[] memory) {\n        uint256[] memory allPoolAPY = new uint256[](stakePoolArray.length);\n        stakePool memory stakePoolDetails;\n        uint256 stakePoolAPY;\n\n        if(dynamicApy == false){\n            \n            uint256 rewardTokenBalance = rewardToken.balanceOf(address(this));\n            uint256 poolMultiplier;\n            uint256 totalPoolsAPY;\n\n            for(uint256 i = 0; i < stakePoolArray.length; i++ ){\n                stakePoolDetails = stakePoolArray[i];\n                poolMultiplier = stakePoolDetails.multiplier;\n                totalPoolsAPY = rewardTokenBalance / totalStakedBalance;\n                stakePoolAPY = totalPoolsAPY * poolMultiplier;\n                allPoolAPY[i] = stakePoolAPY;\n            }\n        }else{\n            for(uint256 i = 0; i < stakePoolArray.length; i++ ){\n                stakePoolDetails = stakePoolArray[i];\n                stakePoolAPY = stakePoolDetails.APY;\n                allPoolAPY[i] = stakePoolAPY;\n            }\n        }\n        return (allPoolAPY);\n    }\n\n    function getStakePoolDetailsById(uint256 _stakePoolId) public view returns(stakePool memory){\n        return (stakePoolArray[_stakePoolId]);\n    }\n\n    function getElapsedTime(uint256 _stakeId) public view returns(uint256){\n        userStake memory userStakeDetails = userStakesById[_stakeId];\n        uint256 lapsedDays = ((block.timestamp - userStakeDetails.lastClaimedTime)/3600)/24; //3600 seconds per hour so: lapsed days = lapsed time * (3600seconds /24hrs)\n        return lapsedDays;  \n    }\n\n    function stake(uint256 _stakePoolId, uint256 _amount) unpaused external returns (bool) {\n        stakePool memory stakePoolDetails = stakePoolsById[_stakePoolId];\n\n        require(stakeToken.allowance(msg.sender, address(this)) >= _amount,'Tokens not approved for transfer');\n        \n        bool success = stakeToken.transferFrom(msg.sender, address(this), _amount);\n        require(success, \"Token Transfer failed.\");\n\n        userStake memory userStakeDetails;\n\n        uint256 userStakeid = stakeIndex++;\n        userStakeDetails.id = userStakeid;\n        userStakeDetails.stakePoolId = _stakePoolId;\n        userStakeDetails.stakeBalance = _amount;\n        userStakeDetails.status = 1;\n        userStakeDetails.owner = msg.sender;\n        userStakeDetails.createdTime = block.timestamp;\n        userStakeDetails.unlockTime = block.timestamp + (stakePoolDetails.duration * 86400);\n        userStakeDetails.lockDuration = stakePoolDetails.duration;\n        userStakeDetails.lastClaimedTime = block.timestamp;\n        userStakeDetails.nextClaimTime = userStakeDetails.lastClaimedTime + (stakePoolDetails.claimFrequency * 1 days);\n        userStakesById[userStakeid] = userStakeDetails;\n    \n        uint256[] storage userStakeIdsArray = userStakeIds[msg.sender];\n    \n        userStakeIdsArray.push(userStakeid);\n        userStakeArray.push(userStakeDetails);\n    \n        userStake[] storage userStakeList = userStakeLists[msg.sender];\n        userStakeList.push(userStakeDetails);\n        \n        user memory userDetails = users[msg.sender];\n\n        if(userDetails.id == 0){\n            userDetails.id = ++userIndex;\n            userDetails.createdTime = block.timestamp;\n        }\n\n        userDetails.totalStakedBalance += _amount;\n\n        users[msg.sender] = userDetails;\n\n        stakePoolDetails.stakedTokens += _amount;\n    \n        stakePoolArray[_stakePoolId] = stakePoolDetails;\n        \n        stakePoolsById[_stakePoolId] = stakePoolDetails;\n\n        totalStakedBalance = totalStakedBalance + _amount;\n        \n        return true;\n    }\n\n    function unstake(uint256 _stakeId) nonReentrant unpaused external returns (bool){\n        userStake memory userStakeDetails = userStakesById[_stakeId];\n        uint256 stakePoolId = userStakeDetails.stakePoolId;\n        uint256 stakeBalance = userStakeDetails.stakeBalance;\n        \n        require(userStakeDetails.owner == msg.sender,\"You don't own this stake\");\n        \n        stakePool memory stakePoolDetails = stakePoolsById[stakePoolId];\n\n        uint256 unstakableBalance;\n        if(isStakeLocked(_stakeId)){\n            unstakableBalance = stakeBalance - (stakeBalance * stakePoolDetails.earlyUnstakePenalty)/(100);\n        }else{\n            unstakableBalance = stakeBalance;\n        }\n\n        userStakeDetails.status = 0;\n\n        userStakesById[_stakeId] = userStakeDetails;\n\n        stakePoolDetails.stakedTokens = stakePoolDetails.stakedTokens - stakeBalance;\n\n        userStakesById[_stakeId] = userStakeDetails;\n\n        user memory userDetails = users[msg.sender];\n        userDetails.totalStakedBalance =   userDetails.totalStakedBalance - stakeBalance;\n\n        users[msg.sender] = userDetails;\n\n        stakePoolsById[stakePoolId] = stakePoolDetails;\n\n        updateStakeArray(_stakeId);\n\n        totalStakedBalance =  totalStakedBalance - stakeBalance;\n\n        require(stakeToken.balanceOf(address(this)) >= unstakableBalance, \"Insufficient contract stake token balance\");\n        \n        bool success = stakeToken.transfer(msg.sender, unstakableBalance);\n        require(success, \"Token Transfer failed.\");\n\n        return true;\n    }\n\n    function isStakeLocked(uint256 _stakeId) public view returns (bool) {\n        userStake memory userStakeDetails = userStakesById[_stakeId];\n        if(block.timestamp < userStakeDetails.unlockTime){\n            return true;\n        }else{\n            return false;\n        }\n    }\n\n    function getStakePoolIdByStakeId(uint256 _stakeId) public view returns(uint256){\n        userStake memory userStakeDetails = userStakesById[_stakeId];\n        return userStakeDetails.stakePoolId;\n    }\n\n    function getUserStakeIds() public view returns(uint256[] memory){\n        return (userStakeIds[msg.sender]);\n    }\n\n    function getUserStakeIdsByAddress(address _userAddress) public view returns(uint256[] memory){\n         return(userStakeIds[_userAddress]);\n    }\n\n    \n    function getUserAllStakeDetails() public view returns(userStake[] memory){\n        return (userStakeLists[msg.sender]);\n    }\n\n    function getUserAllStakeDetailsByAddress(address _userAddress) public view returns(userStake[] memory){\n        return (userStakeLists[_userAddress]);\n    }\n\n    function getUserStakeOwner(uint256 _stakeId) public view returns (address){\n        userStake memory userStakeDetails = userStakesById[_stakeId];\n        return userStakeDetails.owner;\n    }\n\n    function getUserStakeBalance(uint256 _stakeId) public view returns (uint256){\n        userStake memory userStakeDetails = userStakesById[_stakeId];\n        return userStakeDetails.stakeBalance;\n    }\n    \n    function getUnclaimedRewards(uint256 _stakeId) public view returns (uint256){\n        userStake memory userStakeDetails = userStakeArray[_stakeId];\n        uint256 stakePoolId = userStakeDetails.stakePoolId;\n\n        stakePool memory stakePoolDetails = stakePoolsById[stakePoolId];\n        uint256 stakeApr = getDPR(stakePoolDetails.id);\n\n        uint applicableRewards = (userStakeDetails.stakeBalance * stakeApr)/(magnitude * 100); //divided by 10000 to handle decimal percentages like 0.1%\n        uint unclaimedRewards = (applicableRewards * getElapsedTime(_stakeId));\n\n        return unclaimedRewards; \n    }\n\n    function getTotalUnclaimedRewards(address _userAddress) public view returns (uint256){\n        uint256[] memory stakeIds = getUserStakeIdsByAddress(_userAddress);\n        uint256 totalUnclaimedRewards;\n        for(uint256 i = 0; i < stakeIds.length; i++) {\n            userStake memory userStakeDetails = userStakesById[stakeIds[i]];\n            if(userStakeDetails.status == 1){\n                totalUnclaimedRewards += getUnclaimedRewards(stakeIds[i]);\n            }\n        }\n        return totalUnclaimedRewards;\n    }\n\n    \n    function getAllPoolDetails() public view returns(stakePool[] memory){\n        return (stakePoolArray);\n    }\n\n    function claimRewards(uint256 _stakeId) nonReentrant unpaused public returns (bool){\n        address userStakeOwner = getUserStakeOwner(_stakeId);\n        require(userStakeOwner == msg.sender,\"You don't own this stake\");\n\n        userStake memory userStakeDetails = userStakesById[_stakeId];\n        uint256 stakePoolId = userStakeDetails.stakePoolId;\n\n        stakePool memory stakePoolDetails = getStakePoolDetailsById(stakePoolId);\n \n        require(userStakeDetails.status == 1, \"You can not claim after unstaked\");\n        \n        if(userStakeDetails.nextClaimTime <= userStakeDetails.unlockTime){\n            require(userStakeDetails.nextClaimTime <= block.timestamp,\"You can not withdraw\");\n        }\n        uint256 unclaimedRewards = getUnclaimedRewards(_stakeId);\n        \n        userStakeDetails.totalClaimedRewards = userStakeDetails.totalClaimedRewards + unclaimedRewards;\n        userStakeDetails.lastClaimedTime = block.timestamp;\n        userStakeDetails.nextClaimTime = userStakeDetails.lastClaimedTime + (stakePoolDetails.claimFrequency * 1 days);\n        userStakesById[_stakeId] = userStakeDetails;\n        updateStakeArray(_stakeId);\n\n        totalClaimedBalance += unclaimedRewards;\n\n        user memory userDetails = users[msg.sender];\n        userDetails.totalClaimedRewards  +=  unclaimedRewards;\n\n        users[msg.sender] = userDetails;\n\n        require(rewardToken.balanceOf(address(this)) >= unclaimedRewards, \"Insufficient contract reward token balance\");\n\n        if(rewardToken.decimals() < stakeToken.decimals()){\n            unclaimedRewards = unclaimedRewards * (10**(stakeToken.decimals() - rewardToken.decimals()));\n        }else if(rewardToken.decimals() > stakeToken.decimals()){\n            unclaimedRewards = unclaimedRewards / (10**(rewardToken.decimals() - stakeToken.decimals()));\n        }\n\n        bool success = rewardToken.transfer(msg.sender, unclaimedRewards);\n        require(success, \"Token Transfer failed.\");\n\n        return true;\n    }\n\n    function updateStakeArray(uint256 _stakeId) internal {\n        userStake[] storage userStakesArray = userStakeLists[msg.sender];\n        \n        for(uint i = 0; i < userStakesArray.length; i++){\n            userStake memory userStakeFromArrayDetails = userStakesArray[i];\n            if(userStakeFromArrayDetails.id == _stakeId){\n                userStake memory userStakeDetails = userStakesById[_stakeId];\n                userStakesArray[i] = userStakeDetails;\n            }\n        }\n    }\n\n    function getUserDetails(address _userAddress) external view returns (user memory){\n        user memory userDetails = users[_userAddress];\n        return(userDetails);\n    }\n    \n    function pauseStake(bool _pauseStatus) public onlyOwner(){\n        isPaused = _pauseStatus;\n    }\n    \n    function withdrawContractETH() public onlyOwner paused returns(bool){\n        bool success;\n        (success, ) = msg.sender.call{value: address(this).balance}(\"\");\n        require(success, \"Transfer failed.\");\n\n        success = false;\n        \n        success = rewardToken.transfer(msg.sender, rewardToken.balanceOf(address(this)));\n        require(success, \"Token Transfer failed.\");\n\n        return true;\n    }\n    \n    receive() external payable {}\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",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}