Contract 0xdf19f1216aa406df8bc585246bee7d96933f285f 2

 

Contract Overview

Balance:
0 ETH

ETH Value:
$0.00

Token:
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xc6cab3db42f5b5b031c5e2ffd21a28baa2e116fed56db19168f3d9b028abb4b4Harvest All47731432022-01-18 21:44:421 min ago0x6edb6b84818d063f75cca425ae19d4469d8c725e IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000794191015 ETH
0xf40da6a64d2b67027580a38eb9ff24f2c24727aefef8bb3be0317025beaf09a3Harvest All47731212022-01-18 21:44:062 mins ago0x0281208ed5739fa208e9ed895481ca8d2830ada2 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000765741237 ETH
0xafba52ff27862a4f5ada89fb51bdab46b542f120eed93a2661b0afcb44301fb8Withdraw Positio...47730872022-01-18 21:43:153 mins ago0x0281208ed5739fa208e9ed895481ca8d2830ada2 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000816868174 ETH
0x873936c67034e5ff8eeae117fd643e19b3fc3b8a65dfb305ac242b174579dcd8Harvest All47730022022-01-18 21:40:335 mins ago0x1297ad486549a430d59d9d5f99ed7c216b6e77dd IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000770973896 ETH
0x6fd63f7f34738e81d6035f58bd27b934bdbaf1a166a7df8617135580d0a3301bHarvest All47728562022-01-18 21:38:018 mins ago0x7f39df5a8f7bd229c8cb8bc6da940c42ede23e91 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000765126443 ETH
0xf0b207a192d668de770bf1363ab6df075151e9670d8156ade8f288a36ce04db1Harvest All47728152022-01-18 21:37:069 mins ago0x7d9f4a3ab2568f61c9087a8b5506dfcd5e8fea49 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000880297904 ETH
0x105031405eeccf7dda31cc9f6abf7488c3285af0e77fb6beea8785750f47fd60Harvest All47727322022-01-18 21:35:0211 mins ago0x68cbab0a40eb9fb39d4caa0067ff17158f833425 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000891964028 ETH
0xb2f9f5c07fa8d2334096a642bb46d00fdc19c5cb5b18f89b600de472341f4ce1Harvest All47723472022-01-18 21:25:5220 mins ago0x5f527d60ba42c3515e6a221d0db375a11b965631 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.001024472918 ETH
0xb756e10ccac50aec0bcbabc8918fffe8c2c67f9d2914d77c504f6aa965b472d6Harvest All47721472022-01-18 21:20:0426 mins ago0x154c08be7f1a96f0a71c467745065691baa36d45 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000886164929 ETH
0x12ba2e89910da3f3e5877c6cef636446fdec12efcd71087d96f37c513c4109f6Withdraw Positio...47718932022-01-18 21:12:5433 mins ago0xeb20b344612e8825ca07206f40f2b88e5afd5dd3 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000815259807 ETH
0x52b3e6c49fd7eae04752976f3a55feea71dcb3f90c9e3cc6cf4232eed54b0ba1Harvest All47718812022-01-18 21:12:3033 mins ago0x050920eda4014e25ded17c346b425239a468d63d IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000758964684 ETH
0x9c96f4689a95281554e3609a744dcab6980c8bc88e32539a545dd6a763f1f79fHarvest All47718772022-01-18 21:11:5834 mins ago0xeb20b344612e8825ca07206f40f2b88e5afd5dd3 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.00076006763 ETH
0xa16fc241d6080e922e13d5a14545f3475b7fa6c10c56add4ed655b0738b4f011Withdraw Positio...47718652022-01-18 21:11:5834 mins ago0x050920eda4014e25ded17c346b425239a468d63d IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.00092730664 ETH
0x48e2094706ebac10ad04f16cf6cd7d6ce92624f72e159df20496b4be27646e8cHarvest All47717412022-01-18 21:06:2539 mins ago0x37205a67ad46ea0097ecfd900a89a1550127a249 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000875741849 ETH
0x084f2c17495dbb6322278726cc6348daa2fbf21db03b138f8c3e03ee43931469Harvest All47716992022-01-18 21:03:2642 mins ago0x2b5321c1afddfb6680aafff4df96a209e18dea1c IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.001030127995 ETH
0x8ad372326a3e348e294a4d3f88a1e2f9d9eff9e5019e4b5046e4d6d98bdb545cHarvest All47715892022-01-18 20:58:2647 mins ago0x747197638a7af760e221636405c747aab7952cc6 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000773497204 ETH
0x7ea456943776381be9b9df6e2f5758817de269079c189bf0365cebacc6fdb988Harvest All47715712022-01-18 20:56:5249 mins ago0x09b4f701fafa04f4db1a9458ee059d0aa7248b2d IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000783420485 ETH
0x5f753ba96dcd74e2d01df9ad350fb6afd1a17a2bfdb4704ac5f7a712171a4945Withdraw Positio...47715462022-01-18 20:55:2850 mins ago0x09b4f701fafa04f4db1a9458ee059d0aa7248b2d IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000809121612 ETH
0xb39a8e6ea7cb9ce4ed2a15aca897355773a50a1ddd087a75d66bdc3c684c56cdWithdraw Positio...47714602022-01-18 20:49:1057 mins ago0xb03be385f4da2b881f0215dc780b26a6e65fc0bd IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000813304586 ETH
0x3723cd8098319e92c66499d667eeb379680f7a5efcd87720faab4f07914c9932Withdraw Positio...47713722022-01-18 20:44:081 hr 2 mins ago0xce3d3fbb42d4e960f9cb068c3a65242a269feea5 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000797642052 ETH
0x731b097db092d622c751e5f1e3e0658c6c439f4c3bba660bcbf20fc3b50b80b2Withdraw Positio...47713692022-01-18 20:44:081 hr 2 mins ago0xce3d3fbb42d4e960f9cb068c3a65242a269feea5 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000796015915 ETH
0xfb4ef360636fb44e2c234f1a25f9496978a1cfa91379abbf57ba63432f1bb805Withdraw Positio...47713672022-01-18 20:44:081 hr 2 mins ago0xce3d3fbb42d4e960f9cb068c3a65242a269feea5 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000804140925 ETH
0xb97aeb8e95c08aec33eddc26e26ebb088281c024b997ff8b5d87be900ffa8141Withdraw Positio...47713542022-01-18 20:43:121 hr 3 mins ago0xc9b378a35c6c2e9971f74b0a75662aa664b3f391 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.00092195073 ETH
0xfcf3517307cf6f41ab0a3585e41a411dd8a8904b9f411a4620f9dfd83190ef0aHarvest All47713452022-01-18 20:41:391 hr 4 mins ago0xce3d3fbb42d4e960f9cb068c3a65242a269feea5 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000903756613 ETH
0x0af04466d797f4c3ed908566d3cb51e6d6e7bf53588a813d1346a657319f4964Withdraw Positio...47713172022-01-18 20:40:291 hr 5 mins ago0xc9b378a35c6c2e9971f74b0a75662aa664b3f391 IN  0xdf19f1216aa406df8bc585246bee7d96933f285f0 ETH0.000921980255 ETH
[ Download CSV Export 
Parent Txn Hash Block From To Value
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
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.