Overview
S Balance
0 SS Value
$0.00Token Holdings
More Info
Private Name Tags
ContractCreator
Loading...
Loading
Contract Name:
LPUnwrapper
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity)
/**
*Submitted for verification at SonicScan.org on 2025-03-04
*/
// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721Receiver.sol)
pragma solidity ^0.8.20;
/**
* @title ERC-721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC-721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be
* reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
// 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: LPUnwrapper.sol
pragma solidity ^0.8.20;
interface INonfungiblePositionManager {
struct CollectParams {
uint256 tokenId;
address recipient;
uint128 amount0Max;
uint128 amount1Max;
}
struct DecreaseLiquidityParams {
uint256 tokenId;
uint128 liquidity;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function positions(uint256 tokenId)
external
view
returns (
uint88 nonce,
address operator,
address token0,
address token1,
int24 tickLower,
int24 tickUpper,
uint128 liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1
);
function decreaseLiquidity(DecreaseLiquidityParams calldata params) external payable returns (uint256 amount0, uint256 amount1);
function collect(CollectParams calldata params) external payable returns (uint256 amount0, uint256 amount1);
}
/**
* @title LPUnwrapper
* @dev Contract to unwrap SwapX CL LP positions and return tokens to the owner
* while bypassing buy fees for tokens that implement them
*/
contract LPUnwrapper is IERC721Receiver {
using SafeERC20 for IERC20;
INonfungiblePositionManager public constant NONFUNGIBLE_POSITION_MANAGER = INonfungiblePositionManager(0xd82Fe82244ad01AaD671576202F9b46b76fAdFE2); // SwapX NonfungiblePositionManager
event PositionUnwrapped(address indexed owner, uint256 tokenId, uint256 amount0, uint256 amount1);
constructor() {}
/**
* @dev Required by IERC721Receiver to receive NFTs
*/
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external override pure returns (bytes4) {
return this.onERC721Received.selector;
}
/**
* @dev Process a position by removing all liquidity and collecting all fees
*/
function positionUnwrap(uint256 tokenId_) external {
// Get position details
(,,,,,, uint128 liquidity,,,,) = NONFUNGIBLE_POSITION_MANAGER.positions(tokenId_);
// Transfer position to this contract -> will fail if token not approved to be spent on this contract or msg.sender not the owner
NONFUNGIBLE_POSITION_MANAGER.safeTransferFrom(msg.sender, address(this), tokenId_);
// Decrease all liquidity - this will send the tokens to the position itself
if (liquidity > 0) {
INonfungiblePositionManager.DecreaseLiquidityParams memory params = INonfungiblePositionManager.DecreaseLiquidityParams({
tokenId: tokenId_,
liquidity: liquidity,
amount0Min: 0,
amount1Min: 0,
deadline: block.timestamp
});
NONFUNGIBLE_POSITION_MANAGER.decreaseLiquidity(params);
}
// Collect all tokens directly to the owner
INonfungiblePositionManager.CollectParams memory collectParams = INonfungiblePositionManager.CollectParams({
tokenId: tokenId_,
recipient: msg.sender, // Send directly to owner
amount0Max: type(uint128).max,
amount1Max: type(uint128).max
});
(uint256 amount0, uint256 amount1) = NONFUNGIBLE_POSITION_MANAGER.collect(collectParams);
emit PositionUnwrapped(msg.sender, tokenId_, amount0, amount1);
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"PositionUnwrapped","type":"event"},{"inputs":[],"name":"NONFUNGIBLE_POSITION_MANAGER","outputs":[{"internalType":"contract INonfungiblePositionManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"positionUnwrap","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
20678:2365:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21172:212;;;;;;:::i;:::-;21346:30;21172:212;;;;;;;;;;;1288:66:1;1276:79;;;1258:98;;1246:2;1231:18;21172:212:0;;;;;;;;20764:146;;20867:42;20764:146;;;;;1578:42:1;1566:55;;;1548:74;;1536:2;1521:18;20764:146:0;1367:261:1;21496:1542:0;;;;;;:::i;:::-;;:::i;:::-;;;21627:48;;;;;;;;1964:25:1;;;21601:17:0;;20867:42;;21627:38;;1937:18:1;;21627:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;21835:82:0;;;;;21881:10;21835:82;;;3973:34:1;21901:4:0;4023:18:1;;;4016:43;4075:18;;;4068:34;;;21593:82:0;;-1:-1:-1;20867:42:0;;-1:-1:-1;21835:45:0;;-1:-1:-1;;3885:18:1;;;;;-1:-1:-1;21835:82:0;;-1:-1:-1;;;;3710:398:1;21835:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;22028:13:0;;;;22024:448;;22126:251;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22126:251:0;;;;;;;;;;;;22346:15;22126:251;;;;;;22406:54;;;;;4358:13:1;;22406:54:0;;;4340:32:1;4414:24;;4410:65;;;4388:20;;;4381:95;4514:24;;4492:20;;;4485:54;4577:24;;4555:20;;;4548:54;4640:24;;4618:20;;;4611:54;22126:251:0;20867:42;;22406:46;;4312:19:1;;22406:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;22043:429;22024:448;22610:236;;;;;;;;;;;22710:10;22610:236;;;;;;22773:17;22610:236;;;;;;;;;;;;22904:51;;;;;5151:13:1;;22904:51:0;;;5133:32:1;5207:24;;5233:42;5203:73;5181:20;;;5174:103;5306:24;5421:21;;5399:20;;;5392:51;5485:24;;5481:33;;;5459:20;;;5452:63;22610:236:0;-1:-1:-1;;;;20867:42:0;;22904:36;;5105:19:1;;22904:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22973:57;;;5728:25:1;;;5784:2;5769:18;;5762:34;;;5812:18;;;5805:34;;;22867:88:0;;-1:-1:-1;22867:88:0;-1:-1:-1;22991:10:0;;22973:57;;5716:2:1;5701:18;22973:57:0;;;;;;;21547:1491;;;;21496:1542;:::o;14:154:1:-;100:42;93:5;89:54;82:5;79:65;69:93;;158:1;155;148:12;69:93;14:154;:::o;173:936::-;270:6;278;286;294;302;355:3;343:9;334:7;330:23;326:33;323:53;;;372:1;369;362:12;323:53;411:9;398:23;430:31;455:5;430:31;:::i;:::-;480:5;-1:-1:-1;537:2:1;522:18;;509:32;550:33;509:32;550:33;:::i;:::-;602:7;-1:-1:-1;656:2:1;641:18;;628:32;;-1:-1:-1;711:2:1;696:18;;683:32;734:18;764:14;;;761:34;;;791:1;788;781:12;761:34;829:6;818:9;814:22;804:32;;874:7;867:4;863:2;859:13;855:27;845:55;;896:1;893;886:12;845:55;936:2;923:16;962:2;954:6;951:14;948:34;;;978:1;975;968:12;948:34;1023:7;1018:2;1009:6;1005:2;1001:15;997:24;994:37;991:57;;;1044:1;1041;1034:12;991:57;173:936;;;;-1:-1:-1;173:936:1;;-1:-1:-1;1075:2:1;1067:11;;1097:6;173:936;-1:-1:-1;;;173:936:1:o;1633:180::-;1692:6;1745:2;1733:9;1724:7;1720:23;1716:32;1713:52;;;1761:1;1758;1751:12;1713:52;-1:-1:-1;1784:23:1;;1633:180;-1:-1:-1;1633:180:1:o;2000:138::-;2079:13;;2101:31;2079:13;2101:31;:::i;:::-;2000:138;;;:::o;2143:164::-;2220:13;;2273:1;2262:20;;;2252:31;;2242:59;;2297:1;2294;2287:12;2312:192;2391:13;;2444:34;2433:46;;2423:57;;2413:85;;2494:1;2491;2484:12;2509:1196;2664:6;2672;2680;2688;2696;2704;2712;2720;2728;2736;2744:7;2798:3;2786:9;2777:7;2773:23;2769:33;2766:53;;;2815:1;2812;2805:12;2766:53;2847:9;2841:16;2897:24;2890:5;2886:36;2879:5;2876:47;2866:75;;2937:1;2934;2927:12;2866:75;3010:2;2995:18;;2989:25;2960:5;;-1:-1:-1;3023:33:1;2989:25;3023:33;:::i;:::-;3127:2;3112:18;;3106:25;3075:7;;-1:-1:-1;3140:33:1;3106:25;3140:33;:::i;:::-;3192:7;-1:-1:-1;3218:49:1;3263:2;3248:18;;3218:49;:::i;:::-;3208:59;;3286:48;3329:3;3318:9;3314:19;3286:48;:::i;:::-;3276:58;;3353:48;3396:3;3385:9;3381:19;3353:48;:::i;:::-;3343:58;;3420:50;3465:3;3454:9;3450:19;3420:50;:::i;:::-;3410:60;;3510:3;3499:9;3495:19;3489:26;3479:36;;3555:3;3544:9;3540:19;3534:26;3524:36;;3579:50;3624:3;3613:9;3609:19;3579:50;:::i;:::-;3569:60;;3649:50;3694:3;3683:9;3679:19;3649:50;:::i;:::-;3638:61;;2509:1196;;;;;;;;;;;;;;:::o;4676:245::-;4755:6;4763;4816:2;4804:9;4795:7;4791:23;4787:32;4784:52;;;4832:1;4829;4822:12;4784:52;-1:-1:-1;;4855:16:1;;4911:2;4896:18;;;4890:25;4855:16;;4890:25;;-1:-1:-1;4676:245:1:o
Swarm Source
ipfs://79c792db13d9239a7ee76f29522d16347433b3ece926d7f315fd8d0420fcbfe6
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.