Overview
S Balance
0 SS Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
| Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
| Seed Market | 1029866 | 26 days ago | IN | 0 S | 0.00005559 |
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-21
*/
/**
*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 SONIC;
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
SONIC = IERC20(0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38);
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;
SONIC.safeTransfer(treasuryAddress, fee);
SONIC.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 depositSonic(uint amount, address ref) external {
require(initialized, "Not initialized");
require(amount > 0, "Invalid amount");
SONIC.safeTransferFrom(msg.sender, address(this), amount);
_deposit(amount, ref, false);
}
function depositSonicWithProof(
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");
SONIC.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);
SONIC.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(SONIC);
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 SONIC.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":"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":[],"name":"SONIC","outputs":[{"internalType":"contract IERC20","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":"minAmount","type":"uint256"},{"internalType":"address","name":"ref","type":"address"}],"name":"depositETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"ref","type":"address"}],"name":"depositSonic","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":"depositSonicWithProof","outputs":[],"stateMutability":"nonpayable","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)
000000000000000000000000667e3065e3f1f2236b91cd34262583a911931b2d0000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _treasuryAddress (address): 0x667E3065e3f1F2236b91CD34262583A911931B2d
Arg [1] : _merkleRoot (bytes32): 0x0000000000000000000000000000000000000000000000000000000000000000
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000667e3065e3f1f2236b91cd34262583a911931b2d
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
50538:7079:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56482:103;;;;;;;;;;-1:-1:-1;56566:10:0;56526:7;56553:24;;;:12;:24;;;;;;56482:103;;;160:25:1;;;148:2;133:18;56482:103:0;;;;;;;;50952:48;;;;;;;;;;-1:-1:-1;50952:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;56366:108;;;;;;;;;;;;;:::i;50704:31::-;;;;;;;;;;-1:-1:-1;50704:31:0;;;;;;;;;;;749:14:1;;742:22;724:41;;712:2;697:18;50704:31:0;584:187:1;51007:42:0;;;;;;;;;;-1:-1:-1;51007:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;55308:201;;;;;;;;;;-1:-1:-1;55308:201:0;;;;;:::i;:::-;;:::i;51819:814::-;;;;;;;;;;-1:-1:-1;51819:814:0;;;;;:::i;:::-;;:::i;:::-;;50798:25;;;;;;;;;;;;;;;;50770:21;;;;;;;;;;-1:-1:-1;50770:21:0;;;;-1:-1:-1;;;;;50770:21:0;;;;;;-1:-1:-1;;;;;1609:32:1;;;1591:51;;1579:2;1564:18;50770:21:0;1429:219:1;56061:106:0;;;;;;;;;;-1:-1:-1;56061:106:0;;;;;:::i;:::-;;:::i;50596:49::-;;;;;;;;;;;;;;;;56175:183;;;:::i;52641:617::-;;;;;;;;;;;;;:::i;51304:27::-;;;;;;;;;;;;;;;;53266:257;;;;;;:::i;:::-;;:::i;53535:272::-;;;;;;;;;;-1:-1:-1;53535:272:0;;;;;:::i;:::-;;:::i;51056:47::-;;;;;;;;;;-1:-1:-1;51056:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;50744:19;;;;;;;;;;-1:-1:-1;50744:19:0;;;;;;;-1:-1:-1;;;;;50744:19:0;;;55711:196;;;;;;;;;;-1:-1:-1;55711:196:0;;;;;:::i;:::-;;:::i;53815:508::-;;;;;;;;;;-1:-1:-1;53815:508:0;;;;;:::i;:::-;;:::i;55915:138::-;;;;;;;;;;-1:-1:-1;55915:138:0;;;;;:::i;:::-;;:::i;50869:20::-;;;;;;;;;;-1:-1:-1;50869:20:0;;;;-1:-1:-1;;;;;50869:20:0;;;51110:44;;;;;;;;;;-1:-1:-1;51110:44:0;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;51110:44:0;;;55517:186;;;;;;;;;;-1:-1:-1;55517:186:0;;;;;:::i;:::-;;:::i;50898:47::-;;;;;;;;;;-1:-1:-1;50898:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;56593:140;;;;;;;;;;;;;:::i;50832:30::-;;;;;;;;;;-1:-1:-1;50832:30:0;;;;-1:-1:-1;;;;;50832:30:0;;;57262:239;;;;;;;;;;;;;:::i;56741:513::-;;;;;;;;;;-1:-1:-1;56741:513:0;;;;;:::i;:::-;;:::i;56366:108::-;56436:5;;:30;;-1:-1:-1;;;56436:30:0;;56460:4;56436:30;;;1591:51:1;56409:7:0;;56436:5;;;-1:-1:-1;;;;;56436:5:0;;:15;;1564:18:1;;56436:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56429:37;;56366:108;:::o;55308:201::-;55423:7;55497:2;55491;55484:4;;:9;;;;:::i;:::-;55479:2;55473:3;;:8;;;;:::i;:::-;:20;;;;:::i;:::-;55472:27;;;;:::i;:::-;55464:4;;:36;;;;:::i;:::-;55457:2;55451:3;;:8;;;;:::i;:::-;55450:51;;;;:::i;:::-;55443:58;55308:201;-1:-1:-1;;;;55308:201:0:o;51819:814::-;51876:11;;;;51868:39;;;;-1:-1:-1;;;51868:39:0;;;;;;;:::i;:::-;;;;;;;;;51929:10;-1:-1:-1;;;;;51922:17:0;;;51918:66;;-1:-1:-1;51970:1:0;51918:66;52022:10;52045:1;52012:21;;;:9;:21;;;;;;-1:-1:-1;;;;;52012:21:0;:35;:87;;;;-1:-1:-1;52089:10:0;52064:21;;;;:9;:21;;;;;;-1:-1:-1;;;;;52064:21:0;:35;;52012:87;51994:171;;;52136:10;52126:21;;;;:9;:21;;;;;:27;;-1:-1:-1;;;;;;52126:27:0;-1:-1:-1;;;;;52126:27:0;;;;;51994:171;52175:18;52196:13;:11;:13::i;:::-;52175:34;;52222:17;52255:25;;52242:10;:38;;;;:::i;:::-;52304:10;52291:24;;;;:12;:24;;;;;:37;;52222:58;;-1:-1:-1;52222:58:0;;52291:24;;;:37;;52222:58;;52291:37;:::i;:::-;;;;-1:-1:-1;;52353:10:0;52367:1;52339:25;;;:13;:25;;;;;;;;:29;;;52379:7;:19;;;;;;;52401:15;52379:37;;52510:15;;:10;:15;:::i;:::-;52494:10;52470:36;52484:21;;;:9;:21;;;;;;;;;-1:-1:-1;;;;;52484:21:0;52470:36;;:13;:36;;;;;:55;;:36;;;:55;;;;;:::i;:::-;;;;-1:-1:-1;52611:14:0;;-1:-1:-1;52624:1:0;52611:10;:14;:::i;:::-;52595:12;;:30;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;51819:814:0:o;56061:106::-;56114:7;56156:3;56142:10;:6;56151:1;56142:10;:::i;:::-;56141:18;;;;:::i;:::-;56134:25;56061:106;-1:-1:-1;;56061:106:0:o;56175:183::-;51394:5;;-1:-1:-1;;;;;51394:5:0;51380:10;:19;51372:41;;;;-1:-1:-1;;;51372:41:0;;6220:2:1;51372:41:0;;;6202:21:1;6259:1;6239:18;;;6232:29;-1:-1:-1;;;6277:18:1;;;6270:39;6326:18;;51372:41:0;6018:332:1;51372:41:0;56241:12:::1;::::0;:17;56233:51:::1;;;::::0;-1:-1:-1;;;56233:51:0;;6557:2:1;56233: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;;56233:51:0::1;6355:345:1::0;56233:51:0::1;56295:11;:18:::0;;-1:-1:-1;;56295:18:0::1;56309:4;56295:18;::::0;;56339:11:::1;56324:12;:26:::0;56175:183::o;52641:617::-;52689:11;;;;52681:39;;;;-1:-1:-1;;;52681:39:0;;;;;;;:::i;:::-;52731:17;52751:13;:11;:13::i;:::-;52731:33;;52797:1;52785:9;:13;52777:47;;;;-1:-1:-1;;;52777:47:0;;6907:2:1;52777:47:0;;;6889:21:1;6946:2;6926:18;;;6919:30;-1:-1:-1;;;6965:18:1;;;6958:51;7026:18;;52777:47:0;6705:345:1;52777:47:0;52835:18;52856:29;52875:9;52856:18;:29::i;:::-;52835:50;;52896:11;52910:18;52917:10;52910:6;:18::i;:::-;52955:10;52969:1;52941:25;;;:13;:25;;;;;;;;:29;;;52981:7;:19;;;;;53003:15;52981:37;;;;53029:12;:24;;;;;:42;53113:12;:25;;52896:32;;-1:-1:-1;53129:9:0;;53113:12;;52969:1;53113:25;;53129:9;;53113:25;:::i;:::-;;;;-1:-1:-1;;53170:15:0;;53151:5;;:40;;-1:-1:-1;;;;;53170:15:0;53151:5;;;;;;53170:15;53187:3;53151:18;:40::i;:::-;53202:48;53221:10;53233:16;53246:3;53233:10;:16;:::i;:::-;53202:5;;;;;-1:-1:-1;;;;;53202:5:0;;;:18;:48::i;:::-;52670:588;;;52641:617::o;53266:257::-;53351:11;;;;53343:39;;;;-1:-1:-1;;;53343:39:0;;;;;;;:::i;:::-;53413:1;53401:9;:13;53393:40;;;;-1:-1:-1;;;53393:40:0;;;;;;;:::i;:::-;53446:11;53460:16;53466:9;53460:5;:16::i;:::-;53446:30;;53487:28;53496:6;53504:3;53509:5;53487:8;:28::i;53535:272::-;53611:11;;;;53603:39;;;;-1:-1:-1;;;53603:39:0;;;;;;;:::i;:::-;53670:1;53661:6;:10;53653:37;;;;-1:-1:-1;;;53653:37:0;;;;;;;:::i;:::-;53703:5;;:57;;:5;;;-1:-1:-1;;;;;53703:5:0;53726:10;53746:4;53753:6;53703:22;:57::i;:::-;53771:28;53780:6;53788:3;53793:5;53771:8;:28::i;:::-;53535:272;;:::o;55711:196::-;55822:7;55849:50;55864:3;55869:15;55886:12;;55849:14;:50::i;:::-;55842:57;55711:196;-1:-1:-1;;;55711:196:0:o;53815:508::-;53958:11;;;;53950:39;;;;-1:-1:-1;;;53950:39:0;;;;;;;:::i;:::-;54017:1;54008:6;:10;54000:37;;;;-1:-1:-1;;;54000:37:0;;;;;;;:::i;:::-;54075:28;;-1:-1:-1;;54092:10:0;7680:2:1;7676:15;7672:53;54075:28:0;;;7660:66:1;54050:12:0;;7742::1;;54075:28:0;;;;;;;;;;;;54065:39;;;;;;54050:54;;54123:43;54142:5;54149:10;;54161:4;54123:18;:43::i;:::-;54115:69;;;;-1:-1:-1;;;54115:69:0;;7967:2:1;54115:69:0;;;7949:21:1;8006:2;7986:18;;;7979:30;-1:-1:-1;;;8025:18:1;;;8018:43;8078:18;;54115:69:0;7765:337:1;54115:69:0;54197:5;;:57;;:5;;;-1:-1:-1;;;;;54197:5:0;54220:10;54240:4;54247:6;54197:22;:57::i;:::-;54265:27;54274:6;54282:3;54287:4;54265:8;:27::i;:::-;53939:384;53815:508;;;:::o;55915:138::-;55982:7;56009:36;56027:3;56032:12;:10;:12::i;55517:186::-;55582:7;55606:6;55616:1;55606:11;55602:25;;-1:-1:-1;55626:1:0;;55517:186;-1:-1:-1;55517:186:0:o;55602:25::-;55645:50;55660:6;55668:12;;55682;:10;:12::i;56593:140::-;56637:7;56692:33;56714:10;56692:21;:33::i;:::-;56678:10;56664:25;;;;:13;:25;;;;;;:61;;;;:::i;57262:239::-;57383:10;57315:7;57370:24;;;:12;:24;;;;;;57315:7;;51191:6;;57352:42;;:15;:42;:::i;:::-;57351:68;;;;:::i;:::-;57335:84;-1:-1:-1;57439:54:0;57443:4;57467:25;51241:6;57335:84;57467:25;:::i;:::-;57449:43;;51289:6;57449:43;:::i;:::-;57439:3;:54::i;:::-;57432:61;;;57262:239;:::o;56741:513::-;56874:10;56806:7;56861:24;;;:12;:24;;;;;;56806:7;;51191:6;;56843:42;;:15;:42;:::i;:::-;56842:68;;;;:::i;:::-;56826:84;-1:-1:-1;56923:18:0;56944:91;56962:4;56999:25;51241:6;56826:84;56999:25;:::i;56944:91::-;57048:21;57090:25;;-1:-1:-1;;;;;57148:12:0;;;;:7;:12;;;;;;56923:112;;-1:-1:-1;57048:21:0;;57072:99;;57090:25;57130:30;;:15;:30;:::i;57072:99::-;-1:-1:-1;;;;;57207:17:0;;;;;;:12;:17;;;;;;57048:123;;-1:-1:-1;57242:4:0;;57228:10;;57191:33;;57048:123;57191:33;:::i;:::-;57190:48;;;;:::i;:::-;57189:57;;;;:::i;:::-;57182:64;56741:513;-1:-1:-1;;;;;56741: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;54838:462::-;54889:4;54906:19;54928:12;:10;:12::i;:::-;54977:16;;;54991:1;54977:16;;;;;;;;54906:34;;-1:-1:-1;54953:21:0;;54977:16;;;;;;;;;;-1:-1:-1;;55014:6:0;;;:13;;;-1:-1:-1;;;55014:13:0;;;;54953:40;;-1:-1:-1;;;;;;55014:6:0;;;;:11;;-1:-1:-1;55014:13:0;;;;;;;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55004:4;55009:1;55004:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;55004:23:0;;;:7;;;;;;;;;:23;55056:5;;55038:7;;55056:5;;;;;;;;55038:4;;55056:5;;55038:7;;;;;;:::i;:::-;-1:-1:-1;;;;;55038:24:0;;;:7;;;;;;;;;:24;55083:6;;;:160;;-1:-1:-1;;;55083:160:0;;:6;;;:28;;55119:9;;55083:160;;55144:11;;55170:4;;55197;;55217:15;;55083:160;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;55083:160:0;;;;;;;;;;;;:::i;:::-;;55278:14;55263:12;:10;:12::i;:::-;:29;;;;:::i;54331:499::-;54408:20;54431:48;54449:6;54472;54457:12;:10;:12::i;:::-;:21;;;;:::i;54431:48::-;54408:71;;54496:6;54492:112;;;54556:3;54536:16;:12;54551:1;54536:16;:::i;:::-;54535:24;;;;:::i;:::-;54519:40;;;;:::i;:::-;;;54492:112;54632:20;54639:12;54632:6;:20::i;:::-;54616:36;;;;:::i;:::-;;;54663:11;54677:14;54684:6;54677;:14::i;:::-;54723:15;;54704:5;;54663:28;;-1:-1:-1;54704:40:0;;54723:15;54704:5;;-1:-1:-1;;;;;54704:5:0;;;;54723:15;54663:28;54704:18;:40::i;:::-;54771:10;54757:25;;;;:13;:25;;;;;:41;;54786:12;;54757:25;:41;;54786:12;;54757:41;:::i;:::-;;;;-1:-1:-1;54809:13:0;;-1:-1:-1;54818:3:0;54809:8;:13::i;:::-;54397:433;;54331:499;;;:::o;16162:190::-;16290:53;;-1:-1:-1;;;;;10813:32:1;;;16290:53:0;;;10795:51:1;10882:32;;;10862:18;;;10855:60;10931:18;;;10924:34;;;16263:81:0;;16283:5;;16305:18;;;;;10768::1;;16290:53:0;10593:371:1;26695:156:0;26786:4;26839;26810:25;26823:5;26830:4;26810:12;:25::i;:::-;:33;;26695:156;-1:-1:-1;;;;26695:156:0:o;57509:105::-;57566:7;57597:1;57593;:5;:13;;57605:1;57593:13;;;-1:-1:-1;57601:1:0;;57509:105;-1:-1:-1;57509: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;;;;;1609:32:1;;23027:40:0;;;1591:51:1;1564:18;;23027:40:0;1429:219: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;1653:226::-;1712:6;1765:2;1753:9;1744:7;1740:23;1736:32;1733:52;;;1781:1;1778;1771:12;1733:52;-1:-1:-1;1826:23:1;;1653:226;-1:-1:-1;1653:226:1:o;1884:367::-;1952:6;1960;2013:2;2001:9;1992:7;1988:23;1984:32;1981:52;;;2029:1;2026;2019:12;1981:52;2074:23;;;-1:-1:-1;2173:2:1;2158:18;;2145:32;2186:33;2145:32;2186:33;:::i;:::-;2238:7;2228:17;;;1884:367;;;;;:::o;2477:346::-;2545:6;2553;2606:2;2594:9;2585:7;2581:23;2577:32;2574:52;;;2622:1;2619;2612:12;2574:52;-1:-1:-1;;2667:23:1;;;2787:2;2772:18;;;2759:32;;-1:-1:-1;2477:346:1:o;2828:127::-;2889:10;2884:3;2880:20;2877:1;2870:31;2920:4;2917:1;2910:15;2944:4;2941:1;2934:15;2960:275;3031:2;3025:9;3096:2;3077:13;;-1:-1:-1;;3073:27:1;3061:40;;3131:18;3116:34;;3152:22;;;3113:62;3110:88;;;3178:18;;:::i;:::-;3214:2;3207:22;2960:275;;-1:-1:-1;2960:275:1:o;3240:183::-;3300:4;3333:18;3325:6;3322:30;3319:56;;;3355:18;;:::i;:::-;-1:-1:-1;3400:1:1;3396:14;3412:4;3392:25;;3240:183::o;3428:1141::-;3530:6;3538;3546;3599:2;3587:9;3578:7;3574:23;3570:32;3567:52;;;3615:1;3612;3605:12;3567:52;3660:23;;;-1:-1:-1;3759:2:1;3744:18;;3731:32;3772:33;3731:32;3772:33;:::i;:::-;3824:7;-1:-1:-1;3882:2:1;3867:18;;3854:32;3909:18;3898:30;;3895:50;;;3941:1;3938;3931:12;3895:50;3964:22;;4017:4;4009:13;;4005:27;-1:-1:-1;3995:55:1;;4046:1;4043;4036:12;3995:55;4086:2;4073:16;4109:64;4125:47;4165:6;4125:47;:::i;:::-;4109:64;:::i;:::-;4195:3;4219:6;4214:3;4207:19;4251:2;4246:3;4242:12;4235:19;;4306:2;4296:6;4293:1;4289:14;4285:2;4281:23;4277:32;4263:46;;4332:7;4324:6;4321:19;4318:39;;;4353:1;4350;4343:12;4318:39;4385:2;4381;4377:11;4366:22;;4397:142;4413:6;4408:3;4405:15;4397:142;;;4479:17;;4467:30;;4526:2;4430:12;;;;4517;;;;4397:142;;;4558:5;4548:15;;;;;;3428:1141;;;;;:::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;8386:251::-;8456:6;8509:2;8497:9;8488:7;8484:23;8480:32;8477:52;;;8525:1;8522;8515:12;8477:52;8557:9;8551:16;8576:31;8601:5;8576:31;:::i;8642:127::-;8703:10;8698:3;8694:20;8691:1;8684:31;8734:4;8731:1;8724:15;8758:4;8755:1;8748:15;8774:879;9000:4;9048:3;9037:9;9033:19;9079:6;9068:9;9061:25;9122:3;9117:2;9106:9;9102:18;9095:31;9146:6;9181;9175:13;9212:6;9204;9197:22;9250:3;9239:9;9235:19;9228:26;;9289:2;9281:6;9277:15;9263:29;;9310:1;9320:195;9334:6;9331:1;9328:13;9320:195;;;9399:13;;-1:-1:-1;;;;;9395:39:1;9383:52;;9464:2;9490:15;;;;9455:12;;;;9431:1;9349:9;9320:195;;;-1:-1:-1;;;;;;;9571:32:1;;;;9566:2;9551:18;;9544:60;-1:-1:-1;;9635:2:1;9620:18;9613:34;9532:3;8774:879;-1:-1:-1;;8774:879:1:o;9658:930::-;9753:6;9806:2;9794:9;9785:7;9781:23;9777:32;9774:52;;;9822:1;9819;9812:12;9774:52;9855:9;9849:16;9888:18;9880:6;9877:30;9874:50;;;9920:1;9917;9910:12;9874:50;9943:22;;9996:4;9988:13;;9984:27;-1:-1:-1;9974:55:1;;10025:1;10022;10015:12;9974:55;10058:2;10052:9;10081:64;10097:47;10137:6;10097:47;:::i;10081:64::-;10167:3;10191:6;10186:3;10179:19;10223:2;10218:3;10214:12;10207:19;;10278:2;10268:6;10265:1;10261:14;10257:2;10253:23;10249:32;10235:46;;10304:7;10296:6;10293:19;10290:39;;;10325:1;10322;10315:12;10290:39;10357:2;10353;10349:11;10338:22;;10369:189;10385:6;10380:3;10377:15;10369:189;;;10475:10;;10498:18;;10545:2;10402:12;;;;10536;;;;10369:189;;;10577:5;9658:930;-1:-1:-1;;;;;;9658:930:1:o
Swarm Source
ipfs://91fd65ba4824327b5d8da07b0f30b6d90a30c96e1d3ae72b1765711fe27548bd
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.