Contract 0xdf19f1216aa406df8bc585246bee7d96933f285f 4

 

Contract Overview

Treasure DAO: Mine
Balance:
0 ETH

ETH Value:
$0.00

Token:
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x8e99486445ab070d80f0ef89b1ab4df0c03ca0306e9b1ad8500df0fb1ed3d007Withdraw Positio...199475852022-08-10 22:18:326 days 2 hrs ago0x655a7ba052e5acde220a482777981c050fa087fe IN  Treasure DAO: Mine0 ETH0.‍000147088522 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72aceHarvest All199475702022-08-10 22:18:326 days 2 hrs ago0x655a7ba052e5acde220a482777981c050fa087fe IN  Treasure DAO: Mine0 ETH0.‍000163443804 ETH
0xf99026f4bbeb787cbb0d803feca7668d28fffe42108165d9726953467da47abcHarvest All196772042022-08-08 4:09:548 days 20 hrs ago0x0c73f75339f530e5cb1f3f3fb2ac5865e2bf82f3 IN  Treasure DAO: Mine0 ETH0.‍000045414224 ETH
0xd3a7239da7208c213cd301c1fa128e2b58b9e207dce85004a5af1f3646d18468Withdraw Positio...196771862022-08-08 4:09:548 days 20 hrs ago0x0c73f75339f530e5cb1f3f3fb2ac5865e2bf82f3 IN  Treasure DAO: Mine0 ETH0.‍000055257349 ETH
0x63dcb8eb51131245642ecdfdaf06314454a462f28f974c3840184f1b5860570dWithdraw Positio...196598982022-08-07 22:39:569 days 1 hr ago0x38d8c4703bc5bf24d493fcdc4e52b12ec71b655f IN  Treasure DAO: Mine0 ETH0.‍000051524449 ETH
0x763cf8740df0bdb49e8990eccaabaf0a61ddd2ffd211b5ed797b8a701e5ee010Withdraw And Har...196392302022-08-07 15:41:279 days 8 hrs ago0xbfe09443556773958bae1699b786d8e9680b5571 IN  Treasure DAO: Mine0 ETH0.‍000040157157 ETH
0xe5744e3efe4cd305e76ba5cab3fd4fc3d6b6d4e7927f4eb04959ab3d709cfdb3Harvest All195659012022-08-06 19:54:1010 days 4 hrs ago0x4e99667ad4a71f00486c01082f515e71422e786d IN  Treasure DAO: Mine0 ETH0.‍000043759957 ETH
0x48e8f783c500c0f6b0890c62740d1191ce35c24d7f4ae6ad2c16a7890d7ed5f4Withdraw Positio...195658842022-08-06 19:54:1010 days 4 hrs ago0x4e99667ad4a71f00486c01082f515e71422e786d IN  Treasure DAO: Mine0 ETH0.‍0000444968 ETH
0xe9e220563b3f6ced8a0fd5f3a7e66cd1f0884a64889f296384312e2946b10390Withdraw Positio...195658772022-08-06 19:54:1010 days 4 hrs ago0x4e99667ad4a71f00486c01082f515e71422e786d IN  Treasure DAO: Mine0 ETH0.‍000044759108 ETH
0x26526f45a8366505bf4809db9ec2c2d7bd605f0111dadff49964c346c0011b7aWithdraw Positio...195658632022-08-06 19:53:3110 days 4 hrs ago0x4e99667ad4a71f00486c01082f515e71422e786d IN  Treasure DAO: Mine0 ETH0.‍000044629561 ETH
0x39a30d16347d70529a9d3da9c783f8e633e0bce0f562770f26f121ae9c4f8c32Withdraw Positio...195658522022-08-06 19:53:3110 days 4 hrs ago0x4e99667ad4a71f00486c01082f515e71422e786d IN  Treasure DAO: Mine0 ETH0.‍000044627198 ETH
0xb07524e77f2d790d6ef679b0db7371304635c5f1cd17d33cbe5211f4a95eba63Withdraw Positio...192327612022-08-02 22:58:4114 days 1 hr ago0xe56a354b83a748a2aaa6b8fdaa293d9f891bd388 IN  Treasure DAO: Mine0 ETH0.‍000081557036 ETH
0x93c53b744f662cd6f87995725c936488d7002ed9cc5ce9e2df97a9e20a4e62c2Harvest All187333522022-07-27 23:23:1620 days 1 hr ago0x46fcafb8c870065f8ade3af4963eec4ea4794ecb IN  Treasure DAO: Mine0 ETH0.‍000098840034 ETH
0xbb814a10d50d692533af2c30340eee8160531def239f514f22b24b0293a5279aWithdraw Positio...187247692022-07-27 20:21:1120 days 4 hrs ago0x8fdd27b6f825da4354129ad0f514f01560687dca IN  Treasure DAO: Mine0 ETH0.‍000096384273 ETH
0x3efa9ecb678aa3d878209097210791e53a5a789a911466fe34082e06bfa62f1fWithdraw Positio...181370402022-07-20 19:53:5927 days 4 hrs ago0xcdc00cca459608e2463c21c1cf74411cae329491 IN  Treasure DAO: Mine0 ETH0.‍000167160962 ETH
0xe6ff5d865625c4f5e804ba4fc74956e4b97afb7f483812de598bca88011934dbHarvest All177742842022-07-16 18:41:2431 days 5 hrs ago0x725031676e9213a4acaf7dd56d4122343ef06bce IN  Treasure DAO: Mine0 ETH0.‍000086732319 ETH
0xdddde8c4578e1da51e422b691eea37b071713a161e2486cbbf58ef81bf21d99dHarvest All177742802022-07-16 18:41:2431 days 5 hrs ago0x725031676e9213a4acaf7dd56d4122343ef06bce IN  Treasure DAO: Mine0 ETH0.‍000088639685 ETH
0x04f0fd52adc89e60b38eae3f64c14fea3f0e2c07dfc8d57005425071435ee013Harvest All175798132022-07-13 21:56:3134 days 2 hrs ago0x29be86363061a89122bb39ad1a5defdbd2209f2c IN  Treasure DAO: Mine0 ETH0.‍000155762155 ETH
0x1b8b62e43ccd8f60e6611434cf40344d24d7e3c0f21395d167838fbaa09a4157Withdraw All174910322022-07-12 16:14:0135 days 8 hrs ago0xa4960b558b9334f759dd36f8f424d1e9caa98b72 IN  Treasure DAO: Mine0 ETH0.‍000096353186 ETH
0xd99b6b7557cce005ff795b7a1e933ed551c0133cb5cf91339abaf5958211f282Withdraw All174906572022-07-12 16:07:1535 days 8 hrs ago0xa4960b558b9334f759dd36f8f424d1e9caa98b72 IN  Treasure DAO: Mine0 ETH0.‍000096353186 ETH
0x522022d6c534bbabde3a282e288536fa6eb8ea9d5b875c9e8f2425f6a3609e6bHarvest All173792522022-07-10 15:44:1137 days 8 hrs ago0xd2f8a98bde7c701ae961d10d0d1fc3a751be737f IN  Treasure DAO: Mine0 ETH0.‍000069732386 ETH
0x65cadf0de68166c64c97280d3fb03da0e73ef7b0bb737e489840cf7caec5b2faWithdraw Positio...173792382022-07-10 15:44:1137 days 8 hrs ago0xd2f8a98bde7c701ae961d10d0d1fc3a751be737f IN  Treasure DAO: Mine0 ETH0.‍000074820457 ETH
0x67ef9e7a9cd94aafe4c759399f55a5b84827eb32da9612bc081c31fa353c687fWithdraw Positio...173792302022-07-10 15:43:3037 days 8 hrs ago0xd2f8a98bde7c701ae961d10d0d1fc3a751be737f IN  Treasure DAO: Mine0 ETH0.‍000082748311 ETH
0x385b28f82aee27b331539748eb15ab3043768c0091393c4d84baa20d2e8ca933Harvest All172650992022-07-08 16:19:3939 days 8 hrs ago0x18b24cf58dd392b9dad6ede481300d33309f3595 IN  Treasure DAO: Mine0 ETH0.‍00014699868 ETH
0xbb9f9e11439dbcecad5097cbfbe4d61f8ea107dd74fef11ea72f88d76a738397Withdraw Positio...172650852022-07-08 16:18:5339 days 8 hrs ago0x18b24cf58dd392b9dad6ede481300d33309f3595 IN  Treasure DAO: Mine0 ETH0.‍000178849798 ETH
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x8e99486445ab070d80f0ef89b1ab4df0c03ca0306e9b1ad8500df0fb1ed3d007199475852022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x8e99486445ab070d80f0ef89b1ab4df0c03ca0306e9b1ad8500df0fb1ed3d007199475852022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x8e99486445ab070d80f0ef89b1ab4df0c03ca0306e9b1ad8500df0fb1ed3d007199475852022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x8e99486445ab070d80f0ef89b1ab4df0c03ca0306e9b1ad8500df0fb1ed3d007199475852022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x8e99486445ab070d80f0ef89b1ab4df0c03ca0306e9b1ad8500df0fb1ed3d007199475852022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x8e99486445ab070d80f0ef89b1ab4df0c03ca0306e9b1ad8500df0fb1ed3d007199475852022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x8e99486445ab070d80f0ef89b1ab4df0c03ca0306e9b1ad8500df0fb1ed3d007199475852022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
0x2e2fc319c3d2755bc3b592b8922232e1ac927de0d13c089395cbdceb91d72ace199475702022-08-10 22:18:326 days 2 hrs ago Treasure DAO: MineTreasure DAO: Magic Token0 ETH
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
TreasuryMine

Compiler Version
v0.8.7+commit.e28d00a7

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 16 : Ownable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../utils/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() {
        _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);
    }
}

File 2 of 16 : IERC1155.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

File 3 of 16 : IERC1155Receiver.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
        @dev Handles the receipt of a single ERC1155 token type. This function is
        called at the end of a `safeTransferFrom` after the balance has been updated.
        To accept the transfer, this must return
        `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
        (i.e. 0xf23a6e61, or its own function selector).
        @param operator The address which initiated the transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param id The ID of the token being transferred
        @param value The amount of tokens being transferred
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
        @dev Handles the receipt of a multiple ERC1155 token types. This function
        is called at the end of a `safeBatchTransferFrom` after the balances have
        been updated. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

File 4 of 16 : ERC1155Holder.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC1155Receiver.sol";

/**
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

File 5 of 16 : ERC1155Receiver.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../IERC1155Receiver.sol";
import "../../../utils/introspection/ERC165.sol";

/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}

File 6 of 16 : ERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens 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 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

File 7 of 16 : IERC20.sol
// SPDX-License-Identifier: MIT

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);
}

File 8 of 16 : IERC20Metadata.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

File 9 of 16 : SafeERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../../../utils/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");
        }
    }
}

File 10 of 16 : Address.sol
// SPDX-License-Identifier: MIT

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);
            }
        }
    }
}

File 11 of 16 : Context.sol
// SPDX-License-Identifier: MIT

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 12 of 16 : ERC165.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

File 13 of 16 : IERC165.sol
// 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);
}

File 14 of 16 : SafeCast.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

File 15 of 16 : TreasuryMine.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;

import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/math/SafeCast.sol';

import './TreasuryStake.sol';

contract TreasuryMine is Ownable {
    using SafeERC20 for ERC20;
    using SafeCast for uint256;
    using SafeCast for int256;

    enum Lock { twoWeeks, oneMonth, threeMonths }

    uint256 public constant DAY = 60 * 60 * 24;
    uint256 public constant ONE_WEEK = DAY * 7;
    uint256 public constant TWO_WEEKS = ONE_WEEK * 2;
    uint256 public constant ONE_MONTH = DAY * 30;
    uint256 public constant THREE_MONTHS = ONE_MONTH * 3;
    uint256 public constant LIFECYCLE = THREE_MONTHS;
    uint256 public constant ONE = 1e18;

    // Magic token addr
    ERC20 public immutable magic;
    address public immutable treasuryStake;

    bool public unlockAll;
    uint256 public endTimestamp;

    uint256 public maxMagicPerSecond;
    uint256 public magicPerSecond;
    uint256 public totalRewardsEarned;
    uint256 public accMagicPerShare;
    uint256 public totalLpToken;
    uint256 public magicTotalDeposits;
    uint256 public lastRewardTimestamp;

    address[] public excludedAddresses;

    struct UserInfo {
        uint256 depositAmount;
        uint256 lpAmount;
        uint256 lockedUntil;
        int256 rewardDebt;
        Lock lock;
    }

    /// @notice user => depositId => UserInfo
    mapping (address => mapping (uint256 => UserInfo)) public userInfo;
    /// @notice user => depositId[]
    mapping (address => uint256[]) public allUserDepositIds;
    /// @notice user => depositId => index in allUserDepositIds
    mapping (address => mapping(uint256 => uint256)) public depositIdIndex;
    /// @notice user => deposit index array
    mapping (address => uint256) public currentId;

    event Deposit(address indexed user, uint256 indexed index, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed index, uint256 amount);
    event EmergencyWithdraw(address indexed to, uint256 amount);
    event Harvest(address indexed user, uint256 indexed index, uint256 amount);
    event LogUpdateRewards(uint256 indexed lastRewardTimestamp, uint256 lpSupply, uint256 accMagicPerShare);

    modifier refreshMagicRate() {
        _;
        uint256 util = utilization();
        if (util < 2e17) {
            magicPerSecond = 0;
        } else if (util < 3e17) { // >20%
            // 50%
            magicPerSecond = maxMagicPerSecond * 5 / 10;
        } else if (util < 4e17) { // >30%
            // 60%
            magicPerSecond = maxMagicPerSecond * 6 / 10;
        } else if (util < 5e17) { // >40%
            // 80%
            magicPerSecond = maxMagicPerSecond * 8 / 10;
        } else if (util < 6e17) { // >50%
            // 90%
            magicPerSecond = maxMagicPerSecond * 9 / 10;
        } else { // >60%
            // 100%
            magicPerSecond = maxMagicPerSecond;
        }
    }

    modifier updateRewards() {
        if (block.timestamp > lastRewardTimestamp && lastRewardTimestamp < endTimestamp && endTimestamp != 0) {
            uint256 lpSupply = totalLpToken;
            if (lpSupply > 0) {
                uint256 timeDelta;
                if (block.timestamp > endTimestamp) {
                    timeDelta = endTimestamp - lastRewardTimestamp;
                    lastRewardTimestamp = endTimestamp;
                } else {
                    timeDelta = block.timestamp - lastRewardTimestamp;
                    lastRewardTimestamp = block.timestamp;
                }
                uint256 magicReward = timeDelta * magicPerSecond;
                // send 10% to treasury
                uint256 treasuryReward = magicReward / 10;
                _fundTreasury(treasuryReward);
                magicReward -= treasuryReward;
                totalRewardsEarned += magicReward;
                accMagicPerShare += magicReward * ONE / lpSupply;
            }
            emit LogUpdateRewards(lastRewardTimestamp, lpSupply, accMagicPerShare);
        }
        _;
    }

    constructor(address _magic, address _treasuryStake, address _owner) {
        magic = ERC20(_magic);
        treasuryStake = _treasuryStake;
        transferOwnership(_owner);
    }

    function init() external onlyOwner refreshMagicRate {
        require(endTimestamp == 0, "Cannot init again");

        uint256 rewardsAmount = magic.balanceOf(address(this)) - magicTotalDeposits;
        require(rewardsAmount > 0, "No rewards sent");

        maxMagicPerSecond = rewardsAmount / LIFECYCLE;
        endTimestamp = block.timestamp + LIFECYCLE;
        lastRewardTimestamp = block.timestamp;
    }

    function isInitialized() public view returns (bool) {
        return endTimestamp != 0;
    }

    function utilization() public view returns (uint256 util) {
        uint256 circulatingSupply = magic.totalSupply();
        uint256 len = excludedAddresses.length;
        for (uint256 i = 0; i < len; i++) {
            circulatingSupply -= magic.balanceOf(excludedAddresses[i]);
        }
        uint256 rewardsAmount = magic.balanceOf(address(this)) - magicTotalDeposits;
        circulatingSupply -= rewardsAmount;
        if (circulatingSupply != 0) {
            util = magicTotalDeposits * ONE / circulatingSupply;
        }
    }

    function getAllUserDepositIds(address _user) public view returns (uint256[] memory) {
        return allUserDepositIds[_user];
    }

    function getExcludedAddresses() public view returns (address[] memory) {
        return excludedAddresses;
    }

    function getBoost(Lock _lock) public pure returns (uint256 boost, uint256 timelock) {
        if (_lock == Lock.twoWeeks) {
            // 20%
            return (2e17, TWO_WEEKS);
        } else if (_lock == Lock.oneMonth) {
            // 50%
            return (5e17, ONE_MONTH);
        } else if (_lock == Lock.threeMonths) {
            // 200%
            return (2e18, THREE_MONTHS);
        } else {
            revert("Invalid lock value");
        }
    }

    function pendingRewardsPosition(address _user, uint256 _depositId) public view returns (uint256 pending) {
        UserInfo storage user = userInfo[_user][_depositId];
        uint256 _accMagicPerShare = accMagicPerShare;
        uint256 lpSupply = totalLpToken;
        if (block.timestamp > lastRewardTimestamp && magicPerSecond != 0) {
            uint256 timeDelta;
            if (block.timestamp > endTimestamp) {
                timeDelta = endTimestamp - lastRewardTimestamp;
            } else {
                timeDelta = block.timestamp - lastRewardTimestamp;
            }
            uint256 magicReward = timeDelta * magicPerSecond;
            // send 10% to treasury
            uint256 treasuryReward = magicReward / 10;
            magicReward -= treasuryReward;

            _accMagicPerShare += magicReward * ONE / lpSupply;
        }

        pending = ((user.lpAmount * _accMagicPerShare / ONE).toInt256() - user.rewardDebt).toUint256();
    }

    function pendingRewardsAll(address _user) external view returns (uint256 pending) {
        uint256 len = allUserDepositIds[_user].length;
        for (uint256 i = 0; i < len; ++i) {
            uint256 depositId = allUserDepositIds[_user][i];
            pending += pendingRewardsPosition(_user, depositId);
        }
    }

    function deposit(uint256 _amount, Lock _lock) public refreshMagicRate updateRewards {
        require(isInitialized(), "Not initialized");

        if (_lock == Lock.twoWeeks) {
            // give 1 DAY of grace period
            require(block.timestamp + TWO_WEEKS - DAY <= endTimestamp, "Less than 2 weeks left");
        } else if (_lock == Lock.oneMonth) {
            // give 3 DAY of grace period
            require(block.timestamp + ONE_MONTH - 3 * DAY<= endTimestamp, "Less than 1 month left");
        } else if (_lock == Lock.threeMonths) {
            // give ONE_WEEK of grace period
            require(block.timestamp + THREE_MONTHS - ONE_WEEK <= endTimestamp, "Less than 3 months left");
        } else {
            revert("Invalid lock value");
        }

        (UserInfo storage user, uint256 depositId) = _addDeposit(msg.sender);
        (uint256 boost, uint256 timelock) = getBoost(_lock);
        uint256 lpAmount = _amount + _amount * boost / ONE;
        magicTotalDeposits += _amount;
        totalLpToken += lpAmount;

        user.depositAmount = _amount;
        user.lpAmount = lpAmount;
        user.lockedUntil = block.timestamp + timelock;
        user.rewardDebt = (lpAmount * accMagicPerShare / ONE).toInt256();
        user.lock = _lock;

        magic.safeTransferFrom(msg.sender, address(this), _amount);

        emit Deposit(msg.sender, depositId, _amount);
    }

    function withdrawPosition(uint256 _depositId, uint256 _amount) public refreshMagicRate updateRewards {
        UserInfo storage user = userInfo[msg.sender][_depositId];
        uint256 depositAmount = user.depositAmount;
        require(depositAmount > 0, "Position does not exists");

        if (_amount > depositAmount) {
            _amount = depositAmount;
        }
        // anyone can withdraw when mine ends or kill swith was used
        if (block.timestamp < endTimestamp && !unlockAll) {
            require(block.timestamp >= user.lockedUntil, "Position is still locked");
        }

        // Effects
        uint256 ratio = _amount * ONE / depositAmount;
        uint256 lpAmount = user.lpAmount * ratio / ONE;

        totalLpToken -= lpAmount;
        magicTotalDeposits -= _amount;

        user.depositAmount -= _amount;
        user.lpAmount -= lpAmount;
        user.rewardDebt -= (lpAmount * accMagicPerShare / ONE).toInt256();

        // Interactions
        magic.safeTransfer(msg.sender, _amount);

        emit Withdraw(msg.sender, _depositId, _amount);
    }

    function withdrawAll() public {
        uint256[] memory depositIds = allUserDepositIds[msg.sender];
        uint256 len = depositIds.length;
        for (uint256 i = 0; i < len; ++i) {
            uint256 depositId = depositIds[i];
            withdrawPosition(depositId, type(uint256).max);
        }
    }

    function harvestPosition(uint256 _depositId) public refreshMagicRate updateRewards {
        UserInfo storage user = userInfo[msg.sender][_depositId];

        int256 accumulatedMagic = (user.lpAmount * accMagicPerShare / ONE).toInt256();
        uint256 _pendingMagic = (accumulatedMagic - user.rewardDebt).toUint256();

        // Effects
        user.rewardDebt = accumulatedMagic;

        if (user.depositAmount == 0 && user.lpAmount == 0) {
            _removeDeposit(msg.sender, _depositId);
        }

        // Interactions
        if (_pendingMagic != 0) {
            magic.safeTransfer(msg.sender, _pendingMagic);
        }

        emit Harvest(msg.sender, _depositId, _pendingMagic);
    }

    function harvestAll() public {
        uint256[] memory depositIds = allUserDepositIds[msg.sender];
        uint256 len = depositIds.length;
        for (uint256 i = 0; i < len; ++i) {
            uint256 depositId = depositIds[i];
            harvestPosition(depositId);
        }
    }

    function withdrawAndHarvestPosition(uint256 _depositId, uint256 _amount) public {
        withdrawPosition(_depositId, _amount);
        harvestPosition(_depositId);
    }

    function withdrawAndHarvestAll() public {
        uint256[] memory depositIds = allUserDepositIds[msg.sender];
        uint256 len = depositIds.length;
        for (uint256 i = 0; i < len; ++i) {
            uint256 depositId = depositIds[i];
            withdrawAndHarvestPosition(depositId, type(uint256).max);
        }
    }

    function burnLeftovers() public refreshMagicRate updateRewards {
        require(block.timestamp > endTimestamp, "Will not burn before end");
        address blackhole = 0x000000000000000000000000000000000000dEaD;
        int256 burnAmount =
            (LIFECYCLE * maxMagicPerSecond).toInt256() // rewards originally sent
            - (totalRewardsEarned).toInt256() // rewards distributed to users
            - (totalRewardsEarned / 9).toInt256(); // rewards distributed to treasury
        if (burnAmount > 0) magic.safeTransfer(blackhole, uint256(burnAmount));
    }

    function addExcludedAddress(address exclude) external onlyOwner refreshMagicRate updateRewards {
        uint256 len = excludedAddresses.length;
        for (uint256 i = 0; i < len; ++i) {
            require(excludedAddresses[i] != exclude, "Already excluded");
        }
        excludedAddresses.push(exclude);
    }

    function removeExcludedAddress(address include) external onlyOwner refreshMagicRate updateRewards {
        uint256 index;
        uint256 len = excludedAddresses.length;
        require(len > 0, "no excluded addresses");
        for (uint256 i = 0; i < len; ++i) {
            if (excludedAddresses[i] == include) {
                index = i;
                break;
            }
        }
        require(excludedAddresses[index] == include, "address not excluded");

        uint256 lastIndex = len - 1;
        if (index != lastIndex) {
            excludedAddresses[index] = excludedAddresses[lastIndex];
        }
        excludedAddresses.pop();
    }

    /// @notice EMERGENCY ONLY
    function kill() external onlyOwner refreshMagicRate updateRewards {
        require(block.timestamp <= endTimestamp, "Will not kill after end");
        require(!unlockAll, "Already dead");

        int256 withdrawAmount =
            (LIFECYCLE * maxMagicPerSecond).toInt256() // rewards originally sent
            - (totalRewardsEarned).toInt256() // rewards distributed to users
            - (totalRewardsEarned / 9).toInt256(); // rewards distributed to treasury
        if (withdrawAmount > 0) {
            magic.safeTransfer(owner(), uint256(withdrawAmount));
            emit EmergencyWithdraw(owner(), uint256(withdrawAmount));
        }
        maxMagicPerSecond = 0;
        magicPerSecond = 0;
        unlockAll = true;
    }

    function _addDeposit(address _user) internal returns (UserInfo storage user, uint256 newDepositId) {
        // start depositId from 1
        newDepositId = ++currentId[_user];
        depositIdIndex[_user][newDepositId] = allUserDepositIds[_user].length;
        allUserDepositIds[_user].push(newDepositId);
        user = userInfo[_user][newDepositId];
    }

    function _removeDeposit(address _user, uint256 _depositId) internal {
        uint256 depositIndex = depositIdIndex[_user][_depositId];

        require(allUserDepositIds[_user][depositIndex] == _depositId, 'depositId !exists');

        uint256 lastDepositIndex = allUserDepositIds[_user].length - 1;
        if (depositIndex != lastDepositIndex) {
            uint256 lastDepositId = allUserDepositIds[_user][lastDepositIndex];
            allUserDepositIds[_user][depositIndex] = lastDepositId;
            depositIdIndex[_user][lastDepositId] = depositIndex;
        }
        allUserDepositIds[_user].pop();
        delete depositIdIndex[_user][_depositId];
    }

    function _fundTreasury(uint256 _amount) internal {
        magic.approve(treasuryStake, _amount);
        TreasuryStake(treasuryStake).notifyRewards(_amount);
    }
}

File 16 of 16 : TreasuryStake.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;

import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/utils/math/SafeCast.sol';
import '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol';

contract TreasuryStake is ERC1155Holder {
    using SafeERC20 for ERC20;
    using SafeCast for uint256;
    using SafeCast for int256;

    uint256 public constant DAY = 60 * 60 * 24;
    uint256 public constant ONE_WEEK = DAY * 7;
    uint256 public constant TWO_WEEKS = ONE_WEEK * 2;
    uint256 public constant ONE_MONTH = DAY * 30;
    uint256 public constant THREE_MONTHS = ONE_MONTH * 3;
    uint256 public constant LIFECYCLE = THREE_MONTHS;
    uint256 public constant ONE = 1e18;

    // Magic token addr
    ERC20 public immutable magic;
    IERC1155 public immutable lpToken;

    uint256 public totalRewardsEarned;
    uint256 public accMagicPerShare;
    uint256 public totalLpToken;
    uint256 public undistributedRewards;

    struct UserInfo {
        uint256 depositAmount;
        uint256 tokenId;
        uint256 lpAmount;
        int256 rewardDebt;
    }

    /// @notice user => tokenId => UserInfo
    mapping (address => mapping (uint256 => UserInfo)) public userInfo;
    /// @notice user => tokenId[]
    mapping (address => uint256[]) public allUserTokenIds;
    // @notice user => tokenId => index in allUserIndex
    mapping (address => mapping(uint256 => uint256)) public tokenIdIndex;

    event Deposit(address indexed user, uint256 lpAmount, uint256 tokenId, uint256 depositAmount);
    event Withdraw(address indexed user, uint256 tokenId, uint256 withdrawAmount);
    event Harvest(address indexed user, uint256 indexed index, uint256 amount);
    event LogUpdateRewards(uint256 lpSupply, uint256 accMagicPerShare);

    constructor(address _magic, address _lpToken) {
        magic = ERC20(_magic);
        lpToken = IERC1155(_lpToken);
    }

    function getLpAmount(uint256 _tokenId, uint256 _amount) public pure returns (uint256) {
        uint256 boost;
        uint256 boostDecimal = 100;

        if (_tokenId == 39) { // Ancient Relic 10.03
            boost = 1003;
        } else if (_tokenId == 46) { // Bag of Rare Mushrooms 8.21
            boost = 821;
        } else if (_tokenId == 47) { // Bait for Monsters 9.73
            boost = 973;
        } else if (_tokenId == 48) { // Beetle-wing 1.00
            boost = 100;
        } else if (_tokenId == 49) { // Blue Rupee 2.04
            boost = 204;
        } else if (_tokenId == 51) { // Bottomless Elixir 10.15
            boost = 1015;
        } else if (_tokenId == 52) { // Cap of Invisibility 10.15
            boost = 1015;
        } else if (_tokenId == 53) { // Carriage 8.09
            boost = 809;
        } else if (_tokenId == 54) { // Castle 9.77
            boost = 977;
        } else if (_tokenId == 68) { // Common Bead 7.52
            boost = 752;
        } else if (_tokenId == 69) { // Common Feather 4.50
            boost = 450;
        } else if (_tokenId == 71) { // Common Relic 2.87
            boost = 287;
        } else if (_tokenId == 72) { // Cow 7.74
            boost = 774;
        } else if (_tokenId == 73) { // Diamond 1.04
            boost = 104;
        } else if (_tokenId == 74) { // Divine Hourglass 8.46
            boost = 846;
        } else if (_tokenId == 75) { // Divine Mask 7.62
            boost = 762;
        } else if (_tokenId == 76) { // Donkey 1.62
            boost = 162;
        } else if (_tokenId == 77) { // Dragon Tail 1.03
            boost = 103;
        } else if (_tokenId == 79) { // Emerald 1.01
            boost = 101;
        } else if (_tokenId == 82) { // Favor from the Gods 7.39
            boost = 739;
        } else if (_tokenId == 91) { // Framed Butterfly 7.79
            boost = 779;
        } else if (_tokenId == 92) { // Gold Coin 1.03
            boost = 103;
        } else if (_tokenId == 93) { // Grain 4.29
            boost = 429;
        } else if (_tokenId == 94) { // Green Rupee 4.36
            boost = 436;
        } else if (_tokenId == 95) { // Grin 10.47
            boost = 1047;
        } else if (_tokenId == 96) { // Half-Penny 1.05
            boost = 105;
        } else if (_tokenId == 97) { // Honeycomb 10.52
            boost = 1052;
        } else if (_tokenId == 98) { // Immovable Stone 9.65
            boost = 965;
        } else if (_tokenId == 99) { // Ivory Breastpin 8.49
            boost = 849;
        } else if (_tokenId == 100) { // Jar of Fairies 7.10
            boost = 710;
        } else if (_tokenId == 103) { // Lumber 4.02
            boost = 402;
        } else if (_tokenId == 104) { // Military Stipend 8.30
            boost = 830;
        } else if (_tokenId == 105) { // Mollusk Shell 8.96
            boost = 896;
        } else if (_tokenId == 114) { // Ox 2.12
            boost = 212;
        } else if (_tokenId == 115) { // Pearl 1.03
            boost = 103;
        } else if (_tokenId == 116) { // Pot of Gold 7.72
            boost = 772;
        } else if (_tokenId == 117) { // Quarter-Penny 1.00
            boost = 100;
        } else if (_tokenId == 132) { // Red Feather 8.51
            boost = 851;
        } else if (_tokenId == 133) { // Red Rupee 1.03
            boost = 103;
        } else if (_tokenId == 141) { // Score of Ivory 7.94
            boost = 794;
        } else if (_tokenId == 151) { // Silver Coin 1.05
            boost = 105;
        } else if (_tokenId == 152) { // Small Bird 7.98
            boost = 798;
        } else if (_tokenId == 153) { // Snow White Feather 8.54
            boost = 854;
        } else if (_tokenId == 161) { // Thread of Divine Silk 9.77
            boost = 977;
        } else if (_tokenId == 162) { // Unbreakable Pocketwatch 7.91
            boost = 791;
        } else if (_tokenId == 164) { // Witches Broom 6.76
            boost = 676;
        } else {
            boost = 0;
        }
        _amount = addDecimals(_amount);
        return _amount + _amount * boost / boostDecimal;
    }

    function addDecimals(uint256 _amount) public pure returns (uint256) {
        return _amount * ONE;
    }

    function getAllUserTokenIds(address _user) public view returns (uint256[] memory) {
        return allUserTokenIds[_user];
    }

    function pendingRewardsPosition(address _user, uint256 _tokenId) public view returns (uint256 pending) {
        UserInfo storage user = userInfo[_user][_tokenId];
        pending = ((user.lpAmount * accMagicPerShare / ONE).toInt256() - user.rewardDebt).toUint256();
    }

    function pendingRewardsAll(address _user) external view returns (uint256 pending) {
        uint256 len = allUserTokenIds[_user].length;
        for (uint256 i = 0; i < len; ++i) {
            uint256 tokenId = allUserTokenIds[_user][i];
            pending += pendingRewardsPosition(_user, tokenId);
        }
    }

    function deposit(uint256 _tokenId, uint256 _amount) public {
        UserInfo storage user = _addDeposit(msg.sender, _tokenId);

        uint256 lpAmount = getLpAmount(_tokenId, _amount);
        totalLpToken += lpAmount;

        user.tokenId = _tokenId;
        user.depositAmount += _amount;
        user.lpAmount += lpAmount;
        user.rewardDebt += (lpAmount * accMagicPerShare / ONE).toInt256();

        lpToken.safeTransferFrom(msg.sender, address(this), _tokenId, _amount, bytes(""));

        emit Deposit(msg.sender, lpAmount, _tokenId, _amount);
    }

    function withdrawPosition(uint256 _tokenId, uint256 _amount) public {
        UserInfo storage user = userInfo[msg.sender][_tokenId];
        uint256 lpAmount = user.lpAmount;
        uint256 depositAmount = user.depositAmount;
        require(depositAmount > 0, "Position does not exists");

        if (_amount > depositAmount) {
            _amount = depositAmount;
        }

        // Effects
        uint256 ratio = _amount * ONE / depositAmount;
        lpAmount = lpAmount * ratio / ONE;

        totalLpToken -= lpAmount;

        user.depositAmount -= _amount;
        user.lpAmount -= lpAmount;
        user.rewardDebt -= (lpAmount * accMagicPerShare / ONE).toInt256();

        // Interactions
        lpToken.safeTransferFrom(address(this), msg.sender, _tokenId, _amount, bytes(""));

        emit Withdraw(msg.sender, _tokenId, _amount);
    }

    function withdrawAll() public {
        uint256[] memory tokenIds = allUserTokenIds[msg.sender];
        uint256 len = tokenIds.length;
        for (uint256 i = 0; i < len; ++i) {
            uint256 tokenId = tokenIds[i];
            withdrawPosition(tokenId, type(uint256).max);
        }
    }

    function harvestPosition(uint256 _tokenId) public {
        UserInfo storage user = userInfo[msg.sender][_tokenId];

        int256 accumulatedMagic = (user.lpAmount * accMagicPerShare / ONE).toInt256();
        uint256 _pendingMagic = (accumulatedMagic - user.rewardDebt).toUint256();

        // Effects
        user.rewardDebt = accumulatedMagic;

        if (user.lpAmount == 0) {
            _removeDeposit(msg.sender, _tokenId);
        }

        // Interactions
        if (_pendingMagic != 0) {
            magic.safeTransfer(msg.sender, _pendingMagic);
        }

        emit Harvest(msg.sender, _tokenId, _pendingMagic);
    }

    function harvestAll() public {
        uint256[] memory tokenIds = allUserTokenIds[msg.sender];
        uint256 len = tokenIds.length;
        for (uint256 i = 0; i < len; ++i) {
            uint256 tokenId = tokenIds[i];
            harvestPosition(tokenId);
        }
    }

    function withdrawAndHarvestPosition(uint256 _tokenId, uint256 _amount) public {
        withdrawPosition(_tokenId, _amount);
        harvestPosition(_tokenId);
    }

    function withdrawAndHarvestAll() public {
        uint256[] memory tokenIds = allUserTokenIds[msg.sender];
        uint256 len = tokenIds.length;
        for (uint256 i = 0; i < len; ++i) {
            uint256 tokenId = tokenIds[i];
            withdrawAndHarvestPosition(tokenId, type(uint256).max);
        }
    }

    function notifyRewards(uint256 _amount) external {
        if (_amount != 0) magic.safeTransferFrom(msg.sender, address(this), _amount);
        _updateRewards(_amount);
    }

    function _updateRewards(uint256 _amount) internal {
        uint256 lpSupply = totalLpToken;
        if (lpSupply > 0) {
            uint256 magicReward = _amount + undistributedRewards;
            accMagicPerShare += magicReward * ONE / lpSupply;
            undistributedRewards = 0;
        } else {
            undistributedRewards += _amount;
        }
        emit LogUpdateRewards(lpSupply, accMagicPerShare);
    }

    function _addDeposit(address _user, uint256 _tokenId) internal returns (UserInfo storage user) {
        user = userInfo[_user][_tokenId];
        uint256 tokenIndex = tokenIdIndex[_user][_tokenId];
        if (allUserTokenIds[_user].length == 0 || allUserTokenIds[_user][tokenIndex] != _tokenId) {
            tokenIdIndex[_user][_tokenId] = allUserTokenIds[_user].length;
            allUserTokenIds[_user].push(_tokenId);
        }
    }

    function _removeDeposit(address _user, uint256 _tokenId) internal {
        uint256 tokenIndex = tokenIdIndex[_user][_tokenId];

        require(allUserTokenIds[_user][tokenIndex] == _tokenId, 'tokenId !exists');

        uint256 lastDepositIndex = allUserTokenIds[_user].length - 1;
        if (tokenIndex != lastDepositIndex) {
            uint256 lastDepositId = allUserTokenIds[_user][lastDepositIndex];
            allUserTokenIds[_user][tokenIndex] = lastDepositId;
            tokenIdIndex[_user][lastDepositId] = tokenIndex;
        }

        allUserTokenIds[_user].pop();
        delete tokenIdIndex[_user][_tokenId];
    }
}

Settings
{
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"_magic","type":"address"},{"internalType":"address","name":"_treasuryStake","type":"address"},{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"lastRewardTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lpSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accMagicPerShare","type":"uint256"}],"name":"LogUpdateRewards","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":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"DAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LIFECYCLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ONE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ONE_MONTH","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ONE_WEEK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"THREE_MONTHS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TWO_WEEKS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accMagicPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"exclude","type":"address"}],"name":"addExcludedAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"allUserDepositIds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnLeftovers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"currentId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"enum TreasuryMine.Lock","name":"_lock","type":"uint8"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"depositIdIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"excludedAddresses","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getAllUserDepositIds","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum TreasuryMine.Lock","name":"_lock","type":"uint8"}],"name":"getBoost","outputs":[{"internalType":"uint256","name":"boost","type":"uint256"},{"internalType":"uint256","name":"timelock","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getExcludedAddresses","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvestAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_depositId","type":"uint256"}],"name":"harvestPosition","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"kill","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastRewardTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"magic","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"magicPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"magicTotalDeposits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMagicPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"pendingRewardsAll","outputs":[{"internalType":"uint256","name":"pending","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_depositId","type":"uint256"}],"name":"pendingRewardsPosition","outputs":[{"internalType":"uint256","name":"pending","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"include","type":"address"}],"name":"removeExcludedAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalLpToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRewardsEarned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryStake","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unlockAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"depositAmount","type":"uint256"},{"internalType":"uint256","name":"lpAmount","type":"uint256"},{"internalType":"uint256","name":"lockedUntil","type":"uint256"},{"internalType":"int256","name":"rewardDebt","type":"int256"},{"internalType":"enum TreasuryMine.Lock","name":"lock","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"utilization","outputs":[{"internalType":"uint256","name":"util","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAndHarvestAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_depositId","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawAndHarvestPosition","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_depositId","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawPosition","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000539bde0d7dbd336b79148aa742883198bbf60342000000000000000000000000d300322832765fee6b910d314f2c2d879427226f0000000000000000000000003d210e741cdedea81efcd9711ce7ef7fee45684b

-----Decoded View---------------
Arg [0] : _magic (address): 0x539bde0d7dbd336b79148aa742883198bbf60342
Arg [1] : _treasuryStake (address): 0xd300322832765fee6b910d314f2c2d879427226f
Arg [2] : _owner (address): 0x3d210e741cdedea81efcd9711ce7ef7fee45684b

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000539bde0d7dbd336b79148aa742883198bbf60342
Arg [1] : 000000000000000000000000d300322832765fee6b910d314f2c2d879427226f
Arg [2] : 0000000000000000000000003d210e741cdedea81efcd9711ce7ef7fee45684b


Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.