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 | 949316 | 30 days 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, supporting tokens with fees on transfer.
* @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.
*/
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
/**
* @notice Returns the address of WETH (Wrapped ETH) on the Base blockchain.
* @return The address of 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.swapExactETHForTokensSupportingFeeOnTransferTokens{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
50465:7098:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56428:103;;;;;;;;;;-1:-1:-1;56512:10:0;56472:7;56499:24;;;:12;:24;;;;;;56428:103;;;160:25:1;;;148:2;133:18;56428:103:0;;;;;;;;50879:48;;;;;;;;;;-1:-1:-1;50879:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;56312:108;;;;;;;;;;;;;:::i;50631:31::-;;;;;;;;;;-1:-1:-1;50631:31:0;;;;;;;;;;;749:14:1;;742:22;724:41;;712:2;697:18;50631:31:0;584:187:1;50934:42:0;;;;;;;;;;-1:-1:-1;50934:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;55254:201;;;;;;;;;;-1:-1:-1;55254:201:0;;;;;:::i;:::-;;:::i;51746:814::-;;;;;;;;;;-1:-1:-1;51746:814:0;;;;;:::i;:::-;;:::i;:::-;;50725:25;;;;;;;;;;;;;;;;50671:19;;;;;;;;;;-1:-1:-1;50671:19:0;;;;;;;-1:-1:-1;;;;;50671:19:0;;;;;;-1:-1:-1;;;;;1606:32:1;;;1588:51;;1576:2;1561:18;50671:19:0;1429:216:1;50697:21:0;;;;;;;;;;-1:-1:-1;50697:21:0;;;;-1:-1:-1;;;;;50697:21:0;;;56007:106;;;;;;;;;;-1:-1:-1;56007:106:0;;;;;:::i;:::-;;:::i;50523:49::-;;;;;;;;;;;;;;;;56121:183;;;:::i;52568:617::-;;;;;;;;;;;;;:::i;51231:27::-;;;;;;;;;;;;;;;;53742:508;;;;;;;;;;-1:-1:-1;53742:508:0;;;;;:::i;:::-;;:::i;53193:257::-;;;;;;:::i;:::-;;:::i;50983:47::-;;;;;;;;;;-1:-1:-1;50983:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;55657:196;;;;;;;;;;-1:-1:-1;55657:196:0;;;;;:::i;:::-;;:::i;55861:138::-;;;;;;;;;;-1:-1:-1;55861:138:0;;;;;:::i;:::-;;:::i;50796:20::-;;;;;;;;;;-1:-1:-1;50796:20:0;;;;-1:-1:-1;;;;;50796:20:0;;;51037:44;;;;;;;;;;-1:-1:-1;51037:44:0;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;51037:44:0;;;55463:186;;;;;;;;;;-1:-1:-1;55463:186:0;;;;;:::i;:::-;;:::i;53462:272::-;;;;;;;;;;-1:-1:-1;53462:272:0;;;;;:::i;:::-;;:::i;50825:47::-;;;;;;;;;;-1:-1:-1;50825:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;56539:140;;;;;;;;;;;;;:::i;50759:30::-;;;;;;;;;;-1:-1:-1;50759:30:0;;;;-1:-1:-1;;;;;50759:30:0;;;57208:239;;;;;;;;;;;;;:::i;56687:513::-;;;;;;;;;;-1:-1:-1;56687:513:0;;;;;:::i;:::-;;:::i;56312:108::-;56382:5;;:30;;-1:-1:-1;;;56382:30:0;;56406:4;56382:30;;;1588:51:1;56355:7:0;;56382:5;;;-1:-1:-1;;;;;56382:5:0;;:15;;1561:18:1;;56382:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56375:37;;56312:108;:::o;55254:201::-;55369:7;55443:2;55437;55430:4;;:9;;;;:::i;:::-;55425:2;55419:3;;:8;;;;:::i;:::-;:20;;;;:::i;:::-;55418:27;;;;:::i;:::-;55410:4;;:36;;;;:::i;:::-;55403:2;55397:3;;:8;;;;:::i;:::-;55396:51;;;;:::i;:::-;55389:58;55254:201;-1:-1:-1;;;;55254:201:0:o;51746:814::-;51803:11;;;;51795:39;;;;-1:-1:-1;;;51795:39:0;;;;;;;:::i;:::-;;;;;;;;;51856:10;-1:-1:-1;;;;;51849:17:0;;;51845:66;;-1:-1:-1;51897:1:0;51845:66;51949:10;51972:1;51939:21;;;:9;:21;;;;;;-1:-1:-1;;;;;51939:21:0;:35;:87;;;;-1:-1:-1;52016:10:0;51991:21;;;;:9;:21;;;;;;-1:-1:-1;;;;;51991:21:0;:35;;51939:87;51921:171;;;52063:10;52053:21;;;;:9;:21;;;;;:27;;-1:-1:-1;;;;;;52053:27:0;-1:-1:-1;;;;;52053:27:0;;;;;51921:171;52102:18;52123:13;:11;:13::i;:::-;52102:34;;52149:17;52182:25;;52169:10;:38;;;;:::i;:::-;52231:10;52218:24;;;;:12;:24;;;;;:37;;52149:58;;-1:-1:-1;52149:58:0;;52218:24;;;:37;;52149:58;;52218:37;:::i;:::-;;;;-1:-1:-1;;52280:10:0;52294:1;52266:25;;;:13;:25;;;;;;;;:29;;;52306:7;:19;;;;;;;52328:15;52306:37;;52437:15;;:10;:15;:::i;:::-;52421:10;52397:36;52411:21;;;:9;:21;;;;;;;;;-1:-1:-1;;;;;52411:21:0;52397:36;;:13;:36;;;;;:55;;:36;;;:55;;;;;:::i;:::-;;;;-1:-1:-1;52538:14:0;;-1:-1:-1;52551:1:0;52538:10;:14;:::i;:::-;52522:12;;:30;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;51746:814:0:o;56007:106::-;56060:7;56102:3;56088:10;:6;56097:1;56088:10;:::i;:::-;56087:18;;;;:::i;:::-;56080:25;56007:106;-1:-1:-1;;56007:106:0:o;56121:183::-;51321:5;;-1:-1:-1;;;;;51321:5:0;51307:10;:19;51299:41;;;;-1:-1:-1;;;51299:41:0;;6001:2:1;51299:41:0;;;5983:21:1;6040:1;6020:18;;;6013:29;-1:-1:-1;;;6058:18:1;;;6051:39;6107:18;;51299:41:0;5799:332:1;51299:41:0;56187:12:::1;::::0;:17;56179:51:::1;;;::::0;-1:-1:-1;;;56179:51:0;;6338:2:1;56179:51:0::1;::::0;::::1;6320:21:1::0;6377:2;6357:18;;;6350:30;-1:-1:-1;;;6396:18:1;;;6389:51;6457:18;;56179:51:0::1;6136:345:1::0;56179:51:0::1;56241:11;:18:::0;;-1:-1:-1;;56241:18:0::1;56255:4;56241:18;::::0;;56285:11:::1;56270:12;:26:::0;56121:183::o;52568:617::-;52616:11;;;;52608:39;;;;-1:-1:-1;;;52608:39:0;;;;;;;:::i;:::-;52658:17;52678:13;:11;:13::i;:::-;52658:33;;52724:1;52712:9;:13;52704:47;;;;-1:-1:-1;;;52704:47:0;;6688:2:1;52704:47:0;;;6670:21:1;6727:2;6707:18;;;6700:30;-1:-1:-1;;;6746:18:1;;;6739:51;6807:18;;52704:47:0;6486:345:1;52704:47:0;52762:18;52783:29;52802:9;52783:18;:29::i;:::-;52762:50;;52823:11;52837:18;52844:10;52837:6;:18::i;:::-;52882:10;52896:1;52868:25;;;:13;:25;;;;;;;;:29;;;52908:7;:19;;;;;52930:15;52908:37;;;;52956:12;:24;;;;;:42;53040:12;:25;;52823:32;;-1:-1:-1;53056:9:0;;53040:12;;52896:1;53040:25;;53056:9;;53040:25;:::i;:::-;;;;-1:-1:-1;;53097:15:0;;53078:5;;:40;;-1:-1:-1;;;;;53097:15:0;53078:5;;;;;;53097:15;53114:3;53078:18;:40::i;:::-;53129:48;53148:10;53160:16;53173:3;53160:10;:16;:::i;:::-;53129:5;;;;;-1:-1:-1;;;;;53129:5:0;;;:18;:48::i;:::-;52597:588;;;52568:617::o;53742:508::-;53885:11;;;;53877:39;;;;-1:-1:-1;;;53877:39:0;;;;;;;:::i;:::-;53944:1;53935:6;:10;53927:37;;;;-1:-1:-1;;;53927:37:0;;;;;;;:::i;:::-;54002:28;;-1:-1:-1;;54019:10:0;7461:2:1;7457:15;7453:53;54002:28:0;;;7441:66:1;53977:12:0;;7523::1;;54002:28:0;;;;;;;;;;;;53992:39;;;;;;53977:54;;54050:43;54069:5;54076:10;;54088:4;54050:18;:43::i;:::-;54042:69;;;;-1:-1:-1;;;54042:69:0;;7748:2:1;54042:69:0;;;7730:21:1;7787:2;7767:18;;;7760:30;-1:-1:-1;;;7806:18:1;;;7799:43;7859:18;;54042:69:0;7546:337:1;54042:69:0;54124:5;;:57;;:5;;;-1:-1:-1;;;;;54124:5:0;54147:10;54167:4;54174:6;54124:22;:57::i;:::-;54192:27;54201:6;54209:3;54214:4;54192:8;:27::i;:::-;53866:384;53742:508;;;:::o;53193:257::-;53278:11;;;;53270:39;;;;-1:-1:-1;;;53270:39:0;;;;;;;:::i;:::-;53340:1;53328:9;:13;53320:40;;;;-1:-1:-1;;;53320:40:0;;;;;;;:::i;:::-;53373:11;53387:16;53393:9;53387:5;:16::i;:::-;53373:30;;53414:28;53423:6;53431:3;53436:5;53414:8;:28::i;55657:196::-;55768:7;55795:50;55810:3;55815:15;55832:12;;55795:14;:50::i;:::-;55788:57;55657:196;-1:-1:-1;;;55657:196:0:o;55861:138::-;55928:7;55955:36;55973:3;55978:12;:10;:12::i;55463:186::-;55528:7;55552:6;55562:1;55552:11;55548:25;;-1:-1:-1;55572:1:0;;55463:186;-1:-1:-1;55463:186:0:o;55548:25::-;55591:50;55606:6;55614:12;;55628;:10;:12::i;53462:272::-;53538:11;;;;53530:39;;;;-1:-1:-1;;;53530:39:0;;;;;;;:::i;:::-;53597:1;53588:6;:10;53580:37;;;;-1:-1:-1;;;53580:37:0;;;;;;;:::i;:::-;53630:5;;:57;;:5;;;-1:-1:-1;;;;;53630:5:0;53653:10;53673:4;53680:6;53630:22;:57::i;:::-;53698:28;53707:6;53715:3;53720:5;53698:8;:28::i;:::-;53462:272;;:::o;56539:140::-;56583:7;56638:33;56660:10;56638:21;:33::i;:::-;56624:10;56610:25;;;;:13;:25;;;;;;:61;;;;:::i;57208:239::-;57329:10;57261:7;57316:24;;;:12;:24;;;;;;57261:7;;51118:6;;57298:42;;:15;:42;:::i;:::-;57297:68;;;;:::i;:::-;57281:84;-1:-1:-1;57385:54:0;57389:4;57413:25;51168:6;57281:84;57413:25;:::i;:::-;57395:43;;51216:6;57395:43;:::i;:::-;57385:3;:54::i;:::-;57378:61;;;57208:239;:::o;56687:513::-;56820:10;56752:7;56807:24;;;:12;:24;;;;;;56752:7;;51118:6;;56789:42;;:15;:42;:::i;:::-;56788:68;;;;:::i;:::-;56772:84;-1:-1:-1;56869:18:0;56890:91;56908:4;56945:25;51168:6;56772:84;56945:25;:::i;56890:91::-;56994:21;57036:25;;-1:-1:-1;;;;;57094:12:0;;;;:7;:12;;;;;;56869:112;;-1:-1:-1;56994:21:0;;57018:99;;57036:25;57076:30;;:15;:30;:::i;57018:99::-;-1:-1:-1;;;;;57153:17:0;;;;;;:12;:17;;;;;;56994:123;;-1:-1:-1;57188:4:0;;57174:10;;57137:33;;56994:123;57137:33;:::i;:::-;57136:48;;;;:::i;:::-;57135:57;;;;:::i;:::-;57128:64;56687:513;-1:-1:-1;;;;;56687:513:0:o;15755:162::-;15865:43;;-1:-1:-1;;;;;8080:32:1;;;15865:43:0;;;8062:51:1;8129:18;;;8122:34;;;15838:71:0;;15858:5;;15880:14;;;;;8035: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;;;;;8387:32:1;;;16290:53:0;;;8369:51:1;8456:32;;;8436:18;;;8429:60;8505:18;;;8498:34;;;16263:81:0;;16283:5;;16305:18;;;;;8342::1;;16290:53:0;8167:371:1;54258:499:0;54335:20;54358:48;54376:6;54399;54384:12;:10;:12::i;:::-;:21;;;;:::i;54358:48::-;54335:71;;54423:6;54419:112;;;54483:3;54463:16;:12;54478:1;54463:16;:::i;:::-;54462:24;;;;:::i;:::-;54446:40;;;;:::i;:::-;;;54419:112;54559:20;54566:12;54559:6;:20::i;:::-;54543:36;;;;:::i;:::-;;;54590:11;54604:14;54611:6;54604;:14::i;:::-;54650:15;;54631:5;;54590:28;;-1:-1:-1;54631:40:0;;54650:15;54631:5;;-1:-1:-1;;;;;54631:5:0;;;;54650:15;54590:28;54631:18;:40::i;:::-;54698:10;54684:25;;;;:13;:25;;;;;:41;;54713:12;;54684:25;:41;;54713:12;;54684:41;:::i;:::-;;;;-1:-1:-1;54736:13:0;;-1:-1:-1;54745:3:0;54736:8;:13::i;:::-;54324:433;;54258:499;;;:::o;54765:481::-;54816:4;54833:19;54855:12;:10;:12::i;:::-;54904:16;;;54918:1;54904:16;;;;;;;;54833:34;;-1:-1:-1;54880:21:0;;54904:16;;;;;;;;;;-1:-1:-1;;54951:6:0;;;:13;;;-1:-1:-1;;;54951:13:0;;;;54880:40;;-1:-1:-1;;;;;;54951:6:0;;;;:11;;-1:-1:-1;54951:13:0;;;;;;;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54941:4;54946:1;54941:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;54941:23:0;;;:7;;;;;;;;;:23;54993:5;;54975:7;;54993:5;;;;;;;;54975:4;;54993:5;;54975:7;;;;;;:::i;:::-;-1:-1:-1;;;;;54975:24:0;;;:7;;;;;;;;;:24;55020:6;;;:169;;-1:-1:-1;;;55020:169:0;;:6;;;:57;;55085:9;;55020:169;;55106:11;;55128:4;;55151;;55167:15;;55020:169;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55224:14;55209:12;:10;:12::i;:::-;:29;;;;:::i;57455:105::-;57512:7;57543:1;57539;:5;:13;;57551:1;57539:13;;;-1:-1:-1;57547:1:0;;57455:105;-1:-1:-1;57455: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:1436;2339:6;2347;2355;2408:2;2396:9;2387:7;2383:23;2379:32;2376:52;;;2424:1;2421;2414:12;2376:52;2469:23;;;-1:-1:-1;2568:2:1;2553:18;;2540:32;2581:33;2540:32;2581:33;:::i;:::-;2633:7;-1:-1:-1;2691:2:1;2676:18;;2663:32;2718:18;2707:30;;2704:50;;;2750:1;2747;2740:12;2704:50;2773:22;;2826:4;2818:13;;2814:27;-1:-1:-1;2804:55:1;;2855:1;2852;2845:12;2804:55;2895:2;2882:16;2921:18;2913:6;2910:30;2907:56;;;2943:18;;:::i;:::-;2989:6;2986:1;2982:14;3025:2;3019:9;3088:2;3084:7;3079:2;3075;3071:11;3067:25;3059:6;3055:38;3159:6;3147:10;3144:22;3123:18;3111:10;3108:34;3105:62;3102:88;;;3170:18;;:::i;:::-;3206:2;3199:22;3256;;;3306:2;3336:11;;;3332:20;;;3256:22;3294:15;;3364:19;;;3361:39;;;3396:1;3393;3386:12;3361:39;3428:2;3424;3420:11;3409:22;;3440:202;3456:6;3451:3;3448:15;3440:202;;;3550:17;;3580:20;;;3629:2;3473:12;;;;3550:17;;-1:-1:-1;3620:12:1;3440:202;;;3444:3;3661:6;3651:16;;;;;;2237:1436;;;;;:::o;3678:367::-;3746:6;3754;3807:2;3795:9;3786:7;3782:23;3778:32;3775:52;;;3823:1;3820;3813:12;3775:52;3868:23;;;-1:-1:-1;3967:2:1;3952:18;;3939:32;3980:33;3939:32;3980:33;:::i;:::-;4032:7;4022:17;;;3678:367;;;;;:::o;4050:346::-;4118:6;4126;4179:2;4167:9;4158:7;4154:23;4150:32;4147:52;;;4195:1;4192;4185:12;4147:52;-1:-1:-1;;4240:23:1;;;4360:2;4345:18;;;4332:32;;-1:-1:-1;4050:346:1:o;4609:184::-;4679:6;4732:2;4720:9;4711:7;4707:23;4703:32;4700:52;;;4748:1;4745;4738:12;4700:52;-1:-1:-1;4771:16:1;;4609:184;-1:-1:-1;4609:184:1:o;4798:127::-;4859:10;4854:3;4850:20;4847:1;4840:31;4890:4;4887:1;4880:15;4914:4;4911:1;4904:15;4930:168;5003:9;;;5034;;5051:15;;;5045:22;;5031:37;5021:71;;5072:18;;:::i;5103:125::-;5168:9;;;5189:10;;;5186:36;;;5202:18;;:::i;5233:217::-;5273:1;5299;5289:132;;5343:10;5338:3;5334:20;5331:1;5324:31;5378:4;5375:1;5368:15;5406:4;5403:1;5396:15;5289:132;-1:-1:-1;5435:9:1;;5233:217::o;5455:339::-;5657:2;5639:21;;;5696:2;5676:18;;;5669:30;-1:-1:-1;;;5730:2:1;5715:18;;5708:45;5785:2;5770:18;;5455:339::o;6836:128::-;6903:9;;;6924:11;;;6921:37;;;6938:18;;:::i;6969:338::-;7171:2;7153:21;;;7210:2;7190:18;;;7183:30;-1:-1:-1;;;7244:2:1;7229:18;;7222:44;7298:2;7283:18;;6969:338::o;8543:251::-;8613:6;8666:2;8654:9;8645:7;8641:23;8637:32;8634:52;;;8682:1;8679;8672:12;8634:52;8714:9;8708:16;8733:31;8758:5;8733:31;:::i;8799:127::-;8860:10;8855:3;8851:20;8848:1;8841:31;8891:4;8888:1;8881:15;8915:4;8912:1;8905:15;8931:879;9157:4;9205:3;9194:9;9190:19;9236:6;9225:9;9218:25;9279:3;9274:2;9263:9;9259:18;9252:31;9303:6;9338;9332:13;9369:6;9361;9354:22;9407:3;9396:9;9392:19;9385:26;;9446:2;9438:6;9434:15;9420:29;;9467:1;9477:195;9491:6;9488:1;9485:13;9477:195;;;9556:13;;-1:-1:-1;;;;;9552:39:1;9540:52;;9621:2;9647:15;;;;9612:12;;;;9588:1;9506:9;9477:195;;;-1:-1:-1;;;;;;;9728:32:1;;;;9723:2;9708:18;;9701:60;-1:-1:-1;;9792:2:1;9777:18;9770:34;9689:3;8931:879;-1:-1:-1;;8931:879:1:o
Swarm Source
ipfs://035e35d72db2747bcc1dde9aed871ebbd89c3fb60fffbb05ce180d374c35d1ad
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.