Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
•    - function _reentrancyGuardEntered()
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(bool succes ...
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• interface IERC20Errors
• interface IERC721Errors
• interface IERC1155Errors
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
•    - function _transfer(address from, addr ...
•    - function _update(address from, addres ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _approve(address owner, addr ...
•    - function _spendAllowance(address owne ...
• interface IBTC
•    - function claimtokenRebase(address _ad ...
•  contract ETF is ERC20("ET ... *
•    - function burn(uint256 _amount)
•    - function setceil(uint256 _bondCap)
•    - function _setceil(uint256 _bondCap)
•    - function setbondPrice(uint256 _bondPr ...
•    - function setvestingTime(uint256 _peri ...
•    - function canclaimTokens(address _addr ...
•    - function setOpenbond(bool _bondOpen)
•    - function recoverTreasuryTokens()
•    - function bond(uint256 _amount)
•    - function claim()
•    - function remainingbondableTokens()
•    - function remainingVestedTime(address ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-01-11
*/

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

    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
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // 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: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: @openzeppelin/contracts/utils/Address.sol


// 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: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol


// 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: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.0) (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;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @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: @openzeppelin/contracts/token/ERC20/IERC20.sol


// 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: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




/**
 * @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: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


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

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

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// File: etf.sol



pragma solidity ^0.8.12;






interface IBTC {
     function claimtokenRebase(address _address, uint256 amount) external;
}

contract ETF is ERC20("ETF", "ETF"), Ownable(msg.sender) , ReentrancyGuard{ 
    
    
    struct UserInfo  {
        uint256 totalbonded;
        uint256 finalInteractionBlock;
        uint256 VestTime;
    }

 
    IBTC BTC;
    constructor(address _BTC) {
        _mint(msg.sender, 0 * 10 ** decimals());
        _setceil(0e18);
        BTC = IBTC(_BTC);
    }
    mapping(address => UserInfo) public userInfo;
    using SafeERC20 for IERC20;
    using SafeMath for uint256;



    uint256 public bondPrice = 1000;
    uint256 public bondCap = 0;
    uint256 public vestingTime = 5 days;
    bool public bondOpen = false;
    IERC20 public USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);


    function burn(uint256 _amount) external  {
        _burn(msg.sender, _amount);
    }

    function setceil(uint256 _bondCap) external onlyOwner {
        bondCap = _bondCap;
    }

    function _setceil(uint256 _bondCap) internal {
        bondCap = _bondCap;
    }

    
    function setbondPrice(uint256 _bondPrice) external onlyOwner {
       
        bondPrice = _bondPrice;
    }

    function setvestingTime(uint256 _period) external onlyOwner {
        require(_period >= 0 days &&_period <=30 days);
        vestingTime = _period;
    }

    function canclaimTokens(address _address) external view returns(uint256) {
        uint256 durationPass = block.timestamp.sub(userInfo[_address].finalInteractionBlock);
        uint256 canclaim;
        if (durationPass >= userInfo[_address].VestTime){
            canclaim = userInfo[_address].totalbonded;
        }
        else {
            canclaim = userInfo[_address].totalbonded.mul(durationPass).div(userInfo[_address].VestTime);
        }
        return canclaim;
    }


    function setOpenbond(bool _bondOpen) external onlyOwner {
        bondOpen = _bondOpen;
    }

    function recoverTreasuryTokens() external onlyOwner {
        USDC.safeTransfer(owner(), USDC.balanceOf(address(this)));
    }


    function bond(uint256 _amount) external nonReentrant {

        require(_amount <= 5000000000, "max 5000");
        require(bondOpen, "bnot opened");
        require(USDC.balanceOf(msg.sender) >= _amount, "USDC b too low");
        uint256 _amountin = _amount.mul(10**12);
        uint256 amountOut = _amountin.mul(1000).div(bondPrice);
        
        require(this.totalSupply().add(amountOut) <= bondCap, "over bond cap");
        userInfo[msg.sender].totalbonded = userInfo[msg.sender].totalbonded.add(amountOut);
        userInfo[msg.sender].finalInteractionBlock = block.timestamp;
        userInfo[msg.sender].VestTime = vestingTime;

        _mint(address(this), amountOut);
        USDC.safeTransferFrom(msg.sender, address(this), _amount);
    }

    function claim() external nonReentrant {

        require(userInfo[msg.sender].totalbonded > 0, "no bond");
        uint256 durationPass = block.timestamp.sub(userInfo[msg.sender].finalInteractionBlock);
        uint256 canclaim;
        if (durationPass >= userInfo[msg.sender].VestTime){
            canclaim = userInfo[msg.sender].totalbonded;
            userInfo[msg.sender].VestTime = 0;
        }
        else {
            canclaim = userInfo[msg.sender].totalbonded.mul(durationPass).div(userInfo[msg.sender].VestTime);
            userInfo[msg.sender].VestTime = userInfo[msg.sender].VestTime.sub(durationPass);
            
        }
        userInfo[msg.sender].totalbonded = userInfo[msg.sender].totalbonded.sub(canclaim);
        userInfo[msg.sender].finalInteractionBlock = block.timestamp;

        this.burn(canclaim);
        BTC.claimtokenRebase(msg.sender, canclaim);
    }

    function remainingbondableTokens() external view returns(uint256){
        
        return bondCap.sub(this.totalSupply());
    }

    function remainingVestedTime(address _address) external view returns(uint256){
        uint256 durationPass = block.timestamp.sub(userInfo[_address].finalInteractionBlock);
        if (durationPass >= userInfo[_address].VestTime){
            return 0;
        }
        else {
            return userInfo[_address].VestTime.sub(durationPass);
        }
        
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_BTC","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":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","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":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"USDC","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"bond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bondCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bondOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bondPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"canclaimTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"recoverTreasuryTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"remainingVestedTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remainingbondableTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_bondOpen","type":"bool"}],"name":"setOpenbond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_bondPrice","type":"uint256"}],"name":"setbondPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_bondCap","type":"uint256"}],"name":"setceil","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_period","type":"uint256"}],"name":"setvestingTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"totalbonded","type":"uint256"},{"internalType":"uint256","name":"finalInteractionBlock","type":"uint256"},{"internalType":"uint256","name":"VestTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000bd6323a83b613f668687014e8a5852079494fb68

-----Decoded View---------------
Arg [0] : _BTC (address): 0xbD6323A83b613F668687014E8A5852079494fB68

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000bd6323a83b613f668687014e8a5852079494fb68

52204:4270:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56092:377;;;;;;:::i;:::-;;:::i;:::-;;;529:25:1;;;517:2;502:18;56092:377:0;;;;;;;;42713:91;;;:::i;:::-;;;;;;;:::i;45006:190::-;;;;;;:::i;:::-;;:::i;:::-;;;1645:14:1;;1638:22;1620:41;;1608:2;1593:18;45006:190:0;1480:187:1;43815:99:0;43894:12;;43815:99;;52588:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1874:25:1;;;1930:2;1915:18;;1908:34;;;;1958:18;;;1951:34;1862:2;1847:18;52588:44:0;1672:319:1;55952:132:0;;;:::i;45774:249::-;;;;;;:::i;:::-;;:::i;43666:84::-;;;43740:2;2471:36:1;;2459:2;2444:18;43666:84:0;2329:184:1;52941:86:0;;;;;;:::i;:::-;;:::i;:::-;;53230:111;;;;;;:::i;:::-;;:::i;54116:128::-;;;:::i;55032:912::-;;;:::i;53514:489::-;;;;;;:::i;:::-;;:::i;43977:118::-;;;;;;:::i;:::-;-1:-1:-1;;;;;44069:18:0;44042:7;44069:18;;;;;;;;;;;;43977:118;30549:103;;;:::i;52859:71::-;;;;;;;;-1:-1:-1;;;;;52859:71:0;;;;;;-1:-1:-1;;;;;2882:32:1;;;2864:51;;2852:2;2837:18;52859:71:0;2703:218:1;53349:157:0;;;;;;:::i;:::-;;:::i;29874:87::-;29947:6;;-1:-1:-1;;;;;29947:6:0;29874:87;;54013:95;;;;;;:::i;:::-;;:::i;52749:26::-;;;;;;42923:95;;;:::i;54254:770::-;;;;;;:::i;:::-;;:::i;44300:182::-;;;;;;:::i;:::-;;:::i;52824:28::-;;;;;;;;;52782:35;;;;;;52711:31;;;;;;44545:142;;;;;;:::i;:::-;-1:-1:-1;;;;;44652:18:0;;;44625:7;44652:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;44545:142;30807:220;;;;;;:::i;:::-;;:::i;53035:91::-;;;;;;:::i;:::-;;:::i;56092:377::-;-1:-1:-1;;;;;56223:18:0;;56161:7;56223:18;;;:8;:18;;;;;:40;;;56161:7;;56203:61;;:15;;:19;:61::i;:::-;-1:-1:-1;;;;;56295:18:0;;;;;;:8;:18;;;;;:27;;;56180:84;;-1:-1:-1;56279:43:0;;56275:177;;-1:-1:-1;56345:1:0;;56092:377;-1:-1:-1;;56092:377:0:o;56275:177::-;-1:-1:-1;;;;;56395:18:0;;;;;;:8;:18;;;;;:27;;;:45;;56427:12;56395:31;:45::i;:::-;56388:52;56092:377;-1:-1:-1;;;56092:377:0:o;56275:177::-;56169:300;56092:377;;;:::o;42713:91::-;42758:13;42791:5;42784:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42713:91;:::o;45006:190::-;45079:4;28070:10;45135:31;28070:10;45151:7;45160:5;45135:8;:31::i;:::-;45184:4;45177:11;;;45006:190;;;;;:::o;55952:132::-;56009:7;56045:31;56057:4;-1:-1:-1;;;;;56057:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56045:7;;;:11;:31::i;:::-;56038:38;;55952:132;:::o;45774:249::-;45861:4;28070:10;45919:37;45935:4;28070:10;45950:5;45919:15;:37::i;:::-;45967:26;45977:4;45983:2;45987:5;45967:9;:26::i;:::-;-1:-1:-1;46011:4:0;;45774:249;-1:-1:-1;;;;45774:249:0:o;52941:86::-;52993:26;52999:10;53011:7;52993:5;:26::i;:::-;52941:86;:::o;53230:111::-;29760:13;:11;:13::i;:::-;53311:9:::1;:22:::0;53230:111::o;54116:128::-;29760:13;:11;:13::i;:::-;54179:57:::1;54197:7;29947:6:::0;;-1:-1:-1;;;;;29947:6:0;;29874:87;54197:7:::1;54206:4;::::0;:29:::1;::::0;-1:-1:-1;;;54206:29:0;;54229:4:::1;54206:29;::::0;::::1;2864:51:1::0;54206:4:0::1;::::0;;::::1;-1:-1:-1::0;;;;;54206:4:0::1;::::0;:14:::1;::::0;2837:18:1;;54206:29:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54179:4;::::0;::::1;::::0;::::1;-1:-1:-1::0;;;;;54179:4:0::1;::::0;;:17:::1;:57::i;:::-;54116:128::o:0;55032:912::-;2345:21;:19;:21::i;:::-;55101:10:::1;55127:1;55092:20:::0;;;:8:::1;:20;::::0;;;;:32;55084:56:::1;;;::::0;-1:-1:-1;;;55084:56:0;;4544:2:1;55084:56:0::1;::::0;::::1;4526:21:1::0;4583:1;4563:18;;;4556:29;-1:-1:-1;;;4601:18:1;;;4594:37;4648:18;;55084:56:0::1;;;;;;;;;55203:10;55151:20;55194::::0;;;:8:::1;:20;::::0;;;;:42:::1;;::::0;55174:63:::1;::::0;:15:::1;::::0;:19:::1;:63::i;:::-;55304:10;55248:16;55295:20:::0;;;:8:::1;:20;::::0;;;;:29:::1;;::::0;55151:86;;-1:-1:-1;55248:16:0;55279:45;::::1;55275:414;;-1:-1:-1::0;55360:10:0::1;55351:20;::::0;;;:8:::1;:20;::::0;;;;:32;;55398:29:::1;::::0;;::::1;:33:::0;;;;55275:414:::1;;;55548:10;55539:20;::::0;;;:8:::1;:20;::::0;;;;:29:::1;::::0;::::1;::::0;55484:32;;:85:::1;::::0;55539:29;55484:50:::1;::::0;55521:12;55484:36:::1;:50::i;:::-;:54:::0;::::1;:85::i;:::-;55625:10;55616:20;::::0;;;:8:::1;:20;::::0;;;;:29:::1;;::::0;55473:96;;-1:-1:-1;55616:47:0::1;::::0;55650:12;55616:33:::1;:47::i;:::-;55593:10;55584:20;::::0;;;:8:::1;:20;::::0;;;;:29:::1;;:79:::0;55275:414:::1;55743:10;55734:20;::::0;;;:8:::1;:20;::::0;;;;:32;:46:::1;::::0;55771:8;55734:36:::1;:46::i;:::-;55708:10;55699:20;::::0;;;:8:::1;:20;::::0;;;;;;:81;;;55836:15:::1;55791:42;::::0;;::::1;:60:::0;;;;55864:19;-1:-1:-1;;;55864:19:0;;::::1;::::0;::::1;529:25:1::0;;;55864:4:0::1;::::0;:9:::1;::::0;502:18:1;;55864:19:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;55894:3:0::1;::::0;:42:::1;::::0;-1:-1:-1;;;55894:42:0;;55915:10:::1;55894:42;::::0;::::1;4851:51:1::0;4918:18;;;4911:34;;;-1:-1:-1;;;;;55894:3:0;;::::1;::::0;-1:-1:-1;55894:20:0::1;::::0;-1:-1:-1;4824:18:1;;55894:42:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;55071:873;;2389:20:::0;1783:1;2909:7;:22;2726:213;53514:489;-1:-1:-1;;;;;53641:18:0;;53578:7;53641:18;;;:8;:18;;;;;:40;;;53578:7;;53621:61;;:15;;:19;:61::i;:::-;-1:-1:-1;;;;;53740:18:0;;53693:16;53740:18;;;:8;:18;;;;;:27;;;53598:84;;-1:-1:-1;53693:16:0;53724:43;;53720:250;;-1:-1:-1;;;;;;53794:18:0;;;;;;:8;:18;;;;;:30;53720:250;;;-1:-1:-1;;;;;53930:18:0;;;;;;:8;:18;;;;;:27;;;;53877:30;;:81;;53930:27;53877:48;;53912:12;53877:34;:48::i;:81::-;53866:92;53987:8;-1:-1:-1;;;;53514:489:0:o;30549:103::-;29760:13;:11;:13::i;:::-;30614:30:::1;30641:1;30614:18;:30::i;53349:157::-:0;29760:13;:11;:13::i;:::-;53458:7:::1;53448;:17;;53420:46;;;::::0;::::1;;53477:11;:21:::0;53349:157::o;54013:95::-;29760:13;:11;:13::i;:::-;54080:8:::1;:20:::0;;-1:-1:-1;;54080:20:0::1;::::0;::::1;;::::0;;;::::1;::::0;;54013:95::o;42923:::-;42970:13;43003:7;42996:14;;;;;:::i;54254:770::-;2345:21;:19;:21::i;:::-;54339:10:::1;54328:7;:21;;54320:42;;;::::0;-1:-1:-1;;;54320:42:0;;5158:2:1;54320:42:0::1;::::0;::::1;5140:21:1::0;5197:1;5177:18;;;5170:29;-1:-1:-1;;;5215:18:1;;;5208:38;5263:18;;54320:42:0::1;4956:331:1::0;54320:42:0::1;54381:8;::::0;::::1;;54373:32;;;::::0;-1:-1:-1;;;54373:32:0;;5494:2:1;54373:32:0::1;::::0;::::1;5476:21:1::0;5533:2;5513:18;;;5506:30;-1:-1:-1;;;5552:18:1;;;5545:41;5603:18;;54373:32:0::1;5292:335:1::0;54373:32:0::1;54424:4;::::0;:26:::1;::::0;-1:-1:-1;;;54424:26:0;;54439:10:::1;54424:26;::::0;::::1;2864:51:1::0;54454:7:0;;54424:4:::1;::::0;::::1;-1:-1:-1::0;;;;;54424:4:0::1;::::0;:14:::1;::::0;2837:18:1;;54424:26:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:37;;54416:64;;;::::0;-1:-1:-1;;;54416:64:0;;5834:2:1;54416:64:0::1;::::0;::::1;5816:21:1::0;5873:2;5853:18;;;5846:30;-1:-1:-1;;;5892:18:1;;;5885:44;5946:18;;54416:64:0::1;5632:338:1::0;54416:64:0::1;54491:17;54511:19;:7:::0;54523:6:::1;54511:11;:19::i;:::-;54491:39;;54541:17;54561:34;54585:9;;54561:19;54575:4;54561:9;:13;;:19;;;;:::i;:34::-;54541:54;;54661:7;;54624:33;54647:9;54624:4;-1:-1:-1::0;;;;;54624:16:0::1;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:22:::0;::::1;:33::i;:::-;:44;;54616:70;;;::::0;-1:-1:-1;;;54616:70:0;;6177:2:1;54616:70:0::1;::::0;::::1;6159:21:1::0;6216:2;6196:18;;;6189:30;-1:-1:-1;;;6235:18:1;;;6228:43;6288:18;;54616:70:0::1;5975:337:1::0;54616:70:0::1;54741:10;54732:20;::::0;;;:8:::1;:20;::::0;;;;:32;:47:::1;::::0;54769:9;54732:36:::1;:47::i;:::-;54706:10;54697:20;::::0;;;:8:::1;:20;::::0;;;;:82;;;54835:15:::1;54790:42;::::0;::::1;:60:::0;54893:11:::1;::::0;54861:29:::1;::::0;;::::1;:43:::0;54917:31:::1;54931:4;54938:9:::0;54917:5:::1;:31::i;:::-;54959:4;::::0;:57:::1;::::0;:4:::1;::::0;::::1;-1:-1:-1::0;;;;;54959:4:0::1;54981:10;55001:4;55008:7:::0;54959:21:::1;:57::i;:::-;54307:717;;2389:20:::0;1783:1;2909:7;:22;2726:213;44300:182;44369:4;28070:10;44425:27;28070:10;44442:2;44446:5;44425:9;:27::i;30807:220::-;29760:13;:11;:13::i;:::-;-1:-1:-1;;;;;30892:22:0;::::1;30888:93;;30938:31;::::0;-1:-1:-1;;;30938:31:0;;30966:1:::1;30938:31;::::0;::::1;2864:51:1::0;2837:18;;30938:31:0::1;2703:218:1::0;30888:93:0::1;30991:28;31010:8;30991:18;:28::i;53035:91::-:0;29760:13;:11;:13::i;:::-;53100:7:::1;:18:::0;53035:91::o;6497:98::-;6555:7;6582:5;6586:1;6582;:5;:::i;49833:130::-;49918:37;49927:5;49934:7;49943:5;49950:4;49918:8;:37::i;:::-;49833:130;;;:::o;51549:487::-;-1:-1:-1;;;;;44652:18:0;;;51649:24;44652:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;51716:37:0;;51712:317;;51793:5;51774:16;:24;51770:132;;;51826:60;;-1:-1:-1;;;51826:60:0;;-1:-1:-1;;;;;6802:32:1;;51826:60:0;;;6784:51:1;6851:18;;;6844:34;;;6894:18;;;6887:34;;;6757:18;;51826:60:0;6582:345:1;51770:132:0;51945:57;51954:5;51961:7;51989:5;51970:16;:24;51996:5;51945:8;:57::i;:::-;51638:398;51549:487;;;:::o;46408:308::-;-1:-1:-1;;;;;46492:18:0;;46488:88;;46534:30;;-1:-1:-1;;;46534:30:0;;46561:1;46534:30;;;2864:51:1;2837:18;;46534:30:0;2703:218:1;46488:88:0;-1:-1:-1;;;;;46590:16:0;;46586:88;;46630:32;;-1:-1:-1;;;46630:32:0;;46659:1;46630:32;;;2864:51:1;2837:18;;46630:32:0;2703:218:1;46586:88:0;46684:24;46692:4;46698:2;46702:5;46684:7;:24::i;49069:211::-;-1:-1:-1;;;;;49140:21:0;;49136:91;;49185:30;;-1:-1:-1;;;49185:30:0;;49212:1;49185:30;;;2864:51:1;2837:18;;49185:30:0;2703:218:1;49136:91:0;49237:35;49245:7;49262:1;49266:5;49237:7;:35::i;:::-;49069:211;;:::o;30039:166::-;29947:6;;-1:-1:-1;;;;;29947:6:0;28070:10;30099:23;30095:103;;30146:40;;-1:-1:-1;;;30146:40:0;;28070:10;30146:40;;;2864:51:1;2837:18;;30146:40:0;2703:218:1;35498:162:0;35608:43;;-1:-1:-1;;;;;4869:32:1;;;35608:43:0;;;4851:51:1;4918:18;;;4911:34;;;35581:71:0;;35601:5;;35623:14;;;;;4824:18:1;;35608:43:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;35608:43:0;;;;;;;;;;;35581:19;:71::i;2425:293::-;1827:1;2559:7;;:19;2551:63;;;;-1:-1:-1;;;2551:63:0;;7134:2:1;2551:63:0;;;7116:21:1;7173:2;7153:18;;;7146:30;7212:33;7192:18;;;7185:61;7263:18;;2551:63:0;6932:355:1;2551:63:0;1827:1;2692:7;:18;2425:293::o;6854:98::-;6912:7;6939:5;6943:1;6939;:5;:::i;7253:98::-;7311:7;7338:5;7342:1;7338;:5;:::i;31187:191::-;31280:6;;;-1:-1:-1;;;;;31297:17:0;;;-1:-1:-1;;;;;;31297:17:0;;;;;;;31330:40;;31280:6;;;31297:17;31280:6;;31330:40;;31261:16;;31330:40;31250:128;31187:191;:::o;6116:98::-;6174:7;6201:5;6205:1;6201;:5;:::i;48528:213::-;-1:-1:-1;;;;;48599:21:0;;48595:93;;48644:32;;-1:-1:-1;;;48644:32:0;;48673:1;48644:32;;;2864:51:1;2837:18;;48644:32:0;2703:218:1;48595:93:0;48698:35;48714:1;48718:7;48727:5;48698:7;:35::i;35905:190::-;36033:53;;-1:-1:-1;;;;;8075:15:1;;;36033:53:0;;;8057:34:1;8127:15;;;8107:18;;;8100:43;8159:18;;;8152:34;;;36006:81:0;;36026:5;;36048:18;;;;;7992::1;;36033:53:0;7817:375:1;50814:443:0;-1:-1:-1;;;;;50927:19:0;;50923:91;;50970:32;;-1:-1:-1;;;50970:32:0;;50999:1;50970:32;;;2864:51:1;2837:18;;50970:32:0;2703:218:1;50923:91:0;-1:-1:-1;;;;;51028:21:0;;51024:92;;51073:31;;-1:-1:-1;;;51073:31:0;;51101:1;51073:31;;;2864:51:1;2837:18;;51073:31:0;2703:218:1;51024:92:0;-1:-1:-1;;;;;51126:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;51172:78;;;;51223:7;-1:-1:-1;;;;;51207:31:0;51216:5;-1:-1:-1;;;;;51207:31:0;;51232:5;51207:31;;;;529:25:1;;517:2;502:18;;383:177;51207:31:0;;;;;;;;50814:443;;;;:::o;47040:1135::-;-1:-1:-1;;;;;47130:18:0;;47126:552;;47284:5;47268:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;47126:552:0;;-1:-1:-1;47126:552:0;;-1:-1:-1;;;;;47344:15:0;;47322:19;47344:15;;;;;;;;;;;47378:19;;;47374:117;;;47425:50;;-1:-1:-1;;;47425:50:0;;-1:-1:-1;;;;;6802:32:1;;47425:50:0;;;6784:51:1;6851:18;;;6844:34;;;6894:18;;;6887:34;;;6757:18;;47425:50:0;6582:345:1;47374:117:0;-1:-1:-1;;;;;47614:15:0;;:9;:15;;;;;;;;;;47632:19;;;;47614:37;;47126:552;-1:-1:-1;;;;;47694:16:0;;47690:435;;47860:12;:21;;;;;;;47690:435;;;-1:-1:-1;;;;;48076:13:0;;:9;:13;;;;;;;;;;:22;;;;;;47690:435;48157:2;-1:-1:-1;;;;;48142:25:0;48151:4;-1:-1:-1;;;;;48142:25:0;;48161:5;48142:25;;;;529::1;;517:2;502:18;;383:177;48142:25:0;;;;;;;;47040:1135;;;:::o;38309:638::-;38733:23;38759:33;-1:-1:-1;;;;;38759:27:0;;38787:4;38759:27;:33::i;:::-;38733:59;;38807:10;:17;38828:1;38807:22;;:57;;;;;38845:10;38834:30;;;;;;;;;;;;:::i;:::-;38833:31;38807:57;38803:137;;;38888:40;;-1:-1:-1;;;38888:40:0;;-1:-1:-1;;;;;2882:32:1;;38888:40:0;;;2864:51:1;2837:18;;38888:40:0;2703:218:1;12976:153:0;13051:12;13083:38;13105:6;13113:4;13119:1;13051:12;13709;13723:23;13750:6;-1:-1:-1;;;;;13750:11:0;13769:5;13776:4;13750:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13708:73;;;;13799:55;13826:6;13834:7;13843:10;13799:26;:55::i;:::-;13792:62;13464:398;-1:-1:-1;;;;;;13464:398:0:o;14940:597::-;15088:12;15118:7;15113:417;;15142:19;15150:10;15142:7;:19::i;:::-;15113:417;;;15370:17;;:22;:49;;;;-1:-1:-1;;;;;;15396:18:0;;;:23;15370:49;15366:121;;;15447:24;;-1:-1:-1;;;15447:24:0;;-1:-1:-1;;;;;2882:32:1;;15447:24:0;;;2864:51:1;2837:18;;15447:24:0;2703:218:1;15366:121:0;-1:-1:-1;15508:10:0;15501:17;;16090:528;16223:17;;:21;16219:392;;16455:10;16449:17;16512:15;16499:10;16495:2;16491:19;16484:44;16219:392;16582:17;;-1:-1:-1;;;16582:17:0;;;;;;;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;565:250::-;650:1;660:113;674:6;671:1;668:13;660:113;;;750:11;;;744:18;731:11;;;724:39;696:2;689:10;660:113;;;-1:-1:-1;;807:1:1;789:16;;782:27;565:250::o;820:396::-;969:2;958:9;951:21;932:4;1001:6;995:13;1044:6;1039:2;1028:9;1024:18;1017:34;1060:79;1132:6;1127:2;1116:9;1112:18;1107:2;1099:6;1095:15;1060:79;:::i;:::-;1200:2;1179:15;-1:-1:-1;;1175:29:1;1160:45;;;;1207:2;1156:54;;820:396;-1:-1:-1;;820:396:1:o;1221:254::-;1289:6;1297;1350:2;1338:9;1329:7;1325:23;1321:32;1318:52;;;1366:1;1363;1356:12;1318:52;1389:29;1408:9;1389:29;:::i;:::-;1379:39;1465:2;1450:18;;;;1437:32;;-1:-1:-1;;;1221:254:1:o;1996:328::-;2073:6;2081;2089;2142:2;2130:9;2121:7;2117:23;2113:32;2110:52;;;2158:1;2155;2148:12;2110:52;2181:29;2200:9;2181:29;:::i;:::-;2171:39;;2229:38;2263:2;2252:9;2248:18;2229:38;:::i;:::-;2219:48;;2314:2;2303:9;2299:18;2286:32;2276:42;;1996:328;;;;;:::o;2518:180::-;2577:6;2630:2;2618:9;2609:7;2605:23;2601:32;2598:52;;;2646:1;2643;2636:12;2598:52;-1:-1:-1;2669:23:1;;2518:180;-1:-1:-1;2518:180:1:o;3134:118::-;3220:5;3213:13;3206:21;3199:5;3196:32;3186:60;;3242:1;3239;3232:12;3257:241;3313:6;3366:2;3354:9;3345:7;3341:23;3337:32;3334:52;;;3382:1;3379;3372:12;3334:52;3421:9;3408:23;3440:28;3462:5;3440:28;:::i;3503:260::-;3571:6;3579;3632:2;3620:9;3611:7;3607:23;3603:32;3600:52;;;3648:1;3645;3638:12;3600:52;3671:29;3690:9;3671:29;:::i;:::-;3661:39;;3719:38;3753:2;3742:9;3738:18;3719:38;:::i;:::-;3709:48;;3503:260;;;;;:::o;3768:380::-;3847:1;3843:12;;;;3890;;;3911:61;;3965:4;3957:6;3953:17;3943:27;;3911:61;4018:2;4010:6;4007:14;3987:18;3984:38;3981:161;;4064:10;4059:3;4055:20;4052:1;4045:31;4099:4;4096:1;4089:15;4127:4;4124:1;4117:15;4153:184;4223:6;4276:2;4264:9;4255:7;4251:23;4247:32;4244:52;;;4292:1;4289;4282:12;4244:52;-1:-1:-1;4315:16:1;;4153:184;-1:-1:-1;4153:184:1:o;6317:127::-;6378:10;6373:3;6369:20;6366:1;6359:31;6409:4;6406:1;6399:15;6433:4;6430:1;6423:15;6449:128;6516:9;;;6537:11;;;6534:37;;;6551:18;;:::i;7292:168::-;7365:9;;;7396;;7413:15;;;7407:22;;7393:37;7383:71;;7434:18;;:::i;7465:217::-;7505:1;7531;7521:132;;7575:10;7570:3;7566:20;7563:1;7556:31;7610:4;7607:1;7600:15;7638:4;7635:1;7628:15;7521:132;-1:-1:-1;7667:9:1;;7465:217::o;7687:125::-;7752:9;;;7773:10;;;7770:36;;;7786:18;;:::i;8197:245::-;8264:6;8317:2;8305:9;8296:7;8292:23;8288:32;8285:52;;;8333:1;8330;8323:12;8285:52;8365:9;8359:16;8384:28;8406:5;8384:28;:::i;8447:287::-;8576:3;8614:6;8608:13;8630:66;8689:6;8684:3;8677:4;8669:6;8665:17;8630:66;:::i;:::-;8712:16;;;;;8447:287;-1:-1:-1;;8447:287:1:o

ipfs://7aa4f2027d525fa374a54517dab285a4855be61061e2594c93da47352ad820a9