Overview
S Balance
0 SS Value
$0.00Token Holdings
- ERC-20 Tokens (1)View All Holdings9.60538928 wS
Wrapped Soni... (wS)$4.84@0.5036
More Info
Private Name Tags
ContractCreator
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
ShroomTreasury
Compiler Version
v0.8.26+commit.8a97fa7a
Contract Source Code (Solidity)
/**
*Submitted for verification at SonicScan.org on 2025-03-05
*/
// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
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);
}
// File: @openzeppelin/contracts/interfaces/IERC20.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)
pragma solidity ^0.8.20;
// File: @openzeppelin/contracts/utils/introspection/IERC165.sol
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @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);
}
// File: @openzeppelin/contracts/interfaces/IERC165.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
pragma solidity ^0.8.20;
// File: @openzeppelin/contracts/interfaces/IERC1363.sol
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)
pragma solidity ^0.8.20;
/**
* @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);
}
// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
/**
* @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);
}
}
// File: @openzeppelin/contracts/security/ReentrancyGuard.sol
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be _NOT_ENTERED
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
// File: ShroomTreasury-org.sol
pragma solidity ^0.8.26;
/// @notice A fully autonomous treasury that burns SHR tokens and refunds wrapped Sonic S ($wS) tokens proportionally, with no owner control to ensure fairness.
/// @dev The refund calculation distributes $S based on the ratio of the treasury's $wS balance to the circulating SHR supply.
/// Circulation is defined as the total SHR supply minus the SHR balance held by the tradingAddress (Shroom Trading account),
/// ensuring that only user-held SHR impacts the refund rate. SHR tokens are sent to deadAddress (burned) until its balance exceeds
/// BURN_LIMIT (90% of the original supply, i.e., 90 billion SHR tokens); afterward, they are transferred to tradingAddress.
/// No funds can be withdrawn, locking all excess $wS and SHR for refunds only.
contract ShroomTreasury is ReentrancyGuard {
using SafeERC20 for IERC20;
// Immutable token and address definitions
address public immutable shrToken = 0x5D0393b0655D483E63Fe1F5a85AE37d67dE6f356;
address public immutable wsToken = 0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38;
address public immutable tradingAddress = 0xDFd600C7683246E2866596958a751C90bf7bCCe6;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
// Constants
uint256 public constant ORIGINAL_SUPPLY = 100_000_000_000 * 10**18; // 100B tokens with 18 decimals
uint256 public constant BURN_LIMIT = ORIGINAL_SUPPLY * 90 / 100; // 90B tokens
// Events
event TokensTransferred(address indexed user, uint256 shrAmount, address destination);
event RefundIssued(address indexed user, uint256 sAmount);
/// @notice Constructor initializes the contract
constructor() {
// ReentrancyGuard constructor is automatically called
}
/// @notice Burns SHR tokens and refunds $wS based on the treasury ratio
/// @param amount The amount of SHR tokens to process
function burnShroomAndRefundS(uint256 amount) external nonReentrant {
require(amount > 0, "Amount must be greater than zero");
// Transfer SHR tokens from the user to the contract
IERC20(shrToken).safeTransferFrom(msg.sender, address(this), amount);
// Determine destination: burn to deadAddress until its balance exceeds BURN_LIMIT, then send to tradingAddress
address destination = (IERC20(shrToken).balanceOf(deadAddress) > BURN_LIMIT) ? tradingAddress : deadAddress;
IERC20(shrToken).safeTransfer(destination, amount);
emit TokensTransferred(msg.sender, amount, destination);
// Calculate circulating supply (total supply minus tradingAddress balance)
uint256 currentSupply = IERC20(shrToken).totalSupply();
uint256 circulation = currentSupply - IERC20(shrToken).balanceOf(tradingAddress);
require(circulation > 0, "Circulation is zero, cannot calculate refund");
// Calculate available $wS for refunds without reserving any amount
uint256 treasuryS = IERC20(wsToken).balanceOf(address(this));
// Calculate refund amount with proper precision (sToken per shrToken ratio)
uint256 refundAmount = (amount * treasuryS) / circulation;
// Ensure sufficient $wS balance and transfer refund
require(refundAmount <= treasuryS, "Insufficient $wS");
IERC20(wsToken).safeTransfer(msg.sender, refundAmount);
emit RefundIssued(msg.sender, refundAmount);
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"sAmount","type":"uint256"}],"name":"RefundIssued","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"shrAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"destination","type":"address"}],"name":"TokensTransferred","type":"event"},{"inputs":[],"name":"BURN_LIMIT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ORIGINAL_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnShroomAndRefundS","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deadAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"shrToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wsToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
22302:2686:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22803:66;;22845:24;22803:66;;;;;160:25:1;;;148:2;133:18;22803:66:0;;;;;;;;22604:84;;;;;;;;-1:-1:-1;;;;;360:32:1;;;342:51;;330:2;315:18;22604:84:0;196:203:1;22695:81:0;;;;;22908:63;;;:::i;23452:1533::-;;;;;;:::i;:::-;;:::i;:::-;;22435:78;;;;;22520:77;;;;;22908:63;22968:3;22945:20;22845:24;22963:2;22945:20;:::i;:::-;:26;;;;:::i;:::-;22908:63;:::o;23452:1533::-;20559:21;:19;:21::i;:::-;23548:1:::1;23539:6;:10;23531:55;;;::::0;-1:-1:-1;;;23531:55:0;;1318:2:1;23531:55:0::1;::::0;::::1;1300:21:1::0;;;1337:18;;;1330:30;1396:34;1376:18;;;1369:62;1448:18;;23531:55:0::1;;;;;;;;;23661:68;-1:-1:-1::0;;;;;23668:8:0::1;23661:33;23695:10;23715:4;23722:6:::0;23661:33:::1;:68::i;:::-;23863:19;22968:3;22945:20;22845:24;22963:2;22945:20;:::i;:::-;:26;;;;:::i;:::-;23886:39;::::0;-1:-1:-1;;;23886:39:0;;-1:-1:-1;;;;;23913:11:0::1;360:32:1::0;;23886:39:0::1;::::0;::::1;342:51:1::0;23893:8:0::1;23886:26;::::0;::::1;::::0;315:18:1;;23886:39:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;23885:85;;23959:11;23885:85;;;23942:14;23885:85;23863:107:::0;-1:-1:-1;23981:50:0::1;-1:-1:-1::0;;;;;23988:8:0::1;23981:29;23863:107:::0;24024:6;23981:29:::1;:50::i;:::-;24047;::::0;;1840:25:1;;;-1:-1:-1;;;;;1901:32:1;;1896:2;1881:18;;1874:60;24065:10:0::1;::::0;24047:50:::1;::::0;1813:18:1;24047:50:0::1;;;;;;;24195:21;24226:8;-1:-1:-1::0;;;;;24219:28:0::1;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24298:42;::::0;-1:-1:-1;;;24298:42:0;;-1:-1:-1;;;;;24325:14:0::1;360:32:1::0;;24298:42:0::1;::::0;::::1;342:51:1::0;24195:54:0;;-1:-1:-1;;;24305:8:0::1;24298:26;::::0;::::1;::::0;315:18:1;;24298:42:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24282:58;::::0;:13;:58:::1;:::i;:::-;24260:80;;24373:1;24359:11;:15;24351:72;;;::::0;-1:-1:-1;;;24351:72:0;;2280:2:1;24351:72:0::1;::::0;::::1;2262:21:1::0;2319:2;2299:18;;;2292:30;2358:34;2338:18;;;2331:62;-1:-1:-1;;;2409:18:1;;;2402:42;2461:19;;24351:72:0::1;2078:408:1::0;24351:72:0::1;24533:40;::::0;-1:-1:-1;;;24533:40:0;;24567:4:::1;24533:40;::::0;::::1;342:51:1::0;24513:17:0::1;::::0;24540:7:::1;-1:-1:-1::0;;;;;24533:25:0::1;::::0;::::1;::::0;315:18:1;;24533:40:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24513:60:::0;-1:-1:-1;24672:20:0::1;24718:11:::0;24696:18:::1;24513:60:::0;24696:6;:18:::1;:::i;:::-;24695:34;;;;:::i;:::-;24672:57;;24828:9;24812:12;:25;;24804:54;;;::::0;-1:-1:-1;;;24804:54:0;;2693:2:1;24804:54:0::1;::::0;::::1;2675:21:1::0;2732:2;2712:18;;;2705:30;-1:-1:-1;;;2751:18:1;;;2744:46;2807:18;;24804:54:0::1;2491:340:1::0;24804:54:0::1;24869;-1:-1:-1::0;;;;;24876:7:0::1;24869:28;24898:10;24910:12:::0;24869:28:::1;:54::i;:::-;24939:38;::::0;160:25:1;;;24952:10:0::1;::::0;24939:38:::1;::::0;148:2:1;133:18;24939:38:0::1;;;;;;;23520:1465;;;;;20603:20:::0;19997:1;21123:7;:22;20940:213;20603:20;23452:1533;:::o;20639:293::-;20041:1;20773:7;;:19;20765:63;;;;-1:-1:-1;;;20765:63:0;;3038:2:1;20765:63:0;;;3020:21:1;3077:2;3057:18;;;3050:30;3116:33;3096:18;;;3089:61;3167:18;;20765:63:0;2836:355:1;20765:63:0;20041:1;20906:7;:18;20639:293::o;10281:190::-;10409:53;;-1:-1:-1;;;;;3416:32:1;;;10409:53:0;;;3398:51:1;3485:32;;;3465:18;;;3458:60;3534:18;;;3527:34;;;10382:81:0;;10402:5;;10424:18;;;;;3371::1;;10409:53:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;10409:53:0;;;;;;;;;;;10382:19;:81::i;:::-;10281:190;;;;:::o;9874:162::-;9984:43;;-1:-1:-1;;;;;3764:32:1;;;9984:43:0;;;3746:51:1;3813:18;;;3806:34;;;9957:71:0;;9977:5;;9999:14;;;;;3719:18:1;;9984:43:0;3572:274:1;9957:71:0;9874:162;;;:::o;16467:738::-;16548:18;16577:19;16717:4;16714:1;16707:4;16701:11;16694:4;16688;16684:15;16681:1;16674:5;16667;16662:60;16776:7;16766:180;;16821:4;16815:11;16867:16;16864:1;16859:3;16844:40;16914:16;16909:3;16902:29;16766:180;-1:-1:-1;;17025:1:0;17019:8;16974:16;;-1:-1:-1;17054:15:0;;:68;;17106:11;17121:1;17106:16;;17054:68;;;-1:-1:-1;;;;;17072:26:0;;;:31;17054:68;17050:148;;;17146:40;;-1:-1:-1;;;17146:40:0;;-1:-1:-1;;;;;360:32:1;;17146:40:0;;;342:51:1;315:18;;17146:40:0;196:203:1;404:180;463:6;516:2;504:9;495:7;491:23;487:32;484:52;;;532:1;529;522:12;484:52;-1:-1:-1;555:23:1;;404:180;-1:-1:-1;404:180:1:o;589:127::-;650:10;645:3;641:20;638:1;631:31;681:4;678:1;671:15;705:4;702:1;695:15;721:168;794:9;;;825;;842:15;;;836:22;;822:37;812:71;;863:18;;:::i;:::-;721:168;;;;:::o;894:217::-;934:1;960;950:132;;1004:10;999:3;995:20;992:1;985:31;1039:4;1036:1;1029:15;1067:4;1064:1;1057:15;950:132;-1:-1:-1;1096:9:1;;894:217::o;1477:184::-;1547:6;1600:2;1588:9;1579:7;1575:23;1571:32;1568:52;;;1616:1;1613;1606:12;1568:52;-1:-1:-1;1639:16:1;;1477:184;-1:-1:-1;1477:184:1:o;1945:128::-;2012:9;;;2033:11;;;2030:37;;;2047:18;;:::i
Swarm Source
ipfs://cad957e4faf73cb2a8c2c543d0691053b91283a3f2d2572fa1433e507a313dd2
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 31 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.