More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 84 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Set Data | 68093208 | 7 hrs ago | IN | 0 POL | 0.00495735 | ||||
Set Data | 68053101 | 31 hrs ago | IN | 0 POL | 0.00495795 | ||||
Set Data | 68012650 | 2 days ago | IN | 0 POL | 0.00495795 | ||||
Set Data | 67972426 | 3 days ago | IN | 0 POL | 0.00495795 | ||||
Set Data | 67932254 | 4 days ago | IN | 0 POL | 0.00495765 | ||||
Set Data | 67892277 | 5 days ago | IN | 0 POL | 0.00495795 | ||||
Set Data | 67853111 | 6 days ago | IN | 0 POL | 0.00535607 | ||||
Set Data | 67815041 | 7 days ago | IN | 0 POL | 0.00581759 | ||||
Set Data | 67777078 | 8 days ago | IN | 0 POL | 0.00529357 | ||||
Set Data | 67739881 | 9 days ago | IN | 0 POL | 0.00496069 | ||||
Set Data | 67702519 | 10 days ago | IN | 0 POL | 0.00505841 | ||||
Set Data | 67664179 | 11 days ago | IN | 0 POL | 0.01558475 | ||||
Set Data | 67625421 | 12 days ago | IN | 0 POL | 0.00515762 | ||||
Set Data | 67586280 | 13 days ago | IN | 0 POL | 0.00523261 | ||||
Set Data | 67546893 | 14 days ago | IN | 0 POL | 0.00612815 | ||||
Set Data | 67506820 | 15 days ago | IN | 0 POL | 0.00734118 | ||||
Set Data | 67467710 | 16 days ago | IN | 0 POL | 0.00720589 | ||||
Set Data | 67427257 | 17 days ago | IN | 0 POL | 0.00506346 | ||||
Set Data | 67387186 | 18 days ago | IN | 0 POL | 0.00507976 | ||||
Set Data | 67347416 | 19 days ago | IN | 0 POL | 0.00495795 | ||||
Set Data | 67307505 | 20 days ago | IN | 0 POL | 0.00518995 | ||||
Set Data | 67267110 | 21 days ago | IN | 0 POL | 0.00546385 | ||||
Set Data | 67226771 | 22 days ago | IN | 0 POL | 0.00587363 | ||||
Set Data | 67186496 | 23 days ago | IN | 0 POL | 0.0076143 | ||||
Set Data | 67146449 | 24 days ago | IN | 0 POL | 0.00588333 |
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
PriceFeed
Compiler Version
v0.8.26+commit.8a97fa7a
Contract Source Code (Solidity Multiple files format)
// SPDX-License-Identifier: MIT /** * * @title: Price Feed Contract * @date: 26-November-2024 * @version: 2.3 * @author: IPMB Dev Team */ import "./Ownable.sol"; import "./Strings.sol"; pragma solidity ^0.8.19; contract PriceFeed is Ownable { // struct struct Data { uint256 goldPro; uint256 gold; uint256 goldDaily; bytes32 epochAvgPriceHash; bytes32 epochGoldDataSetHash; bytes32 epochGoldProDataSetHash; uint256 epochTS; } // mappings declaration mapping (address => bool) public admin; mapping (uint256 => Data) public PriceFeedData; // variables declaration using Strings for uint256; uint256 public nextEpoch; uint256 public latestTS; uint256 public epochInterval; // modifiers modifier onlyAdmin() { require(admin[msg.sender] == true, "Not allowed"); _; } // events event EpochData(uint256 indexed epoch, uint256 indexed goldPro, uint256 indexed gold, uint256 golddaily, bytes32 avgpricehash, bytes32 datasetGoldProhash, bytes32 datasetGoldhash, uint256 ts); // constructor constructor(uint256 _goldPro, uint256 _gold, uint256 _goldDaily, bytes32 _epochGoldProDataSetHash, bytes32 _epochGoldDataSetHash, uint256 _epochInterval) { admin[msg.sender] = true; PriceFeedData[0].goldPro = _goldPro; PriceFeedData[0].gold = _gold; PriceFeedData[0].goldDaily = _goldDaily; PriceFeedData[0].epochAvgPriceHash = keccak256((abi.encodePacked(_goldPro.toString() , _gold.toString()))); PriceFeedData[0].epochGoldProDataSetHash = _epochGoldProDataSetHash; PriceFeedData[0].epochGoldDataSetHash = _epochGoldDataSetHash; PriceFeedData[0].epochTS = block.timestamp; latestTS = block.timestamp; epochInterval = _epochInterval; emit EpochData(0, PriceFeedData[0].goldPro, PriceFeedData[0].gold, PriceFeedData[0].goldDaily, PriceFeedData[0].epochAvgPriceHash, PriceFeedData[0].epochGoldProDataSetHash, PriceFeedData[0].epochGoldDataSetHash, PriceFeedData[0].epochTS); nextEpoch = nextEpoch + 1; } // set epoch data function setData(uint256 _goldPro, uint256 _gold, uint256 _goldDaily, bytes32 _epochGoldProDataSetHash, bytes32 _epochGoldDataSetHash) public onlyAdmin { require (block.timestamp >= latestTS + epochInterval, "1 epoch per interval"); uint256 curEpoch = nextEpoch; PriceFeedData[curEpoch].goldPro = _goldPro; PriceFeedData[curEpoch].gold = _gold; PriceFeedData[curEpoch].goldDaily = _goldDaily; PriceFeedData[curEpoch].epochAvgPriceHash = keccak256((abi.encodePacked(_goldPro.toString() , _gold.toString()))); PriceFeedData[curEpoch].epochGoldProDataSetHash = _epochGoldProDataSetHash; PriceFeedData[curEpoch].epochGoldDataSetHash = _epochGoldDataSetHash; PriceFeedData[curEpoch].epochTS = block.timestamp; latestTS = block.timestamp; emit EpochData(curEpoch, PriceFeedData[curEpoch].goldPro, PriceFeedData[curEpoch].gold, PriceFeedData[curEpoch].goldDaily, PriceFeedData[curEpoch].epochAvgPriceHash, PriceFeedData[curEpoch].epochGoldDataSetHash, PriceFeedData[curEpoch].epochGoldDataSetHash, PriceFeedData[curEpoch].epochTS); nextEpoch = nextEpoch + 1; } // retrieve data for latest epoch function getLatestPrices() public view returns (uint256, uint256, uint256, uint256, bytes32, uint256) { uint256 latest = nextEpoch - 1; return (latest, PriceFeedData[latest].goldPro, PriceFeedData[latest].gold, PriceFeedData[latest].goldDaily, PriceFeedData[latest].epochAvgPriceHash, PriceFeedData[latest].epochTS); } // retrieve data for specific epoch function getEpochPrices(uint256 _epoch) public view returns (uint256, uint256, uint256, bytes32, uint256) { return (PriceFeedData[_epoch].goldPro, PriceFeedData[_epoch].gold, PriceFeedData[_epoch].goldDaily, PriceFeedData[_epoch].epochAvgPriceHash, PriceFeedData[_epoch].epochTS); } // retrieve dataset hashes for specific epoch function getEpochDataSetHash(uint256 _epoch) public view returns (bytes32, bytes32) { return (PriceFeedData[_epoch].epochGoldProDataSetHash, PriceFeedData[_epoch].epochGoldDataSetHash); } // update admin status function updateAdminStatus(address _address, bool _st) public onlyOwner() { admin[_address] = _st; } // update epoch interval function updateEpochInterval(uint256 _epochInterval) public onlyOwner() { epochInterval = _epochInterval; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.5; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } } }
// SPDX-License-Identifier: MIT // File: @openzeppelin/contracts/access/Ownable.sol pragma solidity ^0.8.5; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ import "./Context.sol"; abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ import "./Math.sol"; import "./SignedMath.sol"; library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint256","name":"_goldPro","type":"uint256"},{"internalType":"uint256","name":"_gold","type":"uint256"},{"internalType":"uint256","name":"_goldDaily","type":"uint256"},{"internalType":"bytes32","name":"_epochGoldProDataSetHash","type":"bytes32"},{"internalType":"bytes32","name":"_epochGoldDataSetHash","type":"bytes32"},{"internalType":"uint256","name":"_epochInterval","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"epoch","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"goldPro","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"gold","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"golddaily","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"avgpricehash","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"datasetGoldProhash","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"datasetGoldhash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"ts","type":"uint256"}],"name":"EpochData","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"PriceFeedData","outputs":[{"internalType":"uint256","name":"goldPro","type":"uint256"},{"internalType":"uint256","name":"gold","type":"uint256"},{"internalType":"uint256","name":"goldDaily","type":"uint256"},{"internalType":"bytes32","name":"epochAvgPriceHash","type":"bytes32"},{"internalType":"bytes32","name":"epochGoldDataSetHash","type":"bytes32"},{"internalType":"bytes32","name":"epochGoldProDataSetHash","type":"bytes32"},{"internalType":"uint256","name":"epochTS","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"admin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epochInterval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_epoch","type":"uint256"}],"name":"getEpochDataSetHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_epoch","type":"uint256"}],"name":"getEpochPrices","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLatestPrices","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestTS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextEpoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_goldPro","type":"uint256"},{"internalType":"uint256","name":"_gold","type":"uint256"},{"internalType":"uint256","name":"_goldDaily","type":"uint256"},{"internalType":"bytes32","name":"_epochGoldProDataSetHash","type":"bytes32"},{"internalType":"bytes32","name":"_epochGoldDataSetHash","type":"bytes32"}],"name":"setData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"_st","type":"bool"}],"name":"updateAdminStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_epochInterval","type":"uint256"}],"name":"updateEpochInterval","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
608060405234801561000f575f80fd5b50604051610ed6380380610ed683398101604081905261002e916103aa565b5f80546001600160a01b031916339081178255604051909182917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a350335f9081526001602081815260408320805460ff1916909217909155908052600290525f80516020610e968339815191528690555f80516020610e768339815191528590555f80516020610eb68339815191528490556100cd86610239565b6100d686610239565b6040516020016100e7929190610407565b60408051601f1981840301815282825280516020918201205f808052600283527fac33ff75c19e70fe83507db0d683fd3465c996598dc972688b7ace676c89077e8290557fac33ff75c19e70fe83507db0d683fd3465c996598dc972688b7ace676c8907808890557fac33ff75c19e70fe83507db0d683fd3465c996598dc972688b7ace676c89077f879055427fac33ff75c19e70fe83507db0d683fd3465c996598dc972688b7ace676c890781819055600481905560058790555f80516020610e76833981519152545f80516020610e96833981519152545f80516020610eb683398151915254885294870193909352858501899052606086018890526080860152925190939192917fe77cc95247228238d216c3e65256e03ff0af5103cd5b2de892f711b70c95b94f919081900360a00190a460035461022a906001610423565b60035550610456945050505050565b60605f610245836102c8565b60010190505f816001600160401b0381111561026357610263610442565b6040519080825280601f01601f19166020018201604052801561028d576020820181803683370190505b5090508181016020015b5f19016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a850494508461029757509392505050565b5f807a184f03e93ff9f4daa797ed6e38ed64bf6a1f0100000000000000008310610310577a184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000830492506040015b6d04ee2d6d415b85acef8100000000831061033c576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc10000831061035a57662386f26fc10000830492506010015b6305f5e1008310610372576305f5e100830492506008015b612710831061038657612710830492506004015b60648310610398576064830492506002015b600a83106103a4576001015b92915050565b5f805f805f8060c087890312156103bf575f80fd5b50508451602086015160408701516060880151608089015160a090990151939a929950909790965094509092509050565b5f81518060208401855e5f93019283525090919050565b5f61041b61041583866103f0565b846103f0565b949350505050565b808201808211156103a457634e487b7160e01b5f52601160045260245ffd5b634e487b7160e01b5f52604160045260245ffd5b610a13806104635f395ff3fe608060405234801561000f575f80fd5b50600436106100c7575f3560e01c80638b25effb116100795780638b25effb146101915780638da5cb5b1461021057806397f75f9f14610230578063aea0e78b14610294578063cceb0ab31461029d578063f2fde38b146102b0578063ff61ba5c146102c3575f80fd5b806309b1ef26146100cb5780631b8951bc146100e7578063561b7b0d146100f057806363a846f81461012f578063715018a61461016157806374a906951461016b578063839073481461017e575b5f80fd5b6100d460055481565b6040519081526020015b60405180910390f35b6100d460045481565b61011a6100fe366004610865565b5f90815260026020526040902060058101546004909101549091565b604080519283526020830191909152016100de565b61015161013d366004610897565b60016020525f908152604090205460ff1681565b60405190151581526020016100de565b6101696102f8565b005b6101696101793660046108b7565b610378565b61016961018c366004610865565b610524565b6101db61019f366004610865565b600260208190525f9182526040909120805460018201549282015460038301546004840154600585015460069095015493959492939192909187565b604080519788526020880196909652948601939093526060850191909152608084015260a083015260c082015260e0016100de565b610218610558565b6040516001600160a01b0390911681526020016100de565b61026c61023e366004610865565b5f90815260026020819052604090912080546001820154928201546003830154600690930154919490929190565b604080519586526020860194909452928401919091526060830152608082015260a0016100de565b6100d460035481565b6101696102ab3660046108ee565b610566565b6101696102be366004610897565b6105bf565b6102cb6106ac565b604080519687526020870195909552938501929092526060840152608083015260a082015260c0016100de565b33610301610558565b6001600160a01b0316146103305760405162461bcd60e51b815260040161032790610927565b60405180910390fd5b5f80546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a35f80546001600160a01b0319169055565b335f9081526001602081905260409091205460ff161515146103ca5760405162461bcd60e51b815260206004820152600b60248201526a139bdd08185b1b1bddd95960aa1b6044820152606401610327565b6005546004546103da9190610970565b4210156104205760405162461bcd60e51b81526020600482015260146024820152730c48195c1bd8da081c195c881a5b9d195c9d985b60621b6044820152606401610327565b6003545f818152600260208190526040909120878155600181018790550184905561044a866106fd565b610453866106fd565b60405160200161046492919061099a565b60408051808303601f1901815282825280516020918201205f858152600280845290849020600381019283556005810189905560048082018981554260068401819055918290556001830154835493909401549454905494885294870194909452938501829052606085019190915260808401919091529183907fe77cc95247228238d216c3e65256e03ff0af5103cd5b2de892f711b70c95b94f9060a00160405180910390a4600354610519906001610970565b600355505050505050565b3361052d610558565b6001600160a01b0316146105535760405162461bcd60e51b815260040161032790610927565b600555565b5f546001600160a01b031690565b3361056f610558565b6001600160a01b0316146105955760405162461bcd60e51b815260040161032790610927565b6001600160a01b03919091165f908152600160205260409020805460ff1916911515919091179055565b336105c8610558565b6001600160a01b0316146105ee5760405162461bcd60e51b815260040161032790610927565b6001600160a01b0381166106535760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610327565b5f80546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a35f80546001600160a01b0319166001600160a01b0392909216919091179055565b5f805f805f805f60016003546106c291906109b6565b5f81815260026020819052604090912080546001820154928201546003830154600690930154949c919b509299509197509550909350915050565b60605f6107098361078d565b60010190505f8167ffffffffffffffff811115610728576107286109c9565b6040519080825280601f01601f191660200182016040528015610752576020820181803683370190505b5090508181016020015b5f19016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a850494508461075c57509392505050565b5f8072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b83106107cb5772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef810000000083106107f7576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc10000831061081557662386f26fc10000830492506010015b6305f5e100831061082d576305f5e100830492506008015b612710831061084157612710830492506004015b60648310610853576064830492506002015b600a831061085f576001015b92915050565b5f60208284031215610875575f80fd5b5035919050565b80356001600160a01b0381168114610892575f80fd5b919050565b5f602082840312156108a7575f80fd5b6108b08261087c565b9392505050565b5f805f805f60a086880312156108cb575f80fd5b505083359560208501359550604085013594606081013594506080013592509050565b5f80604083850312156108ff575f80fd5b6109088361087c565b91506020830135801515811461091c575f80fd5b809150509250929050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b634e487b7160e01b5f52601160045260245ffd5b8082018082111561085f5761085f61095c565b5f81518060208401855e5f93019283525090919050565b5f6109ae6109a88386610983565b84610983565b949350505050565b8181038181111561085f5761085f61095c565b634e487b7160e01b5f52604160045260245ffdfea2646970667358221220ca045804896f2d040b7c869f483755801fd280aa9e386380be5a83cbbf49e4a464736f6c634300081a0033ac33ff75c19e70fe83507db0d683fd3465c996598dc972688b7ace676c89077cac33ff75c19e70fe83507db0d683fd3465c996598dc972688b7ace676c89077bac33ff75c19e70fe83507db0d683fd3465c996598dc972688b7ace676c89077d0000000000000000000000000000000000000000000000000000000000014c080000000000000000000000000000000000000000000000000000000000014c080000000000000000000000000000000000000000000000000000000000014c085d1b86932606365684fa992a8270ccfde072ec2b8a0d67e8dd9a11e2f1c873215d1b86932606365684fa992a8270ccfde072ec2b8a0d67e8dd9a11e2f1c873210000000000000000000000000000000000000000000000000000000000015180
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000000000000000000000000000000000000014c080000000000000000000000000000000000000000000000000000000000014c080000000000000000000000000000000000000000000000000000000000014c085d1b86932606365684fa992a8270ccfde072ec2b8a0d67e8dd9a11e2f1c873215d1b86932606365684fa992a8270ccfde072ec2b8a0d67e8dd9a11e2f1c873210000000000000000000000000000000000000000000000000000000000015180
-----Decoded View---------------
Arg [0] : _goldPro (uint256): 85000
Arg [1] : _gold (uint256): 85000
Arg [2] : _goldDaily (uint256): 85000
Arg [3] : _epochGoldProDataSetHash (bytes32): 0x5d1b86932606365684fa992a8270ccfde072ec2b8a0d67e8dd9a11e2f1c87321
Arg [4] : _epochGoldDataSetHash (bytes32): 0x5d1b86932606365684fa992a8270ccfde072ec2b8a0d67e8dd9a11e2f1c87321
Arg [5] : _epochInterval (uint256): 86400
-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000014c08
Arg [1] : 0000000000000000000000000000000000000000000000000000000000014c08
Arg [2] : 0000000000000000000000000000000000000000000000000000000000014c08
Arg [3] : 5d1b86932606365684fa992a8270ccfde072ec2b8a0d67e8dd9a11e2f1c87321
Arg [4] : 5d1b86932606365684fa992a8270ccfde072ec2b8a0d67e8dd9a11e2f1c87321
Arg [5] : 0000000000000000000000000000000000000000000000000000000000015180
Deployed Bytecode Sourcemap
240:4501:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;800:28;;;;;;;;;160:25:6;;;148:2;133:18;800:28:3;;;;;;;;770:23;;;;;;4222:201;;;;;;:::i;:::-;4288:7;4325:21;;;:13;:21;;;;;:45;;;;4372:42;;;;;4325:45;;4222:201;;;;;601:25:6;;;657:2;642:18;;635:34;;;;574:18;4222:201:3;427:248:6;575:38:3;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1214:14:6;;1207:22;1189:41;;1177:2;1162:18;575:38:3;1049:187:6;1816:148:2;;;:::i;:::-;;2257:1167:3;;;;;;:::i;:::-;;:::i;4615:121::-;;;;;;:::i;:::-;;:::i;620:46::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2269:25:6;;;2325:2;2310:18;;2303:34;;;;2353:18;;;2346:34;;;;2411:2;2396:18;;2389:34;;;;2454:3;2439:19;;2432:35;2498:3;2483:19;;2476:35;2542:3;2527:19;;2520:35;2256:3;2241:19;620:46:3;1954:607:6;1165:87:2;;;:::i;:::-;;;-1:-1:-1;;;;;2730:32:6;;;2712:51;;2700:2;2685:18;1165:87:2;2566:203:6;3865:296:3;;;;;;:::i;:::-;3926:7;3990:21;;;:13;:21;;;;;;;;:29;;4021:26;;;;4049:31;;;;4082:39;;;;4123:29;;;;;3990;;4049:31;;4082:39;4123:29;3865:296;;;;;3033:25:6;;;3089:2;3074:18;;3067:34;;;;3117:18;;;3110:34;;;;3175:2;3160:18;;3153:34;3218:3;3203:19;;3196:35;3020:3;3005:19;3865:296:3;2774:463:6;739:24:3;;;;;;4461:114;;;;;;:::i;:::-;;:::i;2119:244:2:-;;;;;;:::i;:::-;;:::i;3473:341:3:-;;;:::i;:::-;;;;3881:25:6;;;3937:2;3922:18;;3915:34;;;;3965:18;;;3958:34;;;;4023:2;4008:18;;4001:34;4066:3;4051:19;;4044:35;4110:3;4095:19;;4088:35;3868:3;3853:19;3473:341:3;3594:535:6;1816:148:2;685:10:0;1385:7:2;:5;:7::i;:::-;-1:-1:-1;;;;;1385:23:2;;1377:68;;;;-1:-1:-1;;;1377:68:2;;;;;;;:::i;:::-;;;;;;;;;1923:1:::1;1907:6:::0;;1886:40:::1;::::0;-1:-1:-1;;;;;1907:6:2;;::::1;::::0;1886:40:::1;::::0;1923:1;;1886:40:::1;1954:1;1937:19:::0;;-1:-1:-1;;;;;;1937:19:2::1;::::0;;1816:148::o;2257:1167:3:-;907:10;901:17;;;;:5;:17;;;;;;;;;;;:25;;;893:49;;;;-1:-1:-1;;;893:49:3;;4697:2:6;893:49:3;;;4679:21:6;4736:2;4716:18;;;4709:30;-1:-1:-1;;;4755:18:6;;;4748:41;4806:18;;893:49:3;4495:335:6;893:49:3;2459:13:::1;;2448:8;;:24;;;;:::i;:::-;2429:15;:43;;2420:77;;;::::0;-1:-1:-1;;;2420:77:3;;5299:2:6;2420:77:3::1;::::0;::::1;5281:21:6::0;5338:2;5318:18;;;5311:30;-1:-1:-1;;;5357:18:6;;;5350:50;5417:18;;2420:77:3::1;5097:344:6::0;2420:77:3::1;2528:9;::::0;2509:16:::1;2548:23:::0;;;:13:::1;:23;::::0;;;;;;;:42;;;2601:28:::1;::::0;::::1;:36:::0;;;2648:33:::1;:46:::0;;;2777:19:::1;2582:8:::0;2777:17:::1;:19::i;:::-;2799:16;:5;:14;:16::i;:::-;2760:56;;;;;;;;;:::i;:::-;;::::0;;;;::::1;-1:-1:-1::0;;2760:56:3;;;;;;2749:69;;2760:56:::1;2749:69:::0;;::::1;::::0;2705:23:::1;::::0;;;:13:::1;:23:::0;;;;;;;:41:::1;::::0;::::1;:113:::0;;;2829:47:::1;::::0;::::1;:74:::0;;;2914:44:::1;::::0;;::::1;:68:::0;;;3027:15:::1;2993:31;::::0;::::1;:49:::0;;;3053:26;;;;-1:-1:-1;;;3148:28:3;3115:31;;-1:-1:-1;;;;3178:33:3;3213:41;;3256:44;;3033:25:6;;;3074:18;;;3067:34;;;;3117:18;;;3110:34;;;3175:2;3160:18;;3153:34;;;;3218:3;3203:19;;3196:35;;;;3148:28:3;2705:23;;3095:285:::1;::::0;3020:3:6;3005:19;3095:285:3::1;;;;;;;3403:9;::::0;:13:::1;::::0;3415:1:::1;3403:13;:::i;:::-;3391:9;:25:::0;-1:-1:-1;;;;;;2257:1167:3:o;4615:121::-;685:10:0;1385:7:2;:5;:7::i;:::-;-1:-1:-1;;;;;1385:23:2;;1377:68;;;;-1:-1:-1;;;1377:68:2;;;;;;;:::i;:::-;4698:13:3::1;:30:::0;4615:121::o;1165:87:2:-;1211:7;1238:6;-1:-1:-1;;;;;1238:6:2;;1165:87::o;4461:114:3:-;685:10:0;1385:7:2;:5;:7::i;:::-;-1:-1:-1;;;;;1385:23:2;;1377:68;;;;-1:-1:-1;;;1377:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;4546:15:3;;;::::1;;::::0;;;:5:::1;:15;::::0;;;;:21;;-1:-1:-1;;4546:21:3::1;::::0;::::1;;::::0;;;::::1;::::0;;4461:114::o;2119:244:2:-;685:10:0;1385:7:2;:5;:7::i;:::-;-1:-1:-1;;;;;1385:23:2;;1377:68;;;;-1:-1:-1;;;1377:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;2208:22:2;::::1;2200:73;;;::::0;-1:-1:-1;;;2200:73:2;;6605:2:6;2200:73:2::1;::::0;::::1;6587:21:6::0;6644:2;6624:18;;;6617:30;6683:34;6663:18;;;6656:62;-1:-1:-1;;;6734:18:6;;;6727:36;6780:19;;2200:73:2::1;6403:402:6::0;2200:73:2::1;2310:6;::::0;;2289:38:::1;::::0;-1:-1:-1;;;;;2289:38:2;;::::1;::::0;2310:6;::::1;::::0;2289:38:::1;::::0;::::1;2338:6;:17:::0;;-1:-1:-1;;;;;;2338:17:2::1;-1:-1:-1::0;;;;;2338:17:2;;;::::1;::::0;;;::::1;::::0;;2119:244::o;3473:341:3:-;3521:7;3530;3539;3548;3557;3566;3586:14;3615:1;3603:9;;:13;;;;:::i;:::-;3643:21;;;;:13;:21;;;;;;;;:29;;3674:26;;;;3702:31;;;;3735:39;;;;3776:29;;;;;3643:21;;:29;;-1:-1:-1;3674:26:3;;-1:-1:-1;3702:31:3;;-1:-1:-1;3735:39:3;-1:-1:-1;3776:29:3;;-1:-1:-1;3473:341:3;-1:-1:-1;;3473:341:3:o;457:716:5:-;513:13;564:14;581:17;592:5;581:10;:17::i;:::-;601:1;581:21;564:38;;617:20;651:6;640:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;640:18:5;-1:-1:-1;617:41:5;-1:-1:-1;782:28:5;;;798:2;782:28;839:288;-1:-1:-1;;871:5:5;-1:-1:-1;;;1008:2:5;997:14;;992:30;871:5;979:44;1069:2;1060:11;;;-1:-1:-1;1090:21:5;839:288;1090:21;-1:-1:-1;1148:6:5;457:716;-1:-1:-1;;;457:716:5:o;10390:948:1:-;10443:7;;-1:-1:-1;;;10521:17:1;;10517:106;;-1:-1:-1;;;10559:17:1;;;-1:-1:-1;10605:2:1;10595:12;10517:106;10650:8;10641:5;:17;10637:106;;10688:8;10679:17;;;-1:-1:-1;10725:2:1;10715:12;10637:106;10770:8;10761:5;:17;10757:106;;10808:8;10799:17;;;-1:-1:-1;10845:2:1;10835:12;10757:106;10890:7;10881:5;:16;10877:103;;10927:7;10918:16;;;-1:-1:-1;10963:1:1;10953:11;10877:103;11007:7;10998:5;:16;10994:103;;11044:7;11035:16;;;-1:-1:-1;11080:1:1;11070:11;10994:103;11124:7;11115:5;:16;11111:103;;11161:7;11152:16;;;-1:-1:-1;11197:1:1;11187:11;11111:103;11241:7;11232:5;:16;11228:68;;11279:1;11269:11;11228:68;11324:6;10390:948;-1:-1:-1;;10390:948:1:o;196:226:6:-;255:6;308:2;296:9;287:7;283:23;279:32;276:52;;;324:1;321;314:12;276:52;-1:-1:-1;369:23:6;;196:226;-1:-1:-1;196:226:6:o;680:173::-;748:20;;-1:-1:-1;;;;;797:31:6;;787:42;;777:70;;843:1;840;833:12;777:70;680:173;;;:::o;858:186::-;917:6;970:2;958:9;949:7;945:23;941:32;938:52;;;986:1;983;976:12;938:52;1009:29;1028:9;1009:29;:::i;:::-;999:39;858:186;-1:-1:-1;;;858:186:6:o;1241:708::-;1336:6;1344;1352;1360;1368;1421:3;1409:9;1400:7;1396:23;1392:33;1389:53;;;1438:1;1435;1428:12;1389:53;-1:-1:-1;;1483:23:6;;;1603:2;1588:18;;1575:32;;-1:-1:-1;1706:2:6;1691:18;;1678:32;;1809:2;1794:18;;1781:32;;-1:-1:-1;1912:3:6;1897:19;1884:33;;-1:-1:-1;1241:708:6;-1:-1:-1;1241:708:6:o;3242:347::-;3307:6;3315;3368:2;3356:9;3347:7;3343:23;3339:32;3336:52;;;3384:1;3381;3374:12;3336:52;3407:29;3426:9;3407:29;:::i;:::-;3397:39;;3486:2;3475:9;3471:18;3458:32;3533:5;3526:13;3519:21;3512:5;3509:32;3499:60;;3555:1;3552;3545:12;3499:60;3578:5;3568:15;;;3242:347;;;;;:::o;4134:356::-;4336:2;4318:21;;;4355:18;;;4348:30;4414:34;4409:2;4394:18;;4387:62;4481:2;4466:18;;4134:356::o;4835:127::-;4896:10;4891:3;4887:20;4884:1;4877:31;4927:4;4924:1;4917:15;4951:4;4948:1;4941:15;4967:125;5032:9;;;5053:10;;;5050:36;;;5066:18;;:::i;5446:212::-;5488:3;5526:5;5520:12;5570:6;5563:4;5556:5;5552:16;5547:3;5541:36;5632:1;5596:16;;5621:13;;;-1:-1:-1;5596:16:6;;5446:212;-1:-1:-1;5446:212:6:o;5663:267::-;5842:3;5867:57;5893:30;5919:3;5911:6;5893:30;:::i;:::-;5885:6;5867:57;:::i;:::-;5860:64;5663:267;-1:-1:-1;;;;5663:267:6:o;6810:128::-;6877:9;;;6898:11;;;6895:37;;;6912:18;;:::i;6943:127::-;7004:10;6999:3;6995:20;6992:1;6985:31;7035:4;7032:1;7025:15;7059:4;7056:1;7049:15
Swarm Source
ipfs://ca045804896f2d040b7c869f483755801fd280aa9e386380be5a83cbbf49e4a4
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.