Overview
S Balance
0 SS Value
-More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
| Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
| Seed Market | 947862 | 4 hrs ago | IN | 0 S | 0.00005561 |
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
SonicT
Compiler Version
v0.8.28+commit.7893614a
Contract Source Code (Solidity)
/**
*Submitted for verification at SonicScan.org on 2024-12-20
*/
/**
*Submitted for verification at basescan.org on 2024-11-18
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
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);
}
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
/**
* @title IERC1363
* @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
*
* Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
* after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
*/
interface IERC1363 is IERC20, IERC165 {
/*
* Note: the ERC-165 identifier for this interface is 0xb0202a11.
* 0xb0202a11 ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @param data Additional data with no specified format, sent in call to `spender`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}
/**
* @dev Collection of common custom errors used in multiple contracts
*
* IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
* It is recommended to avoid relying on the error API for critical functionality.
*
* _Available since v5.1._
*/
library Errors {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error InsufficientBalance(uint256 balance, uint256 needed);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedCall();
/**
* @dev The deployment failed.
*/
error FailedDeployment();
/**
* @dev A necessary precompile is missing.
*/
error MissingPrecompile(address);
}
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @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 Errors.InsufficientBalance(address(this).balance, amount);
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert Errors.FailedCall();
}
}
/**
* @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
* {Errors.FailedCall} 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 Errors.InsufficientBalance(address(this).balance, value);
}
(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 {Errors.FailedCall}) 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 {Errors.FailedCall} 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 {Errors.FailedCall}.
*/
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
assembly ("memory-safe") {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert Errors.FailedCall();
}
}
}
/**
* @title SafeERC20
* @dev Wrappers around ERC-20 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 {
/**
* @dev An operation with an ERC-20 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.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
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.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
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.
*
* NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
* only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
* set here.
*/
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 Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
safeTransfer(token, to, value);
} else if (!token.transferAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
* has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferFromAndCallRelaxed(
IERC1363 token,
address from,
address to,
uint256 value,
bytes memory data
) internal {
if (to.code.length == 0) {
safeTransferFrom(token, from, to, value);
} else if (!token.transferFromAndCall(from, to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
* Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
* once without retrying, and relies on the returned value to be true.
*
* Reverts if the returned value is other than `true`.
*/
function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
forceApprove(token, to, value);
} else if (!token.approveAndCall(to, value, data)) {
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 {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
// bubble errors
if iszero(success) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
returnSize := returndatasize()
returnValue := mload(0)
}
if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
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 silently catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
bool success;
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
returnSize := returndatasize()
returnValue := mload(0)
}
return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
}
}
/**
* @dev Library of standard hash functions.
*
* _Available since v5.1._
*/
library Hashes {
/**
* @dev Commutative Keccak256 hash of a sorted pair of bytes32. Frequently used when working with merkle proofs.
*
* NOTE: Equivalent to the `standardNodeHash` in our https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
*/
function commutativeKeccak256(bytes32 a, bytes32 b) internal pure returns (bytes32) {
return a < b ? _efficientKeccak256(a, b) : _efficientKeccak256(b, a);
}
/**
* @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
*/
function _efficientKeccak256(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly ("memory-safe") {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
/**
* @dev These functions deal with verification of Merkle Tree proofs.
*
* The tree and the proofs can be generated using our
* https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
* You will find a quickstart guide in the readme.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the Merkle tree could be reinterpreted as a leaf value.
* OpenZeppelin's JavaScript library generates Merkle trees that are safe
* against this attack out of the box.
*
* IMPORTANT: Consider memory side-effects when using custom hashing functions
* that access memory in an unsafe way.
*
* NOTE: This library supports proof verification for merkle trees built using
* custom _commutative_ hashing functions (i.e. `H(a, b) == H(b, a)`). Proving
* leaf inclusion in trees built using non-commutative hashing functions requires
* additional logic that is not supported by this library.
*/
library MerkleProof {
/**
*@dev The multiproof provided is not valid.
*/
error MerkleProofInvalidMultiproof();
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*
* This version handles proofs in memory with the default hashing function.
*/
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leaves & pre-images are assumed to be sorted.
*
* This version handles proofs in memory with the default hashing function.
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*
* This version handles proofs in memory with a custom hashing function.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bool) {
return processProof(proof, leaf, hasher) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leaves & pre-images are assumed to be sorted.
*
* This version handles proofs in memory with a custom hashing function.
*/
function processProof(
bytes32[] memory proof,
bytes32 leaf,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = hasher(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*
* This version handles proofs in calldata with the default hashing function.
*/
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leaves & pre-images are assumed to be sorted.
*
* This version handles proofs in calldata with the default hashing function.
*/
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*
* This version handles proofs in calldata with a custom hashing function.
*/
function verifyCalldata(
bytes32[] calldata proof,
bytes32 root,
bytes32 leaf,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bool) {
return processProofCalldata(proof, leaf, hasher) == root;
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leaves & pre-images are assumed to be sorted.
*
* This version handles proofs in calldata with a custom hashing function.
*/
function processProofCalldata(
bytes32[] calldata proof,
bytes32 leaf,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = hasher(computedHash, proof[i]);
}
return computedHash;
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* This version handles multiproofs in memory with the default hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
*
* NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
* The `leaves` must be validated independently. See {processMultiProof}.
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* This version handles multiproofs in memory with the default hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
* and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
* validating the leaves elsewhere.
*/
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the Merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofFlagsLen = proofFlags.length;
// Check proof validity.
if (leavesLen + proof.length != proofFlagsLen + 1) {
revert MerkleProofInvalidMultiproof();
}
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](proofFlagsLen);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < proofFlagsLen; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = Hashes.commutativeKeccak256(a, b);
}
if (proofFlagsLen > 0) {
if (proofPos != proof.length) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[proofFlagsLen - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* This version handles multiproofs in memory with a custom hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
*
* NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
* The `leaves` must be validated independently. See {processMultiProof}.
*/
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bool) {
return processMultiProof(proof, proofFlags, leaves, hasher) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* This version handles multiproofs in memory with a custom hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
* and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
* validating the leaves elsewhere.
*/
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the Merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofFlagsLen = proofFlags.length;
// Check proof validity.
if (leavesLen + proof.length != proofFlagsLen + 1) {
revert MerkleProofInvalidMultiproof();
}
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](proofFlagsLen);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < proofFlagsLen; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = hasher(a, b);
}
if (proofFlagsLen > 0) {
if (proofPos != proof.length) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[proofFlagsLen - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* This version handles multiproofs in calldata with the default hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
*
* NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
* The `leaves` must be validated independently. See {processMultiProofCalldata}.
*/
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* This version handles multiproofs in calldata with the default hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
* and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
* validating the leaves elsewhere.
*/
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the Merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofFlagsLen = proofFlags.length;
// Check proof validity.
if (leavesLen + proof.length != proofFlagsLen + 1) {
revert MerkleProofInvalidMultiproof();
}
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](proofFlagsLen);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < proofFlagsLen; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = Hashes.commutativeKeccak256(a, b);
}
if (proofFlagsLen > 0) {
if (proofPos != proof.length) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[proofFlagsLen - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
/**
* @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
*
* This version handles multiproofs in calldata with a custom hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
*
* NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
* The `leaves` must be validated independently. See {processMultiProofCalldata}.
*/
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves, hasher) == root;
}
/**
* @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
* proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
* leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
* respectively.
*
* This version handles multiproofs in calldata with a custom hashing function.
*
* CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
* is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
* tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
*
* NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
* and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
* validating the leaves elsewhere.
*/
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves,
function(bytes32, bytes32) view returns (bytes32) hasher
) internal view returns (bytes32 merkleRoot) {
// This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
// the Merkle tree.
uint256 leavesLen = leaves.length;
uint256 proofFlagsLen = proofFlags.length;
// Check proof validity.
if (leavesLen + proof.length != proofFlagsLen + 1) {
revert MerkleProofInvalidMultiproof();
}
// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
bytes32[] memory hashes = new bytes32[](proofFlagsLen);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
// At each step, we compute the next hash using two values:
// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
// get the next hash.
// - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
// `proof` array.
for (uint256 i = 0; i < proofFlagsLen; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = hasher(a, b);
}
if (proofFlagsLen > 0) {
if (proofPos != proof.length) {
revert MerkleProofInvalidMultiproof();
}
unchecked {
return hashes[proofFlagsLen - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
}
interface IRouter {
/**
* @notice Swap exact ETH for tokens on Uniswap.
* @param amountOutMin Minimum amount of token to receive.
* @param path The path of the trade, with the first address being the input token (ETH) and the last one the output token (BRETT).
* @param to The address to send the resulting tokens.
* @param deadline The time by which the transaction must be confirmed.
* @return amounts Array of amounts (input amount, intermediary amounts, and output amount).
*/
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
/**
* @notice Retourne l'adresse du WETH (Wrapped ETH) sur la blockchain Base.
* @return L'adresse de WETH.
*/
function WETH() external view returns (address);
}
contract SonicT {
using SafeERC20 for IERC20;
uint256 public POINTS_TO_GENERATE_1MINER = 864000;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public initialized = false;
IERC20 public BRETT;
IRouter public ROUTER;
bytes32 public merkleRoot;
address public treasuryAddress;
address public owner;
mapping(address => uint256) public inkjetMiners;
mapping(address => uint256) public claimedPoints;
mapping(address => uint256) public lastInk;
mapping(address => uint256) public lastWithdraw;
mapping(address => address) public referrals;
uint256 constant INK_STEP = 1 days;
uint256 constant INK_STEP_MODIFIER = 0.1e18;
uint256 constant BASE_PERCENTAGE = 0.5e18;
uint256 public marketPoints;
modifier onlyOwner() {
require(msg.sender == owner, "Not owner");
_;
}
constructor(address _treasuryAddress, bytes32 _merkleRoot) {
owner = msg.sender;
// Définition des adresses spécifiques
BRETT = IERC20(0x9990dE39Ca46151150E392Ca96EB349d0f549166);
ROUTER = IRouter(0x591cf6942c422fA53E8D81c62a9692D7BeA72F61);
treasuryAddress = _treasuryAddress;
merkleRoot = _merkleRoot;
}
function compound(address ref) public {
require(initialized, "Not initialized");
if (ref == msg.sender) {
ref = address(0);
}
if (
referrals[msg.sender] == address(0) &&
referrals[msg.sender] != msg.sender
) {
referrals[msg.sender] = ref;
}
uint256 pointsUsed = getMyPoints();
uint256 newMiners = pointsUsed / POINTS_TO_GENERATE_1MINER;
inkjetMiners[msg.sender] += newMiners;
claimedPoints[msg.sender] = 0;
lastInk[msg.sender] = block.timestamp;
// Envoi des points de referral
claimedPoints[referrals[msg.sender]] += pointsUsed / 10;
// Boost du marché pour équilibrer les stocks
marketPoints += pointsUsed / 2;
}
function withdraw() external {
require(initialized, "Not initialized");
uint256 hasPoints = getMyPoints();
require(hasPoints > 0, "No points to withdraw");
uint256 pointValue = calculatePointSell(hasPoints);
uint256 fee = devFee(pointValue);
claimedPoints[msg.sender] = 0;
lastInk[msg.sender] = block.timestamp;
lastWithdraw[msg.sender] = block.timestamp;
// Boost du marché
marketPoints += hasPoints;
BRETT.safeTransfer(treasuryAddress, fee);
BRETT.safeTransfer(msg.sender, pointValue - fee);
}
function depositETH(uint minAmount, address ref) external payable {
require(initialized, "Not initialized");
require(msg.value > 0, "Invalid amount");
uint amount = _swap(minAmount);
_deposit(amount, ref, false);
}
function depositBrett(uint amount, address ref) external {
require(initialized, "Not initialized");
require(amount > 0, "Invalid amount");
BRETT.safeTransferFrom(msg.sender, address(this), amount);
_deposit(amount, ref, false);
}
function depositBrettWithProof(
uint amount,
address ref,
bytes32[] memory proof
) external {
require(initialized, "Not initialized");
require(amount > 0, "Invalid amount");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, merkleRoot, leaf), "Invalid proof");
BRETT.safeTransferFrom(msg.sender, address(this), amount);
_deposit(amount, ref, true); // Utilisateur validé
}
function _deposit(uint amount, address ref, bool holder) internal {
uint256 pointsBought = calculatePointBuy(amount, getBalance() - amount);
if (holder) {
pointsBought += (pointsBought * 2) / 100; // Bonus de 2 % pour les holders
}
pointsBought -= devFee(pointsBought);
uint256 fee = devFee(amount);
BRETT.safeTransfer(treasuryAddress, fee);
claimedPoints[msg.sender] += pointsBought;
compound(ref);
}
function _swap(uint minTokenOut) internal returns (uint) {
uint initialBalance = getBalance();
address[] memory path = new address[](2);
path[0] = ROUTER.WETH();
path[1] = address(BRETT);
ROUTER.swapExactETHForTokens{value: msg.value}(
minTokenOut,
path,
address(this),
block.timestamp
);
return getBalance() - initialBalance;
}
function calculateTrade(
uint256 rt,
uint256 rs,
uint256 bs
) public view returns (uint256) {
return (PSN * bs) / (PSNH + ((PSN * rs + PSNH * rt) / rt));
}
function calculatePointSell(uint256 points) public view returns (uint256) {
if (points == 0) return 0;
return calculateTrade(points, marketPoints, getBalance());
}
function calculatePointBuy(
uint256 eth,
uint256 contractBalance
) public view returns (uint256) {
return calculateTrade(eth, contractBalance, marketPoints);
}
function calculatePointBuySimple(uint256 eth) public view returns (uint256) {
return calculatePointBuy(eth, getBalance());
}
function devFee(uint256 amount) public pure returns (uint256) {
return (amount * 5) / 100;
}
function seedMarket() public payable onlyOwner {
require(marketPoints == 0, "Market already seeded");
initialized = true;
marketPoints = 86400000000;
}
function getBalance() public view returns (uint256) {
return BRETT.balanceOf(address(this));
}
function getMyMiners() public view returns (uint256) {
return inkjetMiners[msg.sender];
}
function getMyPoints() public view returns (uint256) {
return claimedPoints[msg.sender] + getPointsSinceLastInk(msg.sender);
}
function getPointsSinceLastInk(address adr) public view returns (uint256) {
uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /
INK_STEP;
uint256 percentage = min(
1e18,
BASE_PERCENTAGE + steps * INK_STEP_MODIFIER
);
uint256 secondsPassed = min(
POINTS_TO_GENERATE_1MINER,
block.timestamp - lastInk[adr]
);
return ((secondsPassed * inkjetMiners[adr]) * percentage) / 1e18;
}
function getHalvingPercentage() public view returns (uint256) {
uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /
INK_STEP;
return min(1e18, BASE_PERCENTAGE + steps * INK_STEP_MODIFIER);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_treasuryAddress","type":"address"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"BRETT","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POINTS_TO_GENERATE_1MINER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROUTER","outputs":[{"internalType":"contract IRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"eth","type":"uint256"},{"internalType":"uint256","name":"contractBalance","type":"uint256"}],"name":"calculatePointBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"eth","type":"uint256"}],"name":"calculatePointBuySimple","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"points","type":"uint256"}],"name":"calculatePointSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"rt","type":"uint256"},{"internalType":"uint256","name":"rs","type":"uint256"},{"internalType":"uint256","name":"bs","type":"uint256"}],"name":"calculateTrade","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimedPoints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"ref","type":"address"}],"name":"compound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"ref","type":"address"}],"name":"depositBrett","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"ref","type":"address"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"depositBrettWithProof","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"minAmount","type":"uint256"},{"internalType":"address","name":"ref","type":"address"}],"name":"depositETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"devFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getHalvingPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMyMiners","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMyPoints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"getPointsSinceLastInk","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"inkjetMiners","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastInk","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketPoints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"referrals","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"seedMarket","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"treasuryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000487881a26683ec96f7b67b0907846a0b2f3ae3120000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _treasuryAddress (address): 0x487881a26683EC96f7b67b0907846a0B2f3ae312
Arg [1] : _merkleRoot (bytes32): 0x0000000000000000000000000000000000000000000000000000000000000000
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000487881a26683ec96f7b67b0907846a0b2f3ae312
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
50534:7089:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56488:103;;;;;;;;;;-1:-1:-1;56572:10:0;56532:7;56559:24;;;:12;:24;;;;;;56488:103;;;160:25:1;;;148:2;133:18;56488:103:0;;;;;;;;50948:48;;;;;;;;;;-1:-1:-1;50948:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;56372:108;;;;;;;;;;;;;:::i;50700:31::-;;;;;;;;;;-1:-1:-1;50700:31:0;;;;;;;;;;;749:14:1;;742:22;724:41;;712:2;697:18;50700:31:0;584:187:1;51003:42:0;;;;;;;;;;-1:-1:-1;51003:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;55314:201;;;;;;;;;;-1:-1:-1;55314:201:0;;;;;:::i;:::-;;:::i;51815:814::-;;;;;;;;;;-1:-1:-1;51815:814:0;;;;;:::i;:::-;;:::i;:::-;;50794:25;;;;;;;;;;;;;;;;50740:19;;;;;;;;;;-1:-1:-1;50740:19:0;;;;;;;-1:-1:-1;;;;;50740:19:0;;;;;;-1:-1:-1;;;;;1606:32:1;;;1588:51;;1576:2;1561:18;50740:19:0;1429:216:1;50766:21:0;;;;;;;;;;-1:-1:-1;50766:21:0;;;;-1:-1:-1;;;;;50766:21:0;;;56067:106;;;;;;;;;;-1:-1:-1;56067:106:0;;;;;:::i;:::-;;:::i;50592:49::-;;;;;;;;;;;;;;;;56181:183;;;:::i;52637:617::-;;;;;;;;;;;;;:::i;51300:27::-;;;;;;;;;;;;;;;;53811:508;;;;;;;;;;-1:-1:-1;53811:508:0;;;;;:::i;:::-;;:::i;53262:257::-;;;;;;:::i;:::-;;:::i;51052:47::-;;;;;;;;;;-1:-1:-1;51052:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;55717:196;;;;;;;;;;-1:-1:-1;55717:196:0;;;;;:::i;:::-;;:::i;55921:138::-;;;;;;;;;;-1:-1:-1;55921:138:0;;;;;:::i;:::-;;:::i;50865:20::-;;;;;;;;;;-1:-1:-1;50865:20:0;;;;-1:-1:-1;;;;;50865:20:0;;;51106:44;;;;;;;;;;-1:-1:-1;51106:44:0;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;51106:44:0;;;55523:186;;;;;;;;;;-1:-1:-1;55523:186:0;;;;;:::i;:::-;;:::i;53531:272::-;;;;;;;;;;-1:-1:-1;53531:272:0;;;;;:::i;:::-;;:::i;50894:47::-;;;;;;;;;;-1:-1:-1;50894:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;56599:140;;;;;;;;;;;;;:::i;50828:30::-;;;;;;;;;;-1:-1:-1;50828:30:0;;;;-1:-1:-1;;;;;50828:30:0;;;57268:239;;;;;;;;;;;;;:::i;56747:513::-;;;;;;;;;;-1:-1:-1;56747:513:0;;;;;:::i;:::-;;:::i;56372:108::-;56442:5;;:30;;-1:-1:-1;;;56442:30:0;;56466:4;56442:30;;;1588:51:1;56415:7:0;;56442:5;;;-1:-1:-1;;;;;56442:5:0;;:15;;1561:18:1;;56442:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56435:37;;56372:108;:::o;55314:201::-;55429:7;55503:2;55497;55490:4;;:9;;;;:::i;:::-;55485:2;55479:3;;:8;;;;:::i;:::-;:20;;;;:::i;:::-;55478:27;;;;:::i;:::-;55470:4;;:36;;;;:::i;:::-;55463:2;55457:3;;:8;;;;:::i;:::-;55456:51;;;;:::i;:::-;55449:58;55314:201;-1:-1:-1;;;;55314:201:0:o;51815:814::-;51872:11;;;;51864:39;;;;-1:-1:-1;;;51864:39:0;;;;;;;:::i;:::-;;;;;;;;;51925:10;-1:-1:-1;;;;;51918:17:0;;;51914:66;;-1:-1:-1;51966:1:0;51914:66;52018:10;52041:1;52008:21;;;:9;:21;;;;;;-1:-1:-1;;;;;52008:21:0;:35;:87;;;;-1:-1:-1;52085:10:0;52060:21;;;;:9;:21;;;;;;-1:-1:-1;;;;;52060:21:0;:35;;52008:87;51990:171;;;52132:10;52122:21;;;;:9;:21;;;;;:27;;-1:-1:-1;;;;;;52122:27:0;-1:-1:-1;;;;;52122:27:0;;;;;51990:171;52171:18;52192:13;:11;:13::i;:::-;52171:34;;52218:17;52251:25;;52238:10;:38;;;;:::i;:::-;52300:10;52287:24;;;;:12;:24;;;;;:37;;52218:58;;-1:-1:-1;52218:58:0;;52287:24;;;:37;;52218:58;;52287:37;:::i;:::-;;;;-1:-1:-1;;52349:10:0;52363:1;52335:25;;;:13;:25;;;;;;;;:29;;;52375:7;:19;;;;;;;52397:15;52375:37;;52506:15;;:10;:15;:::i;:::-;52490:10;52466:36;52480:21;;;:9;:21;;;;;;;;;-1:-1:-1;;;;;52480:21:0;52466:36;;:13;:36;;;;;:55;;:36;;;:55;;;;;:::i;:::-;;;;-1:-1:-1;52607:14:0;;-1:-1:-1;52620:1:0;52607:10;:14;:::i;:::-;52591:12;;:30;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;51815:814:0:o;56067:106::-;56120:7;56162:3;56148:10;:6;56157:1;56148:10;:::i;:::-;56147:18;;;;:::i;:::-;56140:25;56067:106;-1:-1:-1;;56067:106:0:o;56181:183::-;51390:5;;-1:-1:-1;;;;;51390:5:0;51376:10;:19;51368:41;;;;-1:-1:-1;;;51368:41:0;;6220:2:1;51368:41:0;;;6202:21:1;6259:1;6239:18;;;6232:29;-1:-1:-1;;;6277:18:1;;;6270:39;6326:18;;51368:41:0;6018:332:1;51368:41:0;56247:12:::1;::::0;:17;56239:51:::1;;;::::0;-1:-1:-1;;;56239:51:0;;6557:2:1;56239:51:0::1;::::0;::::1;6539:21:1::0;6596:2;6576:18;;;6569:30;-1:-1:-1;;;6615:18:1;;;6608:51;6676:18;;56239:51:0::1;6355:345:1::0;56239:51:0::1;56301:11;:18:::0;;-1:-1:-1;;56301:18:0::1;56315:4;56301:18;::::0;;56345:11:::1;56330:12;:26:::0;56181:183::o;52637:617::-;52685:11;;;;52677:39;;;;-1:-1:-1;;;52677:39:0;;;;;;;:::i;:::-;52727:17;52747:13;:11;:13::i;:::-;52727:33;;52793:1;52781:9;:13;52773:47;;;;-1:-1:-1;;;52773:47:0;;6907:2:1;52773:47:0;;;6889:21:1;6946:2;6926:18;;;6919:30;-1:-1:-1;;;6965:18:1;;;6958:51;7026:18;;52773:47:0;6705:345:1;52773:47:0;52831:18;52852:29;52871:9;52852:18;:29::i;:::-;52831:50;;52892:11;52906:18;52913:10;52906:6;:18::i;:::-;52951:10;52965:1;52937:25;;;:13;:25;;;;;;;;:29;;;52977:7;:19;;;;;52999:15;52977:37;;;;53025:12;:24;;;;;:42;53109:12;:25;;52892:32;;-1:-1:-1;53125:9:0;;53109:12;;52965:1;53109:25;;53125:9;;53109:25;:::i;:::-;;;;-1:-1:-1;;53166:15:0;;53147:5;;:40;;-1:-1:-1;;;;;53166:15:0;53147:5;;;;;;53166:15;53183:3;53147:18;:40::i;:::-;53198:48;53217:10;53229:16;53242:3;53229:10;:16;:::i;:::-;53198:5;;;;;-1:-1:-1;;;;;53198:5:0;;;:18;:48::i;:::-;52666:588;;;52637:617::o;53811:508::-;53954:11;;;;53946:39;;;;-1:-1:-1;;;53946:39:0;;;;;;;:::i;:::-;54013:1;54004:6;:10;53996:37;;;;-1:-1:-1;;;53996:37:0;;;;;;;:::i;:::-;54071:28;;-1:-1:-1;;54088:10:0;7680:2:1;7676:15;7672:53;54071:28:0;;;7660:66:1;54046:12:0;;7742::1;;54071:28:0;;;;;;;;;;;;54061:39;;;;;;54046:54;;54119:43;54138:5;54145:10;;54157:4;54119:18;:43::i;:::-;54111:69;;;;-1:-1:-1;;;54111:69:0;;7967:2:1;54111:69:0;;;7949:21:1;8006:2;7986:18;;;7979:30;-1:-1:-1;;;8025:18:1;;;8018:43;8078:18;;54111:69:0;7765:337:1;54111:69:0;54193:5;;:57;;:5;;;-1:-1:-1;;;;;54193:5:0;54216:10;54236:4;54243:6;54193:22;:57::i;:::-;54261:27;54270:6;54278:3;54283:4;54261:8;:27::i;:::-;53935:384;53811:508;;;:::o;53262:257::-;53347:11;;;;53339:39;;;;-1:-1:-1;;;53339:39:0;;;;;;;:::i;:::-;53409:1;53397:9;:13;53389:40;;;;-1:-1:-1;;;53389:40:0;;;;;;;:::i;:::-;53442:11;53456:16;53462:9;53456:5;:16::i;:::-;53442:30;;53483:28;53492:6;53500:3;53505:5;53483:8;:28::i;55717:196::-;55828:7;55855:50;55870:3;55875:15;55892:12;;55855:14;:50::i;:::-;55848:57;55717:196;-1:-1:-1;;;55717:196:0:o;55921:138::-;55988:7;56015:36;56033:3;56038:12;:10;:12::i;55523:186::-;55588:7;55612:6;55622:1;55612:11;55608:25;;-1:-1:-1;55632:1:0;;55523:186;-1:-1:-1;55523:186:0:o;55608:25::-;55651:50;55666:6;55674:12;;55688;:10;:12::i;53531:272::-;53607:11;;;;53599:39;;;;-1:-1:-1;;;53599:39:0;;;;;;;:::i;:::-;53666:1;53657:6;:10;53649:37;;;;-1:-1:-1;;;53649:37:0;;;;;;;:::i;:::-;53699:5;;:57;;:5;;;-1:-1:-1;;;;;53699:5:0;53722:10;53742:4;53749:6;53699:22;:57::i;:::-;53767:28;53776:6;53784:3;53789:5;53767:8;:28::i;:::-;53531:272;;:::o;56599:140::-;56643:7;56698:33;56720:10;56698:21;:33::i;:::-;56684:10;56670:25;;;;:13;:25;;;;;;:61;;;;:::i;57268:239::-;57389:10;57321:7;57376:24;;;:12;:24;;;;;;57321:7;;51187:6;;57358:42;;:15;:42;:::i;:::-;57357:68;;;;:::i;:::-;57341:84;-1:-1:-1;57445:54:0;57449:4;57473:25;51237:6;57341:84;57473:25;:::i;:::-;57455:43;;51285:6;57455:43;:::i;:::-;57445:3;:54::i;:::-;57438:61;;;57268:239;:::o;56747:513::-;56880:10;56812:7;56867:24;;;:12;:24;;;;;;56812:7;;51187:6;;56849:42;;:15;:42;:::i;:::-;56848:68;;;;:::i;:::-;56832:84;-1:-1:-1;56929:18:0;56950:91;56968:4;57005:25;51237:6;56832:84;57005:25;:::i;56950:91::-;57054:21;57096:25;;-1:-1:-1;;;;;57154:12:0;;;;:7;:12;;;;;;56929:112;;-1:-1:-1;57054:21:0;;57078:99;;57096:25;57136:30;;:15;:30;:::i;57078:99::-;-1:-1:-1;;;;;57213:17:0;;;;;;:12;:17;;;;;;57054:123;;-1:-1:-1;57248:4:0;;57234:10;;57197:33;;57054:123;57197:33;:::i;:::-;57196:48;;;;:::i;:::-;57195:57;;;;:::i;:::-;57188:64;56747:513;-1:-1:-1;;;;;56747:513:0:o;15755:162::-;15865:43;;-1:-1:-1;;;;;8299:32:1;;;15865:43:0;;;8281:51:1;8348:18;;;8341:34;;;15838:71:0;;15858:5;;15880:14;;;;;8254:18:1;;15865:43:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15865:43:0;;;;;;;;;;;15838:19;:71::i;26695:156::-;26786:4;26839;26810:25;26823:5;26830:4;26810:12;:25::i;:::-;:33;;26695:156;-1:-1:-1;;;;26695:156:0:o;16162:190::-;16290:53;;-1:-1:-1;;;;;8606:32:1;;;16290:53:0;;;8588:51:1;8675:32;;;8655:18;;;8648:60;8724:18;;;8717:34;;;16263:81:0;;16283:5;;16305:18;;;;;8561::1;;16290:53:0;8386:371:1;54327:499:0;54404:20;54427:48;54445:6;54468;54453:12;:10;:12::i;:::-;:21;;;;:::i;54427:48::-;54404:71;;54492:6;54488:112;;;54552:3;54532:16;:12;54547:1;54532:16;:::i;:::-;54531:24;;;;:::i;:::-;54515:40;;;;:::i;:::-;;;54488:112;54628:20;54635:12;54628:6;:20::i;:::-;54612:36;;;;:::i;:::-;;;54659:11;54673:14;54680:6;54673;:14::i;:::-;54719:15;;54700:5;;54659:28;;-1:-1:-1;54700:40:0;;54719:15;54700:5;;-1:-1:-1;;;;;54700:5:0;;;;54719:15;54659:28;54700:18;:40::i;:::-;54767:10;54753:25;;;;:13;:25;;;;;:41;;54782:12;;54753:25;:41;;54782:12;;54753:41;:::i;:::-;;;;-1:-1:-1;54805:13:0;;-1:-1:-1;54814:3:0;54805:8;:13::i;:::-;54393:433;;54327:499;;;:::o;54834:472::-;54885:4;54902:19;54924:12;:10;:12::i;:::-;54973:16;;;54987:1;54973:16;;;;;;;;54902:34;;-1:-1:-1;54949:21:0;;54973:16;;;;;;;;;;-1:-1:-1;;55020:6:0;;;:13;;;-1:-1:-1;;;55020:13:0;;;;54949:40;;-1:-1:-1;;;;;;55020:6:0;;;;:11;;-1:-1:-1;55020:13:0;;;;;;;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55010:4;55015:1;55010:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;55010:23:0;;;:7;;;;;;;;;:23;55062:5;;55044:7;;55062:5;;;;;;;;55044:4;;55062:5;;55044:7;;;;;;:::i;:::-;-1:-1:-1;;;;;55044:24:0;;;:7;;;;;;;;;:24;55089:6;;;:160;;-1:-1:-1;;;55089:160:0;;:6;;;:28;;55125:9;;55089:160;;55150:11;;55176:4;;55203;;55223:15;;55089:160;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;55089:160:0;;;;;;;;;;;;:::i;:::-;;55284:14;55269:12;:10;:12::i;:::-;:29;;;;:::i;57515:105::-;57572:7;57603:1;57599;:5;:13;;57611:1;57599:13;;;-1:-1:-1;57607:1:0;;57515:105;-1:-1:-1;57515:105:0:o;22348:738::-;22429:18;22458:19;22598:4;22595:1;22588:4;22582:11;22575:4;22569;22565:15;22562:1;22555:5;22548;22543:60;22657:7;22647:180;;22702:4;22696:11;22748:16;22745:1;22740:3;22725:40;22795:16;22790:3;22783:29;22647:180;-1:-1:-1;;22906:1:0;22900:8;22855:16;;-1:-1:-1;22935:15:0;;:68;;22987:11;23002:1;22987:16;;22935:68;;;-1:-1:-1;;;;;22953:26:0;;;:31;22935:68;22931:148;;;23027:40;;-1:-1:-1;;;23027:40:0;;-1:-1:-1;;;;;1606:32:1;;23027:40:0;;;1588:51:1;1561:18;;23027:40:0;1429:216:1;27262:314:0;27345:7;27388:4;27345:7;27403:136;27427:5;:12;27423:1;:16;27403:136;;;27476:51;27504:12;27518:5;27524:1;27518:8;;;;;;;;:::i;:::-;;;;;;;27476:27;:51::i;:::-;27461:66;-1:-1:-1;27441:3:0;;27403:136;;;-1:-1:-1;27556:12:0;27262:314;-1:-1:-1;;;27262:314:0:o;24479:171::-;24554:7;24585:1;24581;:5;:61;;24848:13;24914:15;;;24950:4;24943:15;;;24997:4;24981:21;;24581:61;;;24848:13;24914:15;;;24950:4;24943:15;;;24997:4;24981:21;;24589:25;24775:245;196:131:1;-1:-1:-1;;;;;271:31:1;;261:42;;251:70;;317:1;314;307:12;251:70;196:131;:::o;332:247::-;391:6;444:2;432:9;423:7;419:23;415:32;412:52;;;460:1;457;450:12;412:52;499:9;486:23;518:31;543:5;518:31;:::i;776:466::-;853:6;861;869;922:2;910:9;901:7;897:23;893:32;890:52;;;938:1;935;928:12;890:52;-1:-1:-1;;983:23:1;;;1103:2;1088:18;;1075:32;;-1:-1:-1;1206:2:1;1191:18;;;1178:32;;776:466;-1:-1:-1;776:466:1:o;1874:226::-;1933:6;1986:2;1974:9;1965:7;1961:23;1957:32;1954:52;;;2002:1;1999;1992:12;1954:52;-1:-1:-1;2047:23:1;;1874:226;-1:-1:-1;1874:226:1:o;2105:127::-;2166:10;2161:3;2157:20;2154:1;2147:31;2197:4;2194:1;2187:15;2221:4;2218:1;2211:15;2237:275;2308:2;2302:9;2373:2;2354:13;;-1:-1:-1;;2350:27:1;2338:40;;2408:18;2393:34;;2429:22;;;2390:62;2387:88;;;2455:18;;:::i;:::-;2491:2;2484:22;2237:275;;-1:-1:-1;2237:275:1:o;2517:183::-;2577:4;2610:18;2602:6;2599:30;2596:56;;;2632:18;;:::i;:::-;-1:-1:-1;2677:1:1;2673:14;2689:4;2669:25;;2517:183::o;2705:1141::-;2807:6;2815;2823;2876:2;2864:9;2855:7;2851:23;2847:32;2844:52;;;2892:1;2889;2882:12;2844:52;2937:23;;;-1:-1:-1;3036:2:1;3021:18;;3008:32;3049:33;3008:32;3049:33;:::i;:::-;3101:7;-1:-1:-1;3159:2:1;3144:18;;3131:32;3186:18;3175:30;;3172:50;;;3218:1;3215;3208:12;3172:50;3241:22;;3294:4;3286:13;;3282:27;-1:-1:-1;3272:55:1;;3323:1;3320;3313:12;3272:55;3363:2;3350:16;3386:64;3402:47;3442:6;3402:47;:::i;:::-;3386:64;:::i;:::-;3472:3;3496:6;3491:3;3484:19;3528:2;3523:3;3519:12;3512:19;;3583:2;3573:6;3570:1;3566:14;3562:2;3558:23;3554:32;3540:46;;3609:7;3601:6;3598:19;3595:39;;;3630:1;3627;3620:12;3595:39;3662:2;3658;3654:11;3643:22;;3674:142;3690:6;3685:3;3682:15;3674:142;;;3756:17;;3744:30;;3803:2;3707:12;;;;3794;;;;3674:142;;;3835:5;3825:15;;;;;;2705:1141;;;;;:::o;3851:367::-;3919:6;3927;3980:2;3968:9;3959:7;3955:23;3951:32;3948:52;;;3996:1;3993;3986:12;3948:52;4041:23;;;-1:-1:-1;4140:2:1;4125:18;;4112:32;4153:33;4112:32;4153:33;:::i;:::-;4205:7;4195:17;;;3851:367;;;;;:::o;4223:346::-;4291:6;4299;4352:2;4340:9;4331:7;4327:23;4323:32;4320:52;;;4368:1;4365;4358:12;4320:52;-1:-1:-1;;4413:23:1;;;4533:2;4518:18;;;4505:32;;-1:-1:-1;4223:346:1:o;4782:230::-;4852:6;4905:2;4893:9;4884:7;4880:23;4876:32;4873:52;;;4921:1;4918;4911:12;4873:52;-1:-1:-1;4966:16:1;;4782:230;-1:-1:-1;4782:230:1:o;5017:127::-;5078:10;5073:3;5069:20;5066:1;5059:31;5109:4;5106:1;5099:15;5133:4;5130:1;5123:15;5149:168;5222:9;;;5253;;5270:15;;;5264:22;;5250:37;5240:71;;5291:18;;:::i;5322:125::-;5387:9;;;5408:10;;;5405:36;;;5421:18;;:::i;5452:217::-;5492:1;5518;5508:132;;5562:10;5557:3;5553:20;5550:1;5543:31;5597:4;5594:1;5587:15;5625:4;5622:1;5615:15;5508:132;-1:-1:-1;5654:9:1;;5452:217::o;5674:339::-;5876:2;5858:21;;;5915:2;5895:18;;;5888:30;-1:-1:-1;;;5949:2:1;5934:18;;5927:45;6004:2;5989:18;;5674:339::o;7055:128::-;7122:9;;;7143:11;;;7140:37;;;7157:18;;:::i;7188:338::-;7390:2;7372:21;;;7429:2;7409:18;;;7402:30;-1:-1:-1;;;7463:2:1;7448:18;;7441:44;7517:2;7502:18;;7188:338::o;8762:251::-;8832:6;8885:2;8873:9;8864:7;8860:23;8856:32;8853:52;;;8901:1;8898;8891:12;8853:52;8933:9;8927:16;8952:31;8977:5;8952:31;:::i;9018:127::-;9079:10;9074:3;9070:20;9067:1;9060:31;9110:4;9107:1;9100:15;9134:4;9131:1;9124:15;9150:879;9376:4;9424:3;9413:9;9409:19;9455:6;9444:9;9437:25;9498:3;9493:2;9482:9;9478:18;9471:31;9522:6;9557;9551:13;9588:6;9580;9573:22;9626:3;9615:9;9611:19;9604:26;;9665:2;9657:6;9653:15;9639:29;;9686:1;9696:195;9710:6;9707:1;9704:13;9696:195;;;9775:13;;-1:-1:-1;;;;;9771:39:1;9759:52;;9840:2;9866:15;;;;9831:12;;;;9807:1;9725:9;9696:195;;;-1:-1:-1;;;;;;;9947:32:1;;;;9942:2;9927:18;;9920:60;-1:-1:-1;;10011:2:1;9996:18;9989:34;9908:3;9150:879;-1:-1:-1;;9150:879:1:o;10034:930::-;10129:6;10182:2;10170:9;10161:7;10157:23;10153:32;10150:52;;;10198:1;10195;10188:12;10150:52;10231:9;10225:16;10264:18;10256:6;10253:30;10250:50;;;10296:1;10293;10286:12;10250:50;10319:22;;10372:4;10364:13;;10360:27;-1:-1:-1;10350:55:1;;10401:1;10398;10391:12;10350:55;10434:2;10428:9;10457:64;10473:47;10513:6;10473:47;:::i;10457:64::-;10543:3;10567:6;10562:3;10555:19;10599:2;10594:3;10590:12;10583:19;;10654:2;10644:6;10641:1;10637:14;10633:2;10629:23;10625:32;10611:46;;10680:7;10672:6;10669:19;10666:39;;;10701:1;10698;10691:12;10666:39;10733:2;10729;10725:11;10714:22;;10745:189;10761:6;10756:3;10753:15;10745:189;;;10851:10;;10874:18;;10921:2;10778:12;;;;10912;;;;10745:189;;;10953:5;10034:930;-1:-1:-1;;;;;;10034:930:1:o
Swarm Source
ipfs://03c5fa495d4f12521457cd24f3da7d3b0b3071dc880444c8a3efb4436a42fb78
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
[ 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.