ETH Price: $3,073.75 (-1.32%)
Gas: 3 Gwei

Token

 

Overview

Max Total Supply

0

Holders

0

Total Transfers

-

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

-
Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information
# Exchange Pair Price  24H Volume % Volume

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0xD96AbC6f...6663BdA40
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
TypeAI

Compiler Version
v0.8.20+commit.a1b79de6

Optimization Enabled:
Yes with 200 runs

Other Settings:
paris EvmVersion
File 1 of 12 : Ownable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

File 2 of 12 : IERC20Permit.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

File 3 of 12 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

File 4 of 12 : SafeERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../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;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @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);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

File 5 of 12 : Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

File 6 of 12 : Context.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

File 7 of 12 : ReentrancyGuard.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

File 8 of 12 : EnumerableMap.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableMap.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableMap.js.

pragma solidity ^0.8.20;

import {EnumerableSet} from "./EnumerableSet.sol";

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * The following map types are supported:
 *
 * - `uint256 -> address` (`UintToAddressMap`) since v3.0.0
 * - `address -> uint256` (`AddressToUintMap`) since v4.6.0
 * - `bytes32 -> bytes32` (`Bytes32ToBytes32Map`) since v4.6.0
 * - `uint256 -> uint256` (`UintToUintMap`) since v4.7.0
 * - `bytes32 -> uint256` (`Bytes32ToUintMap`) since v4.7.0
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableMap, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableMap.
 * ====
 */
library EnumerableMap {
    using EnumerableSet for EnumerableSet.Bytes32Set;

    // To implement this library for multiple types with as little code repetition as possible, we write it in
    // terms of a generic Map type with bytes32 keys and values. The Map implementation uses private functions,
    // and user-facing implementations such as `UintToAddressMap` are just wrappers around the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit in bytes32.

    /**
     * @dev Query for a nonexistent map key.
     */
    error EnumerableMapNonexistentKey(bytes32 key);

    struct Bytes32ToBytes32Map {
        // Storage of keys
        EnumerableSet.Bytes32Set _keys;
        mapping(bytes32 key => bytes32) _values;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(Bytes32ToBytes32Map storage map, bytes32 key, bytes32 value) internal returns (bool) {
        map._values[key] = value;
        return map._keys.add(key);
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns (bool) {
        delete map._values[key];
        return map._keys.remove(key);
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) {
        return map._keys.contains(key);
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function length(Bytes32ToBytes32Map storage map) internal view returns (uint256) {
        return map._keys.length();
    }

    /**
     * @dev Returns the key-value pair stored at position `index` in the map. O(1).
     *
     * Note that there are no guarantees on the ordering of entries inside the
     * array, and it may change when more entries are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32ToBytes32Map storage map, uint256 index) internal view returns (bytes32, bytes32) {
        bytes32 key = map._keys.at(index);
        return (key, map._values[key]);
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool, bytes32) {
        bytes32 value = map._values[key];
        if (value == bytes32(0)) {
            return (contains(map, key), bytes32(0));
        } else {
            return (true, value);
        }
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bytes32) {
        bytes32 value = map._values[key];
        if (value == 0 && !contains(map, key)) {
            revert EnumerableMapNonexistentKey(key);
        }
        return value;
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(Bytes32ToBytes32Map storage map) internal view returns (bytes32[] memory) {
        return map._keys.values();
    }

    // UintToUintMap

    struct UintToUintMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToUintMap storage map, uint256 key, uint256 value) internal returns (bool) {
        return set(map._inner, bytes32(key), bytes32(value));
    }

    /**
     * @dev Removes a value from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToUintMap storage map, uint256 key) internal returns (bool) {
        return remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToUintMap storage map, uint256 key) internal view returns (bool) {
        return contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToUintMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the map. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintToUintMap storage map, uint256 index) internal view returns (uint256, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (uint256(key), uint256(value));
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(UintToUintMap storage map, uint256 key) internal view returns (bool, uint256) {
        (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
        return (success, uint256(value));
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToUintMap storage map, uint256 key) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(key)));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(UintToUintMap storage map) internal view returns (uint256[] memory) {
        bytes32[] memory store = keys(map._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
        return remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
        return contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the map. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (uint256(key), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(UintToAddressMap storage map) internal view returns (uint256[] memory) {
        bytes32[] memory store = keys(map._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressToUintMap

    struct AddressToUintMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(AddressToUintMap storage map, address key, uint256 value) internal returns (bool) {
        return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));
    }

    /**
     * @dev Removes a value from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(AddressToUintMap storage map, address key) internal returns (bool) {
        return remove(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(AddressToUintMap storage map, address key) internal view returns (bool) {
        return contains(map._inner, bytes32(uint256(uint160(key))));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(AddressToUintMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the map. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (address(uint160(uint256(key))), uint256(value));
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(AddressToUintMap storage map, address key) internal view returns (bool, uint256) {
        (bool success, bytes32 value) = tryGet(map._inner, bytes32(uint256(uint160(key))));
        return (success, uint256(value));
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(AddressToUintMap storage map, address key) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(uint256(uint160(key)))));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(AddressToUintMap storage map) internal view returns (address[] memory) {
        bytes32[] memory store = keys(map._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // Bytes32ToUintMap

    struct Bytes32ToUintMap {
        Bytes32ToBytes32Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(Bytes32ToUintMap storage map, bytes32 key, uint256 value) internal returns (bool) {
        return set(map._inner, key, bytes32(value));
    }

    /**
     * @dev Removes a value from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(Bytes32ToUintMap storage map, bytes32 key) internal returns (bool) {
        return remove(map._inner, key);
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool) {
        return contains(map._inner, key);
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(Bytes32ToUintMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the map. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32ToUintMap storage map, uint256 index) internal view returns (bytes32, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (key, uint256(value));
    }

    /**
     * @dev Tries to returns the value associated with `key`. O(1).
     * Does not revert if `key` is not in the map.
     */
    function tryGet(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool, uint256) {
        (bool success, bytes32 value) = tryGet(map._inner, key);
        return (success, uint256(value));
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(Bytes32ToUintMap storage map, bytes32 key) internal view returns (uint256) {
        return uint256(get(map._inner, key));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(Bytes32ToUintMap storage map) internal view returns (bytes32[] memory) {
        bytes32[] memory store = keys(map._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

File 9 of 12 : EnumerableSet.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

File 10 of 12 : ITypeAI.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// @author Raj Mazumder <[email protected]>
/// @title Interface of Type AI Staking Pool with fixed APY and lockup.
interface ITypeAI {
    /// @notice Details of the stake holder.
    struct StakeHolder {
        /// @param wallet The address of the stake holder.
        address wallet;
        /// @param amount The total amount stake holder deposited.
        uint256 amount;
        /// @param claimableInterest The claimable interest of the stake holder.
        uint256 claimableInterest;
        /// @param realizedETH The realized ETH for the stake holder.
        uint256 realizedETH;
        /// @param unrealizedETH The unrealized ETH for the stake holder.
        uint256 unrealizedETH;
        /// @param stakedOn The timestamp when stake holder staked.
        uint256 stakedOn;
        /// @param aprStartedOn The timestamp when last apr started.
        uint256 aprStartedOn;
    }

    /// READ METHODS ///
    /**
     * @notice Returns the no of stake holders currently staked.
     * @return count The count of the stake holders.
     */
    function noOfStakeHolders() external view returns (uint256 count);

    /**
     * @notice Returns the stake holders addresses currently staked.
     * @return holders The stake holder addresses.
     */
    function getStakeHolders() external view returns (address[] memory holders);

    /**
     * @notice Returns the details about the `_stakeHolder`.
     * @param _stakeHolder address of the stake holder.
     * @return details The details about the `_stakeHolder`.
     */
    function stakeHolderDetailsOf(
        address _stakeHolder
    ) external view returns (StakeHolder memory details);

    /**
     * @notice Returns the total amount staked by `stakeHolder`.
     * @param stakeHolder address of the stake holder.
     * @return stakedAmount the total amount staked.
     */
    function totalAmountStakedBy(
        address stakeHolder
    ) external view returns (uint256 stakedAmount);

    /**
     * @notice Returns the total amount locked on the contract.
     * @return tvl the total amount of tokens locked.
     */
    function totalValueLocked() external view returns (uint256 tvl);

    /**
     * @notice Returns the claimable token amount as interest by the `stakeHolder`.
     * @param stakeHolder address of the stake holder.
     * @return claimableInterest The amount of interest gained by `stakeHolder`.
     */
    function claimableInterestGainedBy(
        address stakeHolder
    ) external view returns (uint256 claimableInterest);

    /// WRITE METHODS ///

    /**
     * @notice Allows a stake holder to stake tokens.
     * @dev Stake holder must first approve the `_amount` to stake before calling this function.
     * @param _amount The amount to be deposited.
     * @dev That the `amount` deposited should greater than 0.
     */
    function stake(uint256 _amount) external;

    /**
     * @notice Allows a user to withdraw its initial deposit.
     * @param _amount The amount to withdraw.
     * @dev `_amount` must be higher than `0`.
     * @dev `_amount` must be lower or equal to the amount staked.
     * @dev Updating the stake holder details and claim rewards if rewards to claim.
     */
    function unstake(uint256 _amount) external;

    /**
     * @notice Claims pending tokens gained as interest.
     * @dev Transfers the gained tokens to the `msg.sender/caller`
     */
    function claimGainedInterest() external;

    /**
     * @notice Claims pending ETH reward and re lock the stake for another lock-in-period.
     * @dev Distribute ETH reward with no compound.
     */
    function claimETHAndReLock() external;

    /**
     * @notice Claims pending ETH reward and convert into `token` and then re-stake for another lock-in-period.
     * @dev Convert ETH reward to `token` and re invest.
     * @param _minReceive The min receive from dex.
     */
    function compoundETHAndReLock(uint256 _minReceive) external;

    /**
     * @notice Deposit ETH rewards into contract.
     * @dev Internally calls `_depositETHRewards`.
     */
    function depositETHRewards() external payable;

    /**
     * @notice Returns the realized ETH for the `_stakeHolder`
     * @param _stakeHolder The address of the stake holder.
     */
    function getRealizedETH(
        address _stakeHolder
    ) external view returns (uint256 realizedETH);

    /// EVENTS ///

    /**
     * @notice Emitted when `lockInPeriod` gets updated.
     * @param oldPeriod The previous lock in period.
     * @param newPeriod The new updated lock in period.
     */
    event LockInPeriodUpdated(uint256 indexed oldPeriod, uint256 newPeriod);

    /**
     * @notice Emitted when `fixedAPR` gets updated.
     * @param oldAPR The previous APR.
     * @param newAPR The new updated APR.
     */
    event APRUpdated(uint256 indexed oldAPR, uint256 newAPR);

    /**
     * @notice Emitted when `amount` tokens are deposited into pool contract.
     * @param stakeHolder The stake holder address who staked.
     * @param amount The amount stake holder staked.
     */
    event Deposited(address indexed stakeHolder, uint256 amount);

    /**
     * @notice Emitted when someone deposited ETH for reward distribution.
     * @param depositor The address of the depositor.
     * @param amount The amount of ETH deposited.
     */
    event DepositedETHRewards(address depositor, uint256 amount);

    /**
     * @notice Emitted when user withdraw deposited `amount`.
     * @param stakeHolder The stake holder address who withdrawn.
     * @param amount The amount stake holder withdrawn.
     */
    event Withdrawn(address indexed stakeHolder, uint256 amount);

    /**
     * @dev Emitted when `stakeHolder` claim their pending interest.
     * @param stakeHolder The stake holder address who claimed.
     * @param amount The amount of interest claimed.
     */
    event InterestClaimed(address indexed stakeHolder, uint256 amount);

    /**
     * @notice Emitted when `stakeHolder` claims ETH.
     * @param stakeHolder The stake holder address who claimed reward.
     * @param reward The amount of reward stakeHolder claimed.
     */
    event ETHRewardDistributed(address stakeHolder, uint256 reward);

    /// ERRORS ///

    error TypeAI__ZeroAddress(address caller);
    error TypeAI__ZeroAPR(address caller);

    /**
     * @notice Fired when a non stake holder trying to claims interest.
     * @param caller Address who is trying to claim.
     */
    error TypeAI__NotAStakeHolder(address caller);

    /**
     * @notice Fired when someone trying to deposit ETH but no stake available.
     * @param caller Address who is trying to deposit ETH.
     */
    error TypeAI_NoTVLAvailable(address caller);

    /**
     * @notice Fired when stake holder claims 0 interest.
     * @param stakeHolder Address who is trying to claim.
     */
    error TypeAI__NoInterestGained(address stakeHolder);

    /**
     * @notice Fired when stake holder trying to withdraw greater than his deposit.
     * @param stakeHolder Address who is trying to withdraw.
     */
    error TypeAI__InsufficientDepositAmount(address stakeHolder);

    /**
     * @notice Fired when owner trying to withdraw greater than residual balance.
     */
    error TypeAI__InsufficientResidualBalance();

    /**
     * @notice Fired when owner trying to withdraw greater than residual balance.
     */
    error TypeAI__ETHTransferFailed(address receiver, uint256 amount);

    /**
     * @notice Fired when owner trying to withdraw greater than residual balance.
     */
    error TypeAI__InvalidETHBalance(address receiver, uint256 amount);
    /**
     * @notice Fired when owner trying to withdraw reward while no reward available in the contract.
     * @param stakeHolder Address who is trying to claim.
     * @param required The required amount.
     */
    error TypeAI__InsufficientRewardPresent(
        address stakeHolder,
        uint256 required
    );

    /**
     * @notice Fired when stake holder trying to deposit 0 token.
     * @param stakeHolder Address who is trying to deposit.
     */
    error TypeAI__AmountMustBeGreaterThanZero(address stakeHolder);

    /**
     * @notice Fired when stake holder trying to withdraw tokens before
     * lock-in-period ends.
     * @param stakeHolder Address who is trying to withdraw.
     */
    error TypeAI__UnderLockInPeriod(address stakeHolder);
}

File 11 of 12 : IUniswapV2Router.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);

    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    )
        external
        payable
        returns (uint amountToken, uint amountETH, uint liquidity);

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);

    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint amountA, uint amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint amountToken, uint amountETH);

    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapExactETHForTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint[] memory amounts);

    function swapTokensForExactETH(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapExactTokensForETH(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);

    function swapETHForExactTokens(
        uint amountOut,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint[] memory amounts);

    function quote(
        uint amountA,
        uint reserveA,
        uint reserveB
    ) external pure returns (uint amountB);

    function getAmountOut(
        uint amountIn,
        uint reserveIn,
        uint reserveOut
    ) external pure returns (uint amountOut);

    function getAmountIn(
        uint amountOut,
        uint reserveIn,
        uint reserveOut
    ) external pure returns (uint amountIn);

    function getAmountsOut(
        uint amountIn,
        address[] calldata path
    ) external view returns (uint[] memory amounts);

    function getAmountsIn(
        uint amountOut,
        address[] calldata path
    ) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

File 12 of 12 : TypeAI.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

/// @title Implementation of Type AI Staking Pool with fixed APY and lockup.

/// @notice imports
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {EnumerableMap} from "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
/// Customs
import {ITypeAI} from "./interfaces/ITypeAI.sol";
import {IUniswapV2Router} from "./interfaces/IUniswapV2Router.sol";

contract TypeAI is ITypeAI, Ownable, ReentrancyGuard {
    /// Using the libraries.
    using SafeERC20 for IERC20;
    using EnumerableMap for EnumerableMap.AddressToUintMap;

    /// @notice STATE VARIABLES ///
    uint256 constant MULTIPLIER = 1e36;

    /// Holds the current fixed APR going on.
    uint256 public fixedAPR;
    /// Holds The current lock in period going on.
    uint256 public lockInPeriod;
    /// Holds the amount of token locked in the contract.
    uint256 private _totalValueLocked;
    /// Holds the total ETH deposited for reward.
    uint256 public totalETHDeposited;
    /// Holds the ETH amount per share as reward.
    uint256 public ethRewardsPerShare;
    /// Holds the total reward distributed among the stake holders.
    uint256 public totalRewardsDistributed;
    /// Holds the token address which is being staked.
    IERC20 public immutable token;
    /// Holds the dex router address.
    IUniswapV2Router immutable _router;

    /// Mapping between stakeHolder address to their details.
    mapping(address stakeHolder => StakeHolder details)
        private _stakeHolderDetailsOf;
    /// Map for tacking the stake holders.
    EnumerableMap.AddressToUintMap private _stakeHoldersMap;

    /// @notice Constructor ///

    /**
     * @notice constructor contains all the parameters of the staking platform.
     * @param _token The address of the token to be staked.
     * @param _fixedAPR The fixed APY (in %) 10 = 10%, 50 = 50%.
     * @param _lockInPeriod The lock in period in seconds.
     * @param router_ The UniswapV2 router address.
     */
    constructor(
        address _token,
        uint256 _fixedAPR,
        uint256 _lockInPeriod,
        address router_
    ) Ownable(_msgSender()) {
        /// validations
        if (_token == address(0) || (router_ == address(0)))
            revert TypeAI__ZeroAddress(msg.sender);
        if (_fixedAPR == 0) revert TypeAI__ZeroAPR(msg.sender);

        /// Updating the state.
        token = IERC20(_token);
        fixedAPR = _fixedAPR;
        lockInPeriod = _lockInPeriod;
        _router = IUniswapV2Router(router_);

        /// Emitting Events.
        emit APRUpdated(0, _fixedAPR);
        emit LockInPeriodUpdated(0, _lockInPeriod);
    }

    /// @notice READ METHODS ///

    /**
     * @notice Returns the no of stake holders currently staked.
     * @return count The count of the stake holders.
     */
    function noOfStakeHolders() public view returns (uint256 count) {
        return _stakeHoldersMap.length();
    }

    /**
     * @notice Returns the details about the `stakeHolder`.
     * @param stakeHolder address of the stake holder.
     * @return details The details about the `stakeHolder`.
     */
    function stakeHolderDetailsOf(
        address stakeHolder
    ) public view returns (StakeHolder memory details) {
        return _stakeHolderDetailsOf[stakeHolder];
    }

    /**
     * @notice Returns the total amount staked by `stakeHolder`.
     * @param stakeHolder address of the stake holder.
     * @return stakedAmount the total amount staked by `stakeHolder`.
     */
    function totalAmountStakedBy(
        address stakeHolder
    ) public view returns (uint256 stakedAmount) {
        return _stakeHolderDetailsOf[stakeHolder].amount;
    }

    /**
     * @notice Returns the total amount of `token` locked in the contract.
     * @return tvl the total amount of tokens locked.
     */
    function totalValueLocked() public view returns (uint256 tvl) {
        return _totalValueLocked;
    }

    /**
     * @notice Returns the claimable token amount as interest by the `stakeHolder`.
     * @param stakeHolder address of the stake holder.
     * @return claimableInterest The amount of interest gained by `stakeHolder`.
     */
    function claimableInterestGainedBy(
        address stakeHolder
    ) public view returns (uint256 claimableInterest) {
        return _calculateInterestGainedBy(stakeHolder);
    }

    /**
     * @notice Returns the realized ETH for the `stakeHolder`
     * @param stakeHolder The address of the stake holder.
     */
    function getRealizedETH(
        address stakeHolder
    ) public view returns (uint256 realizedETH) {
        /// Getting the stake holder details as memory.
        StakeHolder memory _holderDetails = _stakeHolderDetailsOf[stakeHolder];
        /// If stakeholder has no investment return.
        if (_holderDetails.amount == 0) return 0;

        /// Calculate and return realized ETH.
        uint256 earnedRewards = _cumulativeETHRewards(_holderDetails.amount);
        if (earnedRewards <= _holderDetails.unrealizedETH) return 0;
        return earnedRewards - _holderDetails.unrealizedETH;
    }

    /**
     * @notice Returns the stake holders addresses currently staked.
     * @return holders The stake holder addresses.
     */
    function getStakeHolders() public view returns (address[] memory holders) {
        /// Getting the no of stake holders.
        uint256 _noOfStakeHolders = _stakeHoldersMap.length();
        /// Adding stake holders into memory array.
        address[] memory _stakeHolders = new address[](_noOfStakeHolders);
        for (uint256 index; index < _noOfStakeHolders; index++) {
            (address _stakeHolder, ) = _stakeHoldersMap.at(index);
            _stakeHolders[index] = _stakeHolder;
        }
        // return _stakeHoldersMap.
        return _stakeHolders;
    }

    /// @notice WRITE METHODS ///

    /**
     * @notice Allows the owner to set the APY
     * @param newAPR, the new APY to be set (in %) 10 = 10%, 50 = 50
     */
    function updateAPR(uint8 newAPR) public onlyOwner {
        /// Change the APR
        uint256 _oldAPR = fixedAPR;
        fixedAPR = newAPR;
        /// Emitting `APRUpdated` event.
        emit APRUpdated(_oldAPR, newAPR);
    }

    /**
     * @notice Allows the owner to set the lock in period.
     * @param newLockInPeriod The new lock in period in seconds.
     */
    function updateLockInPeriod(uint256 newLockInPeriod) public onlyOwner {
        /// Change the Lock in period.
        uint256 _oldLockInPeriod = lockInPeriod;
        lockInPeriod = newLockInPeriod;
        /// Emitting `LockInPeriodUpdated` event.
        emit LockInPeriodUpdated(_oldLockInPeriod, newLockInPeriod);
    }

    /**
     * @notice Allows a stake holder to stake tokens.
     * @dev Internally calls `_stake` function.
     * @param amount The amount to be deposited.
     */
    function stake(uint256 amount) public nonReentrant {
        _stake(amount);
    }

    /**
     * @notice Allows a user to withdraw its initial deposit.
     * @param amount The amount to withdraw.
     * @dev `amount` must be higher than `0`.
     * @dev `amount` must be lower or equal to the amount staked.
     * @dev Updating the stake holderVARIABLES claim rewards if rewards to claim.
     */
    function unstake(uint256 amount) public nonReentrant {
        /// Getting the stake holder details as storage.
        StakeHolder storage _stakeHolder = _stakeHolderDetailsOf[_msgSender()];

        /// Validations
        if (_stakeHolder.wallet == address(0))
            revert TypeAI__NotAStakeHolder(_msgSender());
        if ((_stakeHolder.stakedOn + lockInPeriod) >= block.timestamp)
            revert TypeAI__UnderLockInPeriod(_stakeHolder.wallet);
        if (amount == 0)
            revert TypeAI__AmountMustBeGreaterThanZero(_stakeHolder.wallet);
        if (amount > _stakeHolder.amount)
            revert TypeAI__InsufficientDepositAmount(_stakeHolder.wallet);

        /// TOKEN APR ///
        /// Updating the claimable interest
        _updateClaimableInterestOf(_stakeHolder.wallet);
        /// Claim interest If any claim amount available.
        if (_stakeHolder.claimableInterest > 0)
            _claimGainedInterest(_stakeHolder.wallet);

        /// Distribute ETH REWARDS ///
        uint256 _realizedETH = getRealizedETH(_stakeHolder.wallet);
        bool _otherStakersPresent = (_totalValueLocked - amount) > 0;
        if (!_otherStakersPresent) {
            _distributeETHRewards(_stakeHolder.wallet, false, 0);
        }

        /// Updating the TVL & stake holder balance.
        _totalValueLocked -= amount;
        _stakeHolder.amount -= amount;

        /// Update ETH Rewards per share ///
        _updateUnrealizedETHRewardsOf(_stakeHolder.wallet);
        if (_otherStakersPresent && (_realizedETH > 0))
            _depositETHRewards(_realizedETH);

        /// Removing from stake holders map.
        if (_stakeHolder.amount == 0)
            _stakeHoldersMap.remove(_stakeHolder.wallet);

        /// Transferring the tokens.
        token.safeTransfer(_stakeHolder.wallet, amount);
        /// Emitting `Withdrawn` event.
        emit Withdrawn(_stakeHolder.wallet, amount);
    }

    /**
     * @notice Claim all remaining balance on the contract
     * Residual balance is all the remaining tokens that have not been distributed
     * (e.g, in case the number of stakeholders is not sufficient)
     * @dev Can only be called after the end of the staking period
     * Cannot claim initial stakeholders deposit
     */
    function withdrawResidualBalance() public onlyOwner nonReentrant {
        uint256 residualBalance = token.balanceOf(address(this)) -
            _totalValueLocked;
        if (residualBalance == 0) revert TypeAI__InsufficientResidualBalance();
        /// Transfer the tokens.
        token.safeTransfer(_msgSender(), residualBalance);
    }

    /**
     * @notice Claims pending tokens gained as interest.
     * @dev Transfers the gained tokens to the `msg.sender/caller`
     */
    function claimGainedInterest() public nonReentrant {
        /// Validation for unknown caller.
        if (_stakeHolderDetailsOf[_msgSender()].wallet == address(0))
            revert TypeAI__NotAStakeHolder(_msgSender());
        /// Claim interest.
        _claimGainedInterest(_msgSender());
    }

    /**
     * @notice Claims pending ETH reward and re lock the stake for another lock-in-period.
     * @dev Distribute ETH reward with no compound.
     */
    function claimETHAndReLock() public nonReentrant {
        _distributeETHRewards(_msgSender(), false, 0);
    }

    /**
     * @notice Claims pending ETH reward and convert into `token` and then re-stake for another lock-in-period.
     * @dev Convert ETH reward to `token` and re invest.
     * @param _minReceive The min receive from dex.
     */
    function compoundETHAndReLock(uint256 _minReceive) public nonReentrant {
        _distributeETHRewards(_msgSender(), true, _minReceive);
    }

    /**
     * @notice Deposit ETH rewards into contract.
     * @dev Internally calls `_depositETHRewards`.
     */
    function depositETHRewards() public payable nonReentrant {
        _depositETHRewards(msg.value);
    }

    /// @notice Private Functions ///

    /**
     * @notice Returns the ETH reward amount based on `_share`.
     * @param _share The share/deposited amount of the stake holder.
     */
    function _cumulativeETHRewards(
        uint256 _share
    ) private view returns (uint256 ethRewards) {
        return (_share * ethRewardsPerShare) / MULTIPLIER;
    }

    /**
     * @notice Deposit ETH for giving reward to others.
     * @param _amountETH The amount of ETH wants to distribute.
     */
    function _depositETHRewards(uint256 _amountETH) private {
        /// Validations
        if (_amountETH == 0)
            revert TypeAI__AmountMustBeGreaterThanZero(_msgSender());
        if (_totalValueLocked == 0) revert TypeAI_NoTVLAvailable(_msgSender());

        /// Recalculate eth per share.
        totalETHDeposited += _amountETH;
        ethRewardsPerShare += (MULTIPLIER * _amountETH) / _totalValueLocked;
        /// Emit `DepositedETHRewards` event.
        emit DepositedETHRewards(_msgSender(), _amountETH);
    }

    /**
     * @notice Swap ETH for `token` into Uniswap and then reinvest.
     * @param _amount The amount of ETH wanted to swap.
     * @param _minTokensToReceive The minimum receivable `token` amount for ETH.
     */
    function _compoundETHRewards(
        uint256 _amount,
        uint256 _minTokensToReceive
    ) private {
        /// Setting up the swap path.
        address[] memory path = new address[](2);
        path[0] = _router.WETH();
        path[1] = address(token);

        /// Swap ETH for `token`
        uint256 _tokenBalBefore = token.balanceOf(address(this));
        _router.swapExactETHForTokensSupportingFeeOnTransferTokens{
            value: _amount
        }(_minTokensToReceive, path, address(this), block.timestamp);

        /// Reinvest the compound amount.
        uint256 _compoundAmount = token.balanceOf(address(this)) -
            _tokenBalBefore;
        _stake(_compoundAmount);
    }

    /**
     * @notice Distribute ETH reward to `stakeHolder`.
     * @param stakeHolder The stake holder address to whom rewards distributed.
     * @param isReinvest If stake holder wants to reinvest ETH.
     * @param minReceive Minimum receivable for dex if stake holder wants to reinvest.
     */
    function _distributeETHRewards(
        address stakeHolder,
        bool isReinvest,
        uint256 minReceive
    ) private {
        /// Getting the stake holder details as memory.
        StakeHolder storage _holderDetails = _stakeHolderDetailsOf[stakeHolder];
        /// If stakeholder has no investment return.
        if (_holderDetails.amount == 0) return;

        /// Updating stake holder details.
        uint256 _realizedETH = getRealizedETH(_holderDetails.wallet);
        _holderDetails.realizedETH += _realizedETH;
        _holderDetails.stakedOn = block.timestamp; /// Re lock.
        _updateUnrealizedETHRewardsOf(_holderDetails.wallet);

        if (_realizedETH > 0) {
            /// Updating the total reward distributed.
            totalRewardsDistributed += _realizedETH;

            /// Compound and reinvest.
            if (isReinvest)
                _compoundETHRewards(_realizedETH, minReceive);
                /// Claim normal ETH rewards.
            else {
                /// Transferring the ETH.
                uint256 _ethBalanceBefore = address(this).balance;
                (bool success, ) = payable(_holderDetails.wallet).call{
                    value: _realizedETH
                }("");
                /// Validations
                if (!success)
                    revert TypeAI__ETHTransferFailed(
                        _holderDetails.wallet,
                        _realizedETH
                    );
                if (address(this).balance < (_ethBalanceBefore - _realizedETH))
                    revert TypeAI__InvalidETHBalance(
                        _holderDetails.wallet,
                        _realizedETH
                    );
            }

            /// Emitting `ETHRewardDistributed` event.
            emit ETHRewardDistributed(_holderDetails.wallet, _realizedETH);
        }
    }

    /**
     * @notice Allows a stake holder to stake tokens.
     * @dev Stake holder must first approve the `_amount` to stake before calling this function.
     * @param _amount The amount to be deposited.
     * @dev That the `amount` deposited should greater than 0.
     */
    function _stake(uint256 _amount) private {
        /// Validations
        if (_amount == 0)
            revert TypeAI__AmountMustBeGreaterThanZero(_msgSender());

        /// Transferring the tokens.
        token.safeTransferFrom(_msgSender(), address(this), _amount);

        /// Getting the stake holder details as storage.
        StakeHolder storage _stakeHolder = _stakeHolderDetailsOf[_msgSender()];

        /// If stake holder is staking for the first time.
        if (_stakeHolder.wallet == address(0))
            _stakeHolder.wallet = _msgSender();
        if (_stakeHolder.aprStartedOn == 0)
            _stakeHolder.aprStartedOn = block.timestamp;

        /// Update the interest of stake holder
        _updateClaimableInterestOf(_stakeHolder.wallet);

        // Distribute ETH Rewards.
        if (_stakeHolder.amount > 0)
            _distributeETHRewards(_stakeHolder.wallet, false, 0);

        /// Updating the TVL, stake holder balance & address.
        _totalValueLocked += _amount;
        _stakeHolder.amount += _amount;
        _stakeHolder.stakedOn = block.timestamp;
        /// Adding into stake holders map.
        _stakeHoldersMap.set(_stakeHolder.wallet, _amount);

        /// ETH Rewards
        _updateUnrealizedETHRewardsOf(_stakeHolder.wallet);

        /// Emitting `Deposited` event.
        emit Deposited(_stakeHolder.wallet, _amount);
    }

    /**
     * @notice Calculate the gained interest based on the `fixedAPR`.
     * @param _stakeHolder The address of the stake holder.
     * @return claimableInterest amount of claimable tokens as interest of the `_stakeHolder`
     */
    function _calculateInterestGainedBy(
        address _stakeHolder
    ) private view returns (uint256 claimableInterest) {
        /// Getting the stake holder details as memory.
        StakeHolder memory _holderDetails = _stakeHolderDetailsOf[_stakeHolder];

        /// Calculating the staking duration.
        uint256 _stakingDuration = block.timestamp -
            _holderDetails.aprStartedOn;
        /// Returns the claimable interest.
        return
            ((_holderDetails.amount * fixedAPR * _stakingDuration) /
                365 days /
                100) + _holderDetails.claimableInterest;
    }

    /**
     * @notice Claims pending interest.
     * @dev Transfer the pending interest to the `_stakeHolder` address.
     * @param _stakeHolder The address of the stake holder.
     */
    function _claimGainedInterest(address _stakeHolder) private {
        /// Getting the stake holder details as storage.
        StakeHolder storage _holderDetails = _stakeHolderDetailsOf[
            _stakeHolder
        ];
        /// @dev Updating the claimable interest.
        _updateClaimableInterestOf(_stakeHolder);

        /// @dev Checking if any claimable amount available.
        uint256 _claimableInterest = _holderDetails.claimableInterest;
        if (_claimableInterest == 0)
            revert TypeAI__NoInterestGained(_stakeHolder);

        if (token.balanceOf(address(this)) < _claimableInterest)
            revert TypeAI__InsufficientRewardPresent(
                _stakeHolder,
                _claimableInterest
            );
        if (
            (token.balanceOf(address(this)) - _claimableInterest) <
            _totalValueLocked
        )
            revert TypeAI__InsufficientRewardPresent(
                _stakeHolder,
                _claimableInterest
            );

        /// Removing the claimable amount.
        delete _holderDetails.claimableInterest;

        /// @dev Transfer the interest and emitting the event.
        token.safeTransfer(_stakeHolder, _claimableInterest);
        /// Emitting `InterestClaimed` event.
        emit InterestClaimed(_stakeHolder, _claimableInterest);
    }

    /**
     * @notice Updates gained interest and shift them to `rewardsToClaim`
     * @dev Recalculate the gained amount and resetting the stake time.
     */
    function _updateClaimableInterestOf(address _stakeHolder) private {
        /// Getting the stake holder details as storage.
        StakeHolder storage _holderDetails = _stakeHolderDetailsOf[
            _stakeHolder
        ];

        /// @dev Recalculating the claimable amount of `_stakeHolder`.
        _holderDetails.claimableInterest = _calculateInterestGainedBy(
            _stakeHolder
        );
        /// @dev Resetting the stake time.
        _holderDetails.aprStartedOn = block.timestamp;
    }

    /**
     * @notice Updates gained interest and shift them to `rewardsToClaim`
     * @dev Recalculate the gained amount and resetting the stake time.
     */
    function _updateUnrealizedETHRewardsOf(address _stakeHolder) private {
        /// Getting the stake holder details as storage.
        StakeHolder storage _holderDetails = _stakeHolderDetailsOf[
            _stakeHolder
        ];

        /// @dev Recalculating the unrealized ETH amount of `_stakeHolder`.
        _holderDetails.unrealizedETH = _cumulativeETHRewards(
            _holderDetails.amount
        );
    }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_fixedAPR","type":"uint256"},{"internalType":"uint256","name":"_lockInPeriod","type":"uint256"},{"internalType":"address","name":"router_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"TypeAI_NoTVLAvailable","type":"error"},{"inputs":[{"internalType":"address","name":"stakeHolder","type":"address"}],"name":"TypeAI__AmountMustBeGreaterThanZero","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TypeAI__ETHTransferFailed","type":"error"},{"inputs":[{"internalType":"address","name":"stakeHolder","type":"address"}],"name":"TypeAI__InsufficientDepositAmount","type":"error"},{"inputs":[],"name":"TypeAI__InsufficientResidualBalance","type":"error"},{"inputs":[{"internalType":"address","name":"stakeHolder","type":"address"},{"internalType":"uint256","name":"required","type":"uint256"}],"name":"TypeAI__InsufficientRewardPresent","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TypeAI__InvalidETHBalance","type":"error"},{"inputs":[{"internalType":"address","name":"stakeHolder","type":"address"}],"name":"TypeAI__NoInterestGained","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"TypeAI__NotAStakeHolder","type":"error"},{"inputs":[{"internalType":"address","name":"stakeHolder","type":"address"}],"name":"TypeAI__UnderLockInPeriod","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"TypeAI__ZeroAPR","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"TypeAI__ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"oldAPR","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newAPR","type":"uint256"}],"name":"APRUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakeHolder","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DepositedETHRewards","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"stakeHolder","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"ETHRewardDistributed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"stakeHolder","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"InterestClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"oldPeriod","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPeriod","type":"uint256"}],"name":"LockInPeriodUpdated","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":"stakeHolder","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[],"name":"claimETHAndReLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimGainedInterest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakeHolder","type":"address"}],"name":"claimableInterestGainedBy","outputs":[{"internalType":"uint256","name":"claimableInterest","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minReceive","type":"uint256"}],"name":"compoundETHAndReLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositETHRewards","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"ethRewardsPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fixedAPR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakeHolder","type":"address"}],"name":"getRealizedETH","outputs":[{"internalType":"uint256","name":"realizedETH","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStakeHolders","outputs":[{"internalType":"address[]","name":"holders","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockInPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"noOfStakeHolders","outputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakeHolder","type":"address"}],"name":"stakeHolderDetailsOf","outputs":[{"components":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"claimableInterest","type":"uint256"},{"internalType":"uint256","name":"realizedETH","type":"uint256"},{"internalType":"uint256","name":"unrealizedETH","type":"uint256"},{"internalType":"uint256","name":"stakedOn","type":"uint256"},{"internalType":"uint256","name":"aprStartedOn","type":"uint256"}],"internalType":"struct ITypeAI.StakeHolder","name":"details","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakeHolder","type":"address"}],"name":"totalAmountStakedBy","outputs":[{"internalType":"uint256","name":"stakedAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalETHDeposited","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRewardsDistributed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalValueLocked","outputs":[{"internalType":"uint256","name":"tvl","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"newAPR","type":"uint8"}],"name":"updateAPR","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newLockInPeriod","type":"uint256"}],"name":"updateLockInPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawResidualBalance","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Loading...
Loading
[ Download: CSV Export  ]

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.