Overview
ETH Balance
0 ETH
Eth Value
$0.00Token Holdings
More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 1,164 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Claim | 19636911 | 199 days ago | IN | 0 ETH | 0.00154633 | ||||
Bond | 19581397 | 207 days ago | IN | 0 ETH | 0.00303088 | ||||
Claim | 19500456 | 218 days ago | IN | 0 ETH | 0.00221464 | ||||
Claim | 19443386 | 226 days ago | IN | 0 ETH | 0.00408998 | ||||
Claim | 19443383 | 226 days ago | IN | 0 ETH | 0.00461324 | ||||
Claim | 19432997 | 228 days ago | IN | 0 ETH | 0.00495989 | ||||
Claim | 19425409 | 229 days ago | IN | 0 ETH | 0.01064569 | ||||
Claim | 19408168 | 231 days ago | IN | 0 ETH | 0.00546758 | ||||
Claim | 19407617 | 231 days ago | IN | 0 ETH | 0.00763067 | ||||
Bond | 19405304 | 232 days ago | IN | 0 ETH | 0.00510295 | ||||
Claim | 19375496 | 236 days ago | IN | 0 ETH | 0.00819769 | ||||
Bond | 19371137 | 237 days ago | IN | 0 ETH | 0.01972509 | ||||
Claim | 19369524 | 237 days ago | IN | 0 ETH | 0.01175702 | ||||
Bond | 19367627 | 237 days ago | IN | 0 ETH | 0.004948 | ||||
Bond | 19365039 | 237 days ago | IN | 0 ETH | 0.01240401 | ||||
Bond | 19364248 | 238 days ago | IN | 0 ETH | 0.01674477 | ||||
Claim | 19352466 | 239 days ago | IN | 0 ETH | 0.00577543 | ||||
Bond | 19321985 | 243 days ago | IN | 0 ETH | 0.00368042 | ||||
Setbond Price | 19317390 | 244 days ago | IN | 0 ETH | 0.0010879 | ||||
Recover Treasury... | 19316603 | 244 days ago | IN | 0 ETH | 0.00199871 | ||||
Bond | 19316544 | 244 days ago | IN | 0 ETH | 0.00623559 | ||||
Bond | 19316425 | 244 days ago | IN | 0 ETH | 0.00437788 | ||||
Setbond Price | 19316061 | 244 days ago | IN | 0 ETH | 0.00134675 | ||||
Setbond Price | 19315245 | 244 days ago | IN | 0 ETH | 0.00115585 | ||||
Bond | 19314747 | 244 days ago | IN | 0 ETH | 0.0037143 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
ETF
Compiler Version
v0.8.23+commit.f704f362
Contract Source Code (Solidity)
/** *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); } } }
Contract Security Audit
- 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"}]
Contract Creation Code
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
Deployed Bytecode
0x608060405234801561001057600080fd5b50600436106101cf5760003560e01c8063715018a6116101045780639940686e116100a2578063d7ccfb0b11610071578063d7ccfb0b146103de578063dd62ed3e146103e7578063f2fde38b14610420578063ff7deff61461043357600080fd5b80639940686e146103a2578063a9059cbb146103b5578063b8df2093146103c8578063c7dab436146103d557600080fd5b80638da5cb5b116100de5780638da5cb5b1461036d578063945890ed1461037e57806394ab01621461039157806395d89b411461039a57600080fd5b8063715018a61461032257806389a302711461032a5780638acaaefb1461035a57600080fd5b8063313ce567116101715780634e2745141161014b5780634e274514146102d65780634e71d92d146102de5780635ea02407146102e657806370a08231146102f957600080fd5b8063313ce5671461029f57806342966c68146102ae5780634baa6725146102c357600080fd5b806318160ddd116101ad57806318160ddd146102325780631959a0021461023a5780631c743b561461028457806323b872dd1461028c57600080fd5b806303c824da146101d457806306fdde03146101fa578063095ea7b31461020f575b600080fd5b6101e76101e2366004611336565b610446565b6040519081526020015b60405180910390f35b6102026104d0565b6040516101f19190611375565b61022261021d3660046113a8565b610562565b60405190151581526020016101f1565b6002546101e7565b610269610248366004611336565b60086020526000908152604090208054600182015460029092015490919083565b604080519384526020840192909252908201526060016101f1565b6101e761057c565b61022261029a3660046113d2565b6105f1565b604051601281526020016101f1565b6102c16102bc36600461140e565b610615565b005b6102c16102d136600461140e565b610622565b6102c161062f565b6102c16106d6565b6101e76102f4366004611336565b6108da565b6101e7610307366004611336565b6001600160a01b031660009081526020819052604090205490565b6102c161097e565b600c546103429061010090046001600160a01b031681565b6040516001600160a01b0390911681526020016101f1565b6102c161036836600461140e565b610990565b6005546001600160a01b0316610342565b6102c161038c366004611435565b6109ad565b6101e7600a5481565b6102026109c8565b6102c16103b036600461140e565b6109d7565b6102226103c33660046113a8565b610c5c565b600c546102229060ff1681565b6101e7600b5481565b6101e760095481565b6101e76103f5366004611452565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b6102c161042e366004611336565b610c6a565b6102c161044136600461140e565b610ca5565b6001600160a01b038116600090815260086020526040812060010154819061046f904290610cb2565b6001600160a01b038416600090815260086020526040902060020154909150811061049d5750600092915050565b6001600160a01b0383166000908152600860205260409020600201546104c39082610cb2565b9392505050565b50919050565b6060600380546104df90611485565b80601f016020809104026020016040519081016040528092919081815260200182805461050b90611485565b80156105585780601f1061052d57610100808354040283529160200191610558565b820191906000526020600020905b81548152906001019060200180831161053b57829003601f168201915b5050505050905090565b600033610570818585610cbe565b60019150505b92915050565b60006105ec306001600160a01b03166318160ddd6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156105bf573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906105e391906114b9565b600a5490610cb2565b905090565b6000336105ff858285610cd0565b61060a858585610d4e565b506001949350505050565b61061f3382610dad565b50565b61062a610de7565b600955565b610637610de7565b6106d461064c6005546001600160a01b031690565b600c546040516370a0823160e01b81523060048201526101009091046001600160a01b0316906370a0823190602401602060405180830381865afa158015610698573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106bc91906114b9565b600c5461010090046001600160a01b03169190610e14565b565b6106de610e73565b336000908152600860205260409020546107295760405162461bcd60e51b81526020600482015260076024820152661b9bc8189bdb9960ca1b60448201526064015b60405180910390fd5b33600090815260086020526040812060010154610747904290610cb2565b33600090815260086020526040812060020154919250908210610784575033600090815260086020526040812080546002909101919091556107e3565b336000908152600860205260409020600281015490546107af91906107a99085610ecc565b90610ed8565b336000908152600860205260409020600201549091506107cf9083610cb2565b336000908152600860205260409020600201555b336000908152600860205260409020546107fd9082610cb2565b33600090815260086020526040908190209182554260019092019190915551630852cd8d60e31b81526004810182905230906342966c6890602401600060405180830381600087803b15801561085257600080fd5b505af1158015610866573d6000803e3d6000fd5b50506007546040516306b278db60e11b8152336004820152602481018590526001600160a01b039091169250630d64f1b69150604401600060405180830381600087803b1580156108b657600080fd5b505af11580156108ca573d6000803e3d6000fd5b5050505050506106d46001600655565b6001600160a01b0381166000908152600860205260408120600101548190610903904290610cb2565b6001600160a01b03841660009081526008602052604081206002015491925090821061094857506001600160a01b0383166000908152600860205260409020546104c3565b6001600160a01b03841660009081526008602052604090206002810154905461097691906107a99085610ecc565b949350505050565b610986610de7565b6106d46000610ee4565b610998610de7565b62278d008111156109a857600080fd5b600b55565b6109b5610de7565b600c805460ff1916911515919091179055565b6060600480546104df90611485565b6109df610e73565b64012a05f200811115610a1f5760405162461bcd60e51b815260206004820152600860248201526706d617820353030360c41b6044820152606401610720565b600c5460ff16610a5f5760405162461bcd60e51b815260206004820152600b60248201526a189b9bdd081bdc195b995960aa1b6044820152606401610720565b600c546040516370a0823160e01b8152336004820152829161010090046001600160a01b0316906370a0823190602401602060405180830381865afa158015610aac573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ad091906114b9565b1015610b0f5760405162461bcd60e51b815260206004820152600e60248201526d55534443206220746f6f206c6f7760901b6044820152606401610720565b6000610b208264e8d4a51000610ecc565b90506000610b3f6009546107a96103e885610ecc90919063ffffffff16565b9050600a54610bb082306001600160a01b03166318160ddd6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610b86573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610baa91906114b9565b90610f36565b1115610bee5760405162461bcd60e51b815260206004820152600d60248201526c06f76657220626f6e642063617609c1b6044820152606401610720565b33600090815260086020526040902054610c089082610f36565b336000908152600860205260409020908155426001820155600b54600290910155610c333082610f42565b600c54610c509061010090046001600160a01b0316333086610f78565b505061061f6001600655565b600033610570818585610d4e565b610c72610de7565b6001600160a01b038116610c9c57604051631e4fbdf760e01b815260006004820152602401610720565b61061f81610ee4565b610cad610de7565b600a55565b60006104c382846114e8565b610ccb8383836001610fb1565b505050565b6001600160a01b038381166000908152600160209081526040808320938616835292905220546000198114610d485781811015610d3957604051637dc7a0d960e11b81526001600160a01b03841660048201526024810182905260448101839052606401610720565b610d4884848484036000610fb1565b50505050565b6001600160a01b038316610d7857604051634b637e8f60e11b815260006004820152602401610720565b6001600160a01b038216610da25760405163ec442f0560e01b815260006004820152602401610720565b610ccb838383611086565b6001600160a01b038216610dd757604051634b637e8f60e11b815260006004820152602401610720565b610de382600083611086565b5050565b6005546001600160a01b031633146106d45760405163118cdaa760e01b8152336004820152602401610720565b6040516001600160a01b03838116602483015260448201839052610ccb91859182169063a9059cbb906064015b604051602081830303815290604052915060e01b6020820180516001600160e01b0383818316178352505050506111b0565b600260065403610ec55760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610720565b6002600655565b60006104c382846114fb565b60006104c38284611512565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60006104c38284611534565b6001600160a01b038216610f6c5760405163ec442f0560e01b815260006004820152602401610720565b610de360008383611086565b6040516001600160a01b038481166024830152838116604483015260648201839052610d489186918216906323b872dd90608401610e41565b6001600160a01b038416610fdb5760405163e602df0560e01b815260006004820152602401610720565b6001600160a01b03831661100557604051634a1406b160e11b815260006004820152602401610720565b6001600160a01b0380851660009081526001602090815260408083209387168352929052208290558015610d4857826001600160a01b0316846001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258460405161107891815260200190565b60405180910390a350505050565b6001600160a01b0383166110b15780600260008282546110a69190611534565b909155506111239050565b6001600160a01b038316600090815260208190526040902054818110156111045760405163391434e360e21b81526001600160a01b03851660048201526024810182905260448101839052606401610720565b6001600160a01b03841660009081526020819052604090209082900390555b6001600160a01b03821661113f5760028054829003905561115e565b6001600160a01b03821660009081526020819052604090208054820190555b816001600160a01b0316836001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516111a391815260200190565b60405180910390a3505050565b60006111c56001600160a01b03841683611213565b905080516000141580156111ea5750808060200190518101906111e89190611547565b155b15610ccb57604051635274afe760e01b81526001600160a01b0384166004820152602401610720565b60606104c38383600084600080856001600160a01b031684866040516112399190611564565b60006040518083038185875af1925050503d8060008114611276576040519150601f19603f3d011682016040523d82523d6000602084013e61127b565b606091505b509150915061128b868383611295565b9695505050505050565b6060826112aa576112a5826112f1565b6104c3565b81511580156112c157506001600160a01b0384163b155b156112ea57604051639996b31560e01b81526001600160a01b0385166004820152602401610720565b50806104c3565b8051156113015780518082602001fd5b604051630a12f52160e11b815260040160405180910390fd5b80356001600160a01b038116811461133157600080fd5b919050565b60006020828403121561134857600080fd5b6104c38261131a565b60005b8381101561136c578181015183820152602001611354565b50506000910152565b6020815260008251806020840152611394816040850160208701611351565b601f01601f19169190910160400192915050565b600080604083850312156113bb57600080fd5b6113c48361131a565b946020939093013593505050565b6000806000606084860312156113e757600080fd5b6113f08461131a565b92506113fe6020850161131a565b9150604084013590509250925092565b60006020828403121561142057600080fd5b5035919050565b801515811461061f57600080fd5b60006020828403121561144757600080fd5b81356104c381611427565b6000806040838503121561146557600080fd5b61146e8361131a565b915061147c6020840161131a565b90509250929050565b600181811c9082168061149957607f821691505b6020821081036104ca57634e487b7160e01b600052602260045260246000fd5b6000602082840312156114cb57600080fd5b5051919050565b634e487b7160e01b600052601160045260246000fd5b81810381811115610576576105766114d2565b8082028115828204841417610576576105766114d2565b60008261152f57634e487b7160e01b600052601260045260246000fd5b500490565b80820180821115610576576105766114d2565b60006020828403121561155957600080fd5b81516104c381611427565b60008251611576818460208701611351565b919091019291505056fea26469706673582212207aa4f2027d525fa374a54517dab285a4855be61061e2594c93da47352ad820a964736f6c63430008170033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000bd6323a83b613f668687014e8a5852079494fb68
-----Decoded View---------------
Arg [0] : _BTC (address): 0xbD6323A83b613F668687014E8A5852079494fB68
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000bd6323a83b613f668687014e8a5852079494fb68
Deployed Bytecode Sourcemap
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
Swarm Source
ipfs://7aa4f2027d525fa374a54517dab285a4855be61061e2594c93da47352ad820a9
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | 100.00% | $0.999753 | 4,271.8057 | $4,270.75 |
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.