Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 8 internal transactions
Advanced mode:
Parent Transaction Hash | Block | From | To | Value | ||
---|---|---|---|---|---|---|
20015352 | 29 days ago | 0.60777488 ETH | ||||
19972407 | 35 days ago | 0.01885831 ETH | ||||
18601059 | 227 days ago | 0.57539649 ETH | ||||
17995335 | 312 days ago | 0.01352007 ETH | ||||
17431510 | 391 days ago | 0.00407697 ETH | ||||
17431505 | 391 days ago | 0.00407697 ETH | ||||
17431467 | 391 days ago | 23.784 ETH | ||||
17431467 | 391 days ago | 23.784 ETH |
Loading...
Loading
Contract Name:
FirnLunarDAOEscrow
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity Multiple files format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; import "./ERC20.sol"; contract FirnLunarDAOEscrow { address public constant LUNAR_DAO = 0x59F77dC848C2E45B5954975ee1969e7A22fA25F6; address public constant FIRN_MULTISIG = 0xa14664a2E58e804669E9fF1DFbC1bD981E13B0dC; ERC20 public immutable firnToken = ERC20(0xDDEA19FCE1E52497206bf1969D2d56FeD85aFF5c); uint256 public constant VESTING_DATE = 1717214400; // 01-06-2024, at 04:00:00 GMT. 1 year from vote date. uint256 public constant ETHER_AMOUNT = 23784 * 1e15; // $45,000 USD / $1,891.95 USD/ETH uint256 public constant FIRN_AMOUNT = 4710 * 1e18; // $67,500 USD / $14.33 USD/FIRN bool public dealStatus = false; // prices calculated at 29-05-2023, 11:57AM ET receive() external payable { // receive ether, i.e. as a payout from Firn fees. } function sweepFunds() external { // callable by anyone; sweeps balance to the LunarDAO (bool success, ) = payable(LUNAR_DAO).call{value: address(this).balance}(""); // will throw on failure require(success, "Transfer failed."); } function executeDeal() external payable { require(!dealStatus, "Deal already done."); // this can easily be avoided, just as an additional safety measure require(msg.value == ETHER_AMOUNT, "Wrong amount of ether supplied."); require(firnToken.balanceOf(address(this)) == FIRN_AMOUNT, "Token balance is wrong."); // can also be checked explicitly, just to be safe dealStatus = true; // prevents Firn from exiting on line 36 (bool success, ) = payable(FIRN_MULTISIG).call{value: msg.value}(""); // will throw on failure require(success, "Transfer failed."); } function earlyExit() external { // Firn calls this to reclaim token if there is no deal. require(!dealStatus, "Deal has been completed."); firnToken.transfer(FIRN_MULTISIG, firnToken.balanceOf(address(this))); } function vest() external { // LunarDAO calls this after a year to claim their token. require(block.timestamp >= VESTING_DATE, "Hasn't vested yet."); firnToken.transfer(LUNAR_DAO, firnToken.balanceOf(address(this))); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; // ---------------------------------------------------------------------------- // BokkyPooBah's Red-Black Tree Library v1.0-pre-release-a // // A Solidity Red-Black Tree binary search library to store and access a sorted // list of unsigned integer data. The Red-Black algorithm rebalances the binary // search tree, resulting in O(log n) insert, remove and search time (and ~gas) // // https://github.com/bokkypoobah/BokkyPooBahsRedBlackTreeLibrary // // // Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2020. The MIT Licence. // ---------------------------------------------------------------------------- abstract contract BalanceTree { struct Node { address parent; address left; address right; bool red; } address public root; address constant EMPTY = address(0); mapping(address => Node) public nodes; function exists(address key) internal view returns (bool) { return (key != EMPTY) && ((key == root) || (nodes[key].parent != EMPTY)); } function sortKey(address key) internal virtual view returns (uint256); function rotateLeft(address key) internal { address cursor = nodes[key].right; address keyParent = nodes[key].parent; address cursorLeft = nodes[cursor].left; nodes[key].right = cursorLeft; if (cursorLeft != EMPTY) { nodes[cursorLeft].parent = key; } nodes[cursor].parent = keyParent; if (keyParent == EMPTY) { root = cursor; } else if (key == nodes[keyParent].left) { nodes[keyParent].left = cursor; } else { nodes[keyParent].right = cursor; } nodes[cursor].left = key; nodes[key].parent = cursor; } function rotateRight(address key) internal { address cursor = nodes[key].left; address keyParent = nodes[key].parent; address cursorRight = nodes[cursor].right; nodes[key].left = cursorRight; if (cursorRight != EMPTY) { nodes[cursorRight].parent = key; } nodes[cursor].parent = keyParent; if (keyParent == EMPTY) { root = cursor; } else if (key == nodes[keyParent].right) { nodes[keyParent].right = cursor; } else { nodes[keyParent].left = cursor; } nodes[cursor].right = key; nodes[key].parent = cursor; } function insertFixup(address key) internal { address cursor; while (key != root && nodes[nodes[key].parent].red) { address keyParent = nodes[key].parent; if (keyParent == nodes[nodes[keyParent].parent].left) { cursor = nodes[nodes[keyParent].parent].right; if (nodes[cursor].red) { nodes[keyParent].red = false; nodes[cursor].red = false; nodes[nodes[keyParent].parent].red = true; key = nodes[keyParent].parent; } else { if (key == nodes[keyParent].right) { key = keyParent; rotateLeft(key); } keyParent = nodes[key].parent; nodes[keyParent].red = false; nodes[nodes[keyParent].parent].red = true; rotateRight(nodes[keyParent].parent); } } else { cursor = nodes[nodes[keyParent].parent].left; if (nodes[cursor].red) { nodes[keyParent].red = false; nodes[cursor].red = false; nodes[nodes[keyParent].parent].red = true; key = nodes[keyParent].parent; } else { if (key == nodes[keyParent].left) { key = keyParent; rotateRight(key); } keyParent = nodes[key].parent; nodes[keyParent].red = false; nodes[nodes[keyParent].parent].red = true; rotateLeft(nodes[keyParent].parent); } } } if (nodes[root].red) nodes[root].red = false; } function insert(address key) internal { address cursor = EMPTY; address probe = root; while (probe != EMPTY) { cursor = probe; if (sortKey(key) < sortKey(probe)) { probe = nodes[probe].left; } else { probe = nodes[probe].right; } } nodes[key] = Node({parent : cursor, left : EMPTY, right : EMPTY, red : true}); if (cursor == EMPTY) { root = key; } else if (sortKey(key) < sortKey(cursor)) { nodes[cursor].left = key; } else { nodes[cursor].right = key; } insertFixup(key); } function replaceParent(address a, address b) internal { address bParent = nodes[b].parent; nodes[a].parent = bParent; if (bParent == EMPTY) { root = a; } else { if (b == nodes[bParent].left) { nodes[bParent].left = a; } else { nodes[bParent].right = a; } } } function removeFixup(address key) internal { address cursor; while (key != root && !nodes[key].red) { address keyParent = nodes[key].parent; if (key == nodes[keyParent].left) { cursor = nodes[keyParent].right; if (nodes[cursor].red) { nodes[cursor].red = false; nodes[keyParent].red = true; rotateLeft(keyParent); cursor = nodes[keyParent].right; } if (!nodes[nodes[cursor].left].red && !nodes[nodes[cursor].right].red) { nodes[cursor].red = true; key = keyParent; } else { if (!nodes[nodes[cursor].right].red) { nodes[nodes[cursor].left].red = false; nodes[cursor].red = true; rotateRight(cursor); cursor = nodes[keyParent].right; } nodes[cursor].red = nodes[keyParent].red; nodes[keyParent].red = false; nodes[nodes[cursor].right].red = false; rotateLeft(keyParent); return; // key = root; } } else { cursor = nodes[keyParent].left; if (nodes[cursor].red) { nodes[cursor].red = false; nodes[keyParent].red = true; rotateRight(keyParent); cursor = nodes[keyParent].left; } if (!nodes[nodes[cursor].right].red && !nodes[nodes[cursor].left].red) { nodes[cursor].red = true; key = keyParent; } else { if (!nodes[nodes[cursor].left].red) { nodes[nodes[cursor].right].red = false; nodes[cursor].red = true; rotateLeft(cursor); cursor = nodes[keyParent].left; } nodes[cursor].red = nodes[keyParent].red; nodes[keyParent].red = false; nodes[nodes[cursor].left].red = false; rotateRight(keyParent); return; // key = root; } } } if (nodes[key].red) nodes[key].red = false; } function remove(address key) internal { address probe; address cursor; if (nodes[key].left == EMPTY || nodes[key].right == EMPTY) { cursor = key; } else { cursor = nodes[key].right; while (nodes[cursor].left != EMPTY) { cursor = nodes[cursor].left; } } if (nodes[cursor].left != EMPTY) { probe = nodes[cursor].left; } else { probe = nodes[cursor].right; } address yParent = nodes[cursor].parent; nodes[probe].parent = yParent; if (yParent != EMPTY) { if (cursor == nodes[yParent].left) { nodes[yParent].left = probe; } else { nodes[yParent].right = probe; } } else { root = probe; } bool doFixup = !nodes[cursor].red; if (cursor != key) { replaceParent(cursor, key); nodes[cursor].left = nodes[key].left; nodes[nodes[cursor].left].parent = cursor; nodes[cursor].right = nodes[key].right; nodes[nodes[cursor].right].parent = cursor; nodes[cursor].red = nodes[key].red; (cursor, key) = (key, cursor); } if (doFixup) { removeFixup(probe); } delete nodes[cursor]; } } // ---------------------------------------------------------------------------- // End - BokkyPooBah's Red-Black Tree Library // ----------------------------------------------------------------------------
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol) pragma solidity 0.8.17; import "./BalanceTree.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is BalanceTree { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; address _owner; mapping(address => bool) public admins; modifier onlyOwner() { require(msg.sender == _owner, "Caller is not the owner."); _; } modifier onlyAdmin() { require(admins[msg.sender], "Caller is not an admin."); _; } function sortKey(address key) internal view override returns (uint256) { return _balances[key]; } /** * @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 Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; _owner = msg.sender; } function administrate(address owner_) external onlyOwner { _owner = owner_; } function setAdmin(address account, bool value) external onlyOwner { admins[account] = value; } function mint(address account, uint256 amount) external onlyAdmin { _mint(account, amount); } function burn(address account, uint256 amount) external onlyAdmin { _burn(account, amount); } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public pure returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public returns (bool) { address owner = msg.sender; _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public returns (bool) { address owner = msg.sender; _approve(owner, spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public returns (bool) { address spender = msg.sender; _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { address owner = msg.sender; _approve(owner, spender, allowance(owner, spender) + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { address owner = msg.sender; uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; } _balances[to] += amount; if (exists(from)) remove(from); // could be false, if balance was originally 0 and you transfer 0 if (_balances[from] > 0) insert(from); // could be false, if from got emptied if (exists(to)) remove(to); // could be false, if to is new if (_balances[to] > 0) insert(to); // could be false, if 0 got transferred and was already 0. emit Transfer(from, to, amount); _afterTokenTransfer(from, to, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; if (exists(account)) remove(account); if (_balances[account] > 0) insert(account); emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; if (exists(account)) remove(account); // could be false, if was 0 before burn and you burn 0 if (_balances[account] > 0) insert(account); emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal {} } // ---------------------------------------------------------------------------- // End - BokkyPooBah's Red-Black Tree Library // ----------------------------------------------------------------------------
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"name":"ETHER_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FIRN_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FIRN_MULTISIG","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LUNAR_DAO","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VESTING_DATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dealStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"earlyExit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"executeDeal","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"firnToken","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sweepFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
81:2111:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;287:84;;;;;;;;;;;;;;;;;;204:42:3;192:55;;;174:74;;162:2;147:18;287:84:2;;;;;;;;115:78;;;;;;;;;;;;151:42;115:78;;489:51;;;;;;;;;;;;528:12;489:51;;;;;636:25:3;;;624:2;609:18;489:51:2;490:177:3;1953:237:2;;;;;;;;;;;;;:::i;:::-;;1100:610;;;:::i;199:82::-;;;;;;;;;;;;239:42;199:82;;378:49;;;;;;;;;;;;417:10;378:49;;1716:231;;;;;;;;;;;;;:::i;845:249::-;;;;;;;;;;;;;:::i;669:30::-;;;;;;;;;;-1:-1:-1;669:30:2;;;;;;;;;;;837:14:3;;830:22;812:41;;800:2;785:18;669:30:2;672:187:3;581:49:2;;;;;;;;;;;;619:11;581:49;;1953:237;417:10;2054:15;:31;;2046:62;;;;;;;1066:2:3;2046:62:2;;;1048:21:3;1105:2;1085:18;;;1078:30;1144:20;1124:18;;;1117:48;1182:18;;2046:62:2;;;;;;;;;2148:34;;;;;2176:4;2148:34;;;174:74:3;2118:9:2;:18;;;;;151:42;;2118:18;;2148:19;;147:18:3;;2148:34:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2118:65;;;;;;;;;;1604:42:3;1592:55;;;2118:65:2;;;1574:74:3;1664:18;;;1657:34;1547:18;;2118:65:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1953:237::o;1100:610::-;1159:10;;;;1158:11;1150:42;;;;;;;2186:2:3;1150:42:2;;;2168:21:3;2225:2;2205:18;;;2198:30;2264:20;2244:18;;;2237:48;2302:18;;1150:42:2;1984:342:3;1150:42:2;528:12;1278:9;:25;1270:69;;;;;;;2533:2:3;1270:69:2;;;2515:21:3;2572:2;2552:18;;;2545:30;2611:33;2591:18;;;2584:61;2662:18;;1270:69:2;2331:355:3;1270:69:2;1357:34;;;;;1385:4;1357:34;;;174:74:3;619:11:2;;1357:9;:19;;;;;147:18:3;;1357:34:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;1349:85;;;;;;;2893:2:3;1349:85:2;;;2875:21:3;2932:2;2912:18;;;2905:30;2971:25;2951:18;;;2944:53;3014:18;;1349:85:2;2691:347:3;1349:85:2;1495:10;:17;;;;1508:4;1495:17;;;1583:49;;239:42;;1618:9;;1583:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1564:68;;;1675:7;1667:36;;;;;;;3455:2:3;1667:36:2;;;3437:21:3;3494:2;3474:18;;;3467:30;3533:18;3513;;;3506:46;3569:18;;1667:36:2;3253:340:3;1716:231:2;1822:10;;;;1821:11;1813:48;;;;;;;3800:2:3;1813:48:2;;;3782:21:3;3839:2;3819:18;;;3812:30;3878:26;3858:18;;;3851:54;3922:18;;1813:48:2;3598:348:3;1813:48:2;1905:34;;;;;1933:4;1905:34;;;174:74:3;1871:9:2;:18;;;;;239:42;;1871:18;;1905:19;;147:18:3;;1905:34:2;14:240:3;845:249:2;941:12;151:42;959:23;;990:21;959:57;;;3043:205:3;1211:184;1281:6;1334:2;1322:9;1313:7;1309:23;1305:32;1302:52;;;1350:1;1347;1340:12;1302:52;-1:-1:-1;1373:16:3;;1211:184;-1:-1:-1;1211:184:3:o;1702:277::-;1769:6;1822:2;1810:9;1801:7;1797:23;1793:32;1790:52;;;1838:1;1835;1828:12;1790:52;1870:9;1864:16;1923:5;1916:13;1909:21;1902:5;1899:32;1889:60;;1945:1;1942;1935:12;1889:60;1968:5;1702:277;-1:-1:-1;;;1702:277:3:o
Swarm Source
ipfs://f5260f65754b365bfbd1a31c4fb6cb5d8b145b1c16bed2d32682e7d2385eb676
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
[ 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.