Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 12459112 | 1255 days ago | IN | 0 ETH | 0.15427091 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
UsdcToUsdAssimilator
Compiler Version
v0.7.3+commit.9bfce1f6
Contract Source Code (Solidity Multiple files format)
// SPDX-License-Identifier: MIT // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity ^0.7.3; import "./IERC20.sol"; import "./ABDKMath64x64.sol"; import "./IAssimilator.sol"; import "./IOracle.sol"; contract UsdcToUsdAssimilator is IAssimilator { using ABDKMath64x64 for int128; using ABDKMath64x64 for uint256; IOracle private constant oracle = IOracle(0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6); IERC20 private constant usdc = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48); // solhint-disable-next-line constructor() {} // solhint-disable-next-line function getRate() public view override returns (uint256) { return uint256(oracle.latestAnswer()); } function intakeRawAndGetBalance(uint256 _amount) external override returns (int128 amount_, int128 balance_) { bool _success = usdc.transferFrom(msg.sender, address(this), _amount); require(_success, "Curve/USDC-transfer-from-failed"); uint256 _balance = usdc.balanceOf(address(this)); uint256 _rate = getRate(); balance_ = ((_balance * _rate) / 1e8).divu(1e6); amount_ = ((_amount * _rate) / 1e8).divu(1e6); } function intakeRaw(uint256 _amount) external override returns (int128 amount_) { bool _success = usdc.transferFrom(msg.sender, address(this), _amount); require(_success, "Curve/USDC-transfer-from-failed"); uint256 _rate = getRate(); amount_ = ((_amount * _rate) / 1e8).divu(1e6); } function intakeNumeraire(int128 _amount) external override returns (uint256 amount_) { uint256 _rate = getRate(); amount_ = (_amount.mulu(1e6) * 1e8) / _rate; bool _success = usdc.transferFrom(msg.sender, address(this), amount_); require(_success, "Curve/USDC-transfer-from-failed"); } function intakeNumeraireLPRatio( uint256, uint256, address, int128 _amount ) external override returns (uint256 amount_) { amount_ = _amount.mulu(1e6); bool _success = usdc.transferFrom(msg.sender, address(this), amount_); require(_success, "Curve/USDC-transfer-from-failed"); } function outputRawAndGetBalance(address _dst, uint256 _amount) external override returns (int128 amount_, int128 balance_) { uint256 _rate = getRate(); uint256 _usdcAmount = ((_amount * _rate) / 1e8); bool _success = usdc.transfer(_dst, _usdcAmount); require(_success, "Curve/USDC-transfer-failed"); uint256 _balance = usdc.balanceOf(address(this)); amount_ = _usdcAmount.divu(1e6); balance_ = ((_balance * _rate) / 1e8).divu(1e6); } function outputRaw(address _dst, uint256 _amount) external override returns (int128 amount_) { uint256 _rate = getRate(); uint256 _usdcAmount = (_amount * _rate) / 1e8; bool _success = usdc.transfer(_dst, _usdcAmount); require(_success, "Curve/USDC-transfer-failed"); amount_ = _usdcAmount.divu(1e6); } function outputNumeraire(address _dst, int128 _amount) external override returns (uint256 amount_) { uint256 _rate = getRate(); amount_ = (_amount.mulu(1e6) * 1e8) / _rate; bool _success = usdc.transfer(_dst, amount_); require(_success, "Curve/USDC-transfer-failed"); } function viewRawAmount(int128 _amount) external view override returns (uint256 amount_) { uint256 _rate = getRate(); amount_ = (_amount.mulu(1e6) * 1e8) / _rate; } function viewRawAmountLPRatio( uint256, uint256, address, int128 _amount ) external pure override returns (uint256 amount_) { amount_ = _amount.mulu(1e6); } function viewNumeraireAmount(uint256 _amount) external view override returns (int128 amount_) { uint256 _rate = getRate(); amount_ = ((_amount * _rate) / 1e8).divu(1e6); } function viewNumeraireBalance(address _addr) public view override returns (int128 balance_) { uint256 _rate = getRate(); uint256 _balance = usdc.balanceOf(_addr); if (_balance <= 0) return ABDKMath64x64.fromUInt(0); balance_ = ((_balance * _rate) / 1e8).divu(1e6); } // views the numeraire value of the current balance of the reserve wrt to USD // since this is already the USD assimlator, the ratio is just 1 function viewNumeraireBalanceLPRatio( uint256, uint256, address _addr ) external view override returns (int128 balance_) { uint256 _balance = usdc.balanceOf(_addr); return _balance.divu(1e6); } function viewNumeraireAmountAndBalance(address _addr, uint256 _amount) external view override returns (int128 amount_, int128 balance_) { uint256 _rate = getRate(); amount_ = ((_amount * _rate) / 1e8).divu(1e6); uint256 _balance = usdc.balanceOf(_addr); balance_ = ((_balance * _rate) / 1e8).divu(1e6); } }
// SPDX-License-Identifier: BSD-4-Clause /* * ABDK Math 64.64 Smart Contract Library. Copyright © 2019 by ABDK Consulting. * Author: Mikhail Vladimirov <[email protected]> */ pragma solidity ^0.7.0; /** * Smart contract library of mathematical functions operating with signed * 64.64-bit fixed point numbers. Signed 64.64-bit fixed point number is * basically a simple fraction whose numerator is signed 128-bit integer and * denominator is 2^64. As long as denominator is always the same, there is no * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are * represented by int128 type holding only the numerator. */ library ABDKMath64x64 { /* * Minimum value signed 64.64-bit fixed point number may have. */ int128 private constant MIN_64x64 = -0x80000000000000000000000000000000; /* * Maximum value signed 64.64-bit fixed point number may have. */ int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; /** * Convert signed 256-bit integer number into signed 64.64-bit fixed point * number. Revert on overflow. * * @param x signed 256-bit integer number * @return signed 64.64-bit fixed point number */ function fromInt (int256 x) internal pure returns (int128) { require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF); return int128 (x << 64); } /** * Convert signed 64.64 fixed point number into signed 64-bit integer number * rounding down. * * @param x signed 64.64-bit fixed point number * @return signed 64-bit integer number */ function toInt (int128 x) internal pure returns (int64) { return int64 (x >> 64); } /** * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point * number. Revert on overflow. * * @param x unsigned 256-bit integer number * @return signed 64.64-bit fixed point number */ function fromUInt (uint256 x) internal pure returns (int128) { require (x <= 0x7FFFFFFFFFFFFFFF); return int128 (x << 64); } /** * Convert signed 64.64 fixed point number into unsigned 64-bit integer * number rounding down. Revert on underflow. * * @param x signed 64.64-bit fixed point number * @return unsigned 64-bit integer number */ function toUInt (int128 x) internal pure returns (uint64) { require (x >= 0); return uint64 (x >> 64); } /** * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point * number rounding down. Revert on overflow. * * @param x signed 128.128-bin fixed point number * @return signed 64.64-bit fixed point number */ function from128x128 (int256 x) internal pure returns (int128) { int256 result = x >> 64; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Convert signed 64.64 fixed point number into signed 128.128 fixed point * number. * * @param x signed 64.64-bit fixed point number * @return signed 128.128 fixed point number */ function to128x128 (int128 x) internal pure returns (int256) { return int256 (x) << 64; } /** * Calculate x + y. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function add (int128 x, int128 y) internal pure returns (int128) { int256 result = int256(x) + y; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate x - y. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function sub (int128 x, int128 y) internal pure returns (int128) { int256 result = int256(x) - y; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate x * y rounding down. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function mul (int128 x, int128 y) internal pure returns (int128) { int256 result = int256(x) * y >> 64; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point * number and y is signed 256-bit integer number. Revert on overflow. * * @param x signed 64.64 fixed point number * @param y signed 256-bit integer number * @return signed 256-bit integer number */ function muli (int128 x, int256 y) internal pure returns (int256) { if (x == MIN_64x64) { require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF && y <= 0x1000000000000000000000000000000000000000000000000); return -y << 63; } else { bool negativeResult = false; if (x < 0) { x = -x; negativeResult = true; } if (y < 0) { y = -y; // We rely on overflow behavior here negativeResult = !negativeResult; } uint256 absoluteResult = mulu (x, uint256 (y)); if (negativeResult) { require (absoluteResult <= 0x8000000000000000000000000000000000000000000000000000000000000000); return -int256 (absoluteResult); // We rely on overflow behavior here } else { require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); return int256 (absoluteResult); } } } /** * Calculate x * y rounding down, where x is signed 64.64 fixed point number * and y is unsigned 256-bit integer number. Revert on overflow. * * @param x signed 64.64 fixed point number * @param y unsigned 256-bit integer number * @return unsigned 256-bit integer number */ function mulu (int128 x, uint256 y) internal pure returns (uint256) { if (y == 0) return 0; require (x >= 0); uint256 lo = (uint256 (x) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64; uint256 hi = uint256 (x) * (y >> 128); require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); hi <<= 64; require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo); return hi + lo; } /** * Calculate x / y rounding towards zero. Revert on overflow or when y is * zero. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function div (int128 x, int128 y) internal pure returns (int128) { require (y != 0); int256 result = (int256 (x) << 64) / y; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate x / y rounding towards zero, where x and y are signed 256-bit * integer numbers. Revert on overflow or when y is zero. * * @param x signed 256-bit integer number * @param y signed 256-bit integer number * @return signed 64.64-bit fixed point number */ function divi (int256 x, int256 y) internal pure returns (int128) { require (y != 0); bool negativeResult = false; if (x < 0) { x = -x; // We rely on overflow behavior here negativeResult = true; } if (y < 0) { y = -y; // We rely on overflow behavior here negativeResult = !negativeResult; } uint128 absoluteResult = divuu (uint256 (x), uint256 (y)); if (negativeResult) { require (absoluteResult <= 0x80000000000000000000000000000000); return -int128 (absoluteResult); // We rely on overflow behavior here } else { require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); return int128 (absoluteResult); // We rely on overflow behavior here } } /** * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit * integer numbers. Revert on overflow or when y is zero. * * @param x unsigned 256-bit integer number * @param y unsigned 256-bit integer number * @return signed 64.64-bit fixed point number */ function divu (uint256 x, uint256 y) internal pure returns (int128) { require (y != 0); uint128 result = divuu (x, y); require (result <= uint128 (MAX_64x64)); return int128 (result); } /** * Calculate -x. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function neg (int128 x) internal pure returns (int128) { require (x != MIN_64x64); return -x; } /** * Calculate |x|. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function abs (int128 x) internal pure returns (int128) { require (x != MIN_64x64); return x < 0 ? -x : x; } /** * Calculate 1 / x rounding towards zero. Revert on overflow or when x is * zero. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function inv (int128 x) internal pure returns (int128) { require (x != 0); int256 result = int256 (0x100000000000000000000000000000000) / x; require (result >= MIN_64x64 && result <= MAX_64x64); return int128 (result); } /** * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function avg (int128 x, int128 y) internal pure returns (int128) { return int128 ((int256 (x) + int256 (y)) >> 1); } /** * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down. * Revert on overflow or in case x * y is negative. * * @param x signed 64.64-bit fixed point number * @param y signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function gavg (int128 x, int128 y) internal pure returns (int128) { int256 m = int256 (x) * int256 (y); require (m >= 0); require (m < 0x4000000000000000000000000000000000000000000000000000000000000000); return int128 (sqrtu (uint256 (m))); } /** * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number * and y is unsigned 256-bit integer number. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @param y uint256 value * @return signed 64.64-bit fixed point number */ function pow (int128 x, uint256 y) internal pure returns (int128) { uint256 absoluteResult; bool negativeResult = false; if (x >= 0) { absoluteResult = powu (uint256 (x) << 63, y); } else { // We rely on overflow behavior here absoluteResult = powu (uint256 (uint128 (-x)) << 63, y); negativeResult = y & 1 > 0; } absoluteResult >>= 63; if (negativeResult) { require (absoluteResult <= 0x80000000000000000000000000000000); return -int128 (absoluteResult); // We rely on overflow behavior here } else { require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); return int128 (absoluteResult); // We rely on overflow behavior here } } /** * Calculate sqrt (x) rounding down. Revert if x < 0. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function sqrt (int128 x) internal pure returns (int128) { require (x >= 0); return int128 (sqrtu (uint256 (x) << 64)); } /** * Calculate binary logarithm of x. Revert if x <= 0. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function log_2 (int128 x) internal pure returns (int128) { require (x > 0); int256 msb = 0; int256 xc = x; if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; } if (xc >= 0x100000000) { xc >>= 32; msb += 32; } if (xc >= 0x10000) { xc >>= 16; msb += 16; } if (xc >= 0x100) { xc >>= 8; msb += 8; } if (xc >= 0x10) { xc >>= 4; msb += 4; } if (xc >= 0x4) { xc >>= 2; msb += 2; } if (xc >= 0x2) msb += 1; // No need to shift xc anymore int256 result = msb - 64 << 64; uint256 ux = uint256 (x) << uint256 (127 - msb); for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) { ux *= ux; uint256 b = ux >> 255; ux >>= 127 + b; result += bit * int256 (b); } return int128 (result); } /** * Calculate natural logarithm of x. Revert if x <= 0. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function ln (int128 x) internal pure returns (int128) { require (x > 0); return int128 ( uint256 (log_2 (x)) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128); } /** * Calculate binary exponent of x. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function exp_2 (int128 x) internal pure returns (int128) { require (x < 0x400000000000000000); // Overflow if (x < -0x400000000000000000) return 0; // Underflow uint256 result = 0x80000000000000000000000000000000; if (x & 0x8000000000000000 > 0) result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128; if (x & 0x4000000000000000 > 0) result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128; if (x & 0x2000000000000000 > 0) result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128; if (x & 0x1000000000000000 > 0) result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128; if (x & 0x800000000000000 > 0) result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128; if (x & 0x400000000000000 > 0) result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128; if (x & 0x200000000000000 > 0) result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128; if (x & 0x100000000000000 > 0) result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128; if (x & 0x80000000000000 > 0) result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128; if (x & 0x40000000000000 > 0) result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128; if (x & 0x20000000000000 > 0) result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128; if (x & 0x10000000000000 > 0) result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128; if (x & 0x8000000000000 > 0) result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128; if (x & 0x4000000000000 > 0) result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128; if (x & 0x2000000000000 > 0) result = result * 0x1000162E525EE054754457D5995292026 >> 128; if (x & 0x1000000000000 > 0) result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128; if (x & 0x800000000000 > 0) result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128; if (x & 0x400000000000 > 0) result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128; if (x & 0x200000000000 > 0) result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128; if (x & 0x100000000000 > 0) result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128; if (x & 0x80000000000 > 0) result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128; if (x & 0x40000000000 > 0) result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128; if (x & 0x20000000000 > 0) result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128; if (x & 0x10000000000 > 0) result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128; if (x & 0x8000000000 > 0) result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128; if (x & 0x4000000000 > 0) result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128; if (x & 0x2000000000 > 0) result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128; if (x & 0x1000000000 > 0) result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128; if (x & 0x800000000 > 0) result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128; if (x & 0x400000000 > 0) result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128; if (x & 0x200000000 > 0) result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128; if (x & 0x100000000 > 0) result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128; if (x & 0x80000000 > 0) result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128; if (x & 0x40000000 > 0) result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128; if (x & 0x20000000 > 0) result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128; if (x & 0x10000000 > 0) result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128; if (x & 0x8000000 > 0) result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128; if (x & 0x4000000 > 0) result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128; if (x & 0x2000000 > 0) result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128; if (x & 0x1000000 > 0) result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128; if (x & 0x800000 > 0) result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128; if (x & 0x400000 > 0) result = result * 0x100000000002C5C85FDF477B662B26945 >> 128; if (x & 0x200000 > 0) result = result * 0x10000000000162E42FEFA3AE53369388C >> 128; if (x & 0x100000 > 0) result = result * 0x100000000000B17217F7D1D351A389D40 >> 128; if (x & 0x80000 > 0) result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128; if (x & 0x40000 > 0) result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128; if (x & 0x20000 > 0) result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128; if (x & 0x10000 > 0) result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128; if (x & 0x8000 > 0) result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128; if (x & 0x4000 > 0) result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128; if (x & 0x2000 > 0) result = result * 0x1000000000000162E42FEFA39F02B772C >> 128; if (x & 0x1000 > 0) result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128; if (x & 0x800 > 0) result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128; if (x & 0x400 > 0) result = result * 0x100000000000002C5C85FDF473DEA871F >> 128; if (x & 0x200 > 0) result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128; if (x & 0x100 > 0) result = result * 0x100000000000000B17217F7D1CF79E949 >> 128; if (x & 0x80 > 0) result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128; if (x & 0x40 > 0) result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128; if (x & 0x20 > 0) result = result * 0x100000000000000162E42FEFA39EF366F >> 128; if (x & 0x10 > 0) result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128; if (x & 0x8 > 0) result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128; if (x & 0x4 > 0) result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128; if (x & 0x2 > 0) result = result * 0x1000000000000000162E42FEFA39EF358 >> 128; if (x & 0x1 > 0) result = result * 0x10000000000000000B17217F7D1CF79AB >> 128; result >>= uint256 (63 - (x >> 64)); require (result <= uint256 (MAX_64x64)); return int128 (result); } /** * Calculate natural exponent of x. Revert on overflow. * * @param x signed 64.64-bit fixed point number * @return signed 64.64-bit fixed point number */ function exp (int128 x) internal pure returns (int128) { require (x < 0x400000000000000000); // Overflow if (x < -0x400000000000000000) return 0; // Underflow return exp_2 ( int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128)); } /** * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit * integer numbers. Revert on overflow or when y is zero. * * @param x unsigned 256-bit integer number * @param y unsigned 256-bit integer number * @return unsigned 64.64-bit fixed point number */ function divuu (uint256 x, uint256 y) private pure returns (uint128) { require (y != 0); uint256 result; if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) result = (x << 64) / y; else { uint256 msb = 192; uint256 xc = x >> 192; if (xc >= 0x100000000) { xc >>= 32; msb += 32; } if (xc >= 0x10000) { xc >>= 16; msb += 16; } if (xc >= 0x100) { xc >>= 8; msb += 8; } if (xc >= 0x10) { xc >>= 4; msb += 4; } if (xc >= 0x4) { xc >>= 2; msb += 2; } if (xc >= 0x2) msb += 1; // No need to shift xc anymore result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1); require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); uint256 hi = result * (y >> 128); uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); uint256 xh = x >> 192; uint256 xl = x << 64; if (xl < lo) xh -= 1; xl -= lo; // We rely on overflow behavior here lo = hi << 128; if (xl < lo) xh -= 1; xl -= lo; // We rely on overflow behavior here assert (xh == hi >> 128); result += xl / y; } require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); return uint128 (result); } /** * Calculate x^y assuming 0^0 is 1, where x is unsigned 129.127 fixed point * number and y is unsigned 256-bit integer number. Revert on overflow. * * @param x unsigned 129.127-bit fixed point number * @param y uint256 value * @return unsigned 129.127-bit fixed point number */ function powu (uint256 x, uint256 y) private pure returns (uint256) { if (y == 0) return 0x80000000000000000000000000000000; else if (x == 0) return 0; else { int256 msb = 0; uint256 xc = x; if (xc >= 0x100000000000000000000000000000000) { xc >>= 128; msb += 128; } if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; } if (xc >= 0x100000000) { xc >>= 32; msb += 32; } if (xc >= 0x10000) { xc >>= 16; msb += 16; } if (xc >= 0x100) { xc >>= 8; msb += 8; } if (xc >= 0x10) { xc >>= 4; msb += 4; } if (xc >= 0x4) { xc >>= 2; msb += 2; } if (xc >= 0x2) msb += 1; // No need to shift xc anymore int256 xe = msb - 127; if (xe > 0) x >>= uint256 (xe); else x <<= uint256 (-xe); uint256 result = 0x80000000000000000000000000000000; int256 re = 0; while (y > 0) { if (y & 1 > 0) { result = result * x; y -= 1; re += xe; if (result >= 0x8000000000000000000000000000000000000000000000000000000000000000) { result >>= 128; re += 1; } else result >>= 127; if (re < -127) return 0; // Underflow require (re < 128); // Overflow } else { x = x * x; y >>= 1; xe <<= 1; if (x >= 0x8000000000000000000000000000000000000000000000000000000000000000) { x >>= 128; xe += 1; } else x >>= 127; if (xe < -127) return 0; // Underflow require (xe < 128); // Overflow } } if (re > 0) result <<= uint256 (re); else if (re < 0) result >>= uint256 (-re); return result; } } /** * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer * number. * * @param x unsigned 256-bit integer number * @return unsigned 128-bit integer number */ function sqrtu (uint256 x) private pure returns (uint128) { if (x == 0) return 0; else { uint256 xx = x; uint256 r = 1; if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; } if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; } if (xx >= 0x100000000) { xx >>= 32; r <<= 16; } if (xx >= 0x10000) { xx >>= 16; r <<= 8; } if (xx >= 0x100) { xx >>= 8; r <<= 4; } if (xx >= 0x10) { xx >>= 4; r <<= 2; } if (xx >= 0x8) { r <<= 1; } r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; // Seven iterations should be enough uint256 r1 = x / r; return uint128 (r < r1 ? r : r1); } } }
// SPDX-License-Identifier: MIT // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity ^0.7.3; interface IAssimilator { function getRate() external view returns (uint256); function intakeRaw(uint256 amount) external returns (int128); function intakeRawAndGetBalance(uint256 amount) external returns (int128, int128); function intakeNumeraire(int128 amount) external returns (uint256); function intakeNumeraireLPRatio( uint256, uint256, address, int128 ) external returns (uint256); function outputRaw(address dst, uint256 amount) external returns (int128); function outputRawAndGetBalance(address dst, uint256 amount) external returns (int128, int128); function outputNumeraire(address dst, int128 amount) external returns (uint256); function viewRawAmount(int128) external view returns (uint256); function viewRawAmountLPRatio( uint256, uint256, address, int128 ) external view returns (uint256); function viewNumeraireAmount(uint256) external view returns (int128); function viewNumeraireBalanceLPRatio( uint256, uint256, address ) external view returns (int128); function viewNumeraireBalance(address) external view returns (int128); function viewNumeraireAmountAndBalance(address, uint256) external view returns (int128, int128); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) 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 `amount` 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 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @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); }
// SPDX-License-Identifier: MIT // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity ^0.7.3; interface IOracle { function acceptOwnership() external; function accessController() external view returns (address); function aggregator() external view returns (address); function confirmAggregator(address _aggregator) external; function decimals() external view returns (uint8); function description() external view returns (string memory); function getAnswer(uint256 _roundId) external view returns (int256); function getRoundData(uint80 _roundId) external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); function getTimestamp(uint256 _roundId) external view returns (uint256); function latestAnswer() external view returns (int256); function latestRound() external view returns (uint256); function latestRoundData() external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); function latestTimestamp() external view returns (uint256); function owner() external view returns (address); function phaseAggregators(uint16) external view returns (address); function phaseId() external view returns (uint16); function proposeAggregator(address _aggregator) external; function proposedAggregator() external view returns (address); function proposedGetRoundData(uint80 _roundId) external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); function proposedLatestRoundData() external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); function setController(address _accessController) external; function transferOwnership(address _to) external; function version() external view returns (uint256); }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"getRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int128","name":"_amount","type":"int128"}],"name":"intakeNumeraire","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"int128","name":"_amount","type":"int128"}],"name":"intakeNumeraireLPRatio","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"intakeRaw","outputs":[{"internalType":"int128","name":"amount_","type":"int128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"intakeRawAndGetBalance","outputs":[{"internalType":"int128","name":"amount_","type":"int128"},{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_dst","type":"address"},{"internalType":"int128","name":"_amount","type":"int128"}],"name":"outputNumeraire","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_dst","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"outputRaw","outputs":[{"internalType":"int128","name":"amount_","type":"int128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_dst","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"outputRawAndGetBalance","outputs":[{"internalType":"int128","name":"amount_","type":"int128"},{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"viewNumeraireAmount","outputs":[{"internalType":"int128","name":"amount_","type":"int128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"viewNumeraireAmountAndBalance","outputs":[{"internalType":"int128","name":"amount_","type":"int128"},{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"viewNumeraireBalance","outputs":[{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"_addr","type":"address"}],"name":"viewNumeraireBalanceLPRatio","outputs":[{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int128","name":"_amount","type":"int128"}],"name":"viewRawAmount","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"int128","name":"_amount","type":"int128"}],"name":"viewRawAmountLPRatio","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"pure","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
809:4882:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4192:204;;;;;;;;;;;;;;;;-1:-1:-1;4192:204:4;;;;;;;;-1:-1:-1;;;;;4192:204:4;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2119:324;;;;;;;;;;;;;;;;-1:-1:-1;2119:324:4;;;;:::i;5062:242::-;;;;;;;;;;;;;;;;-1:-1:-1;5062:242:4;;;;;;;;;;;-1:-1:-1;;;;;5062:242:4;;:::i;:::-;;;;;;;;;;;;;;;;;;;;5310:379;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;5310:379:4;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2799:527;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2799:527:4;;;;;;;;:::i;1202:112::-;;;:::i;4002:184::-;;;;;;;;;;;;;;;;-1:-1:-1;4002:184:4;;;;:::i;3688:308::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;3688:308:4;;;;;;;;;;:::i;1320:467::-;;;;;;;;;;;;;;;;-1:-1:-1;1320:467:4;;:::i;4600:305::-;;;;;;;;;;;;;;;;-1:-1:-1;4600:305:4;-1:-1:-1;;;;;4600:305:4;;:::i;2449:344::-;;;;;;;;;;;;;;;;-1:-1:-1;2449:344:4;;;;;;;;-1:-1:-1;;;;;2449:344:4;;;;;;;;;;;;:::i;3332:350::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;3332:350:4;;;;;;;;:::i;4402:192::-;;;;;;;;;;;;;;;;-1:-1:-1;4402:192:4;;:::i;1793:320::-;;;;;;;;;;;;;;;;-1:-1:-1;1793:320:4;;:::i;4192:204::-;4335:15;4372:17;:12;;;;4385:3;4372:12;:17::i;:::-;4362:27;4192:204;-1:-1:-1;;;;;4192:204:4:o;2119:324::-;2187:15;2214:13;2230:9;:7;:9::i;:::-;2214:25;-1:-1:-1;2214:25:4;2261:17;:12;;;;2274:3;2261:12;:17::i;:::-;2281:3;2261:23;2260:33;;;;;2320:53;;;-1:-1:-1;;;2320:53:4;;2338:10;2320:53;;;;2358:4;2320:53;;;;2260:33;;;;2320:53;;;;;;;;2260:33;;-1:-1:-1;2304:13:4;;1064:42;;2320:17;;:53;;;;;;;;;;;;;;;2304:13;1064:42;2320:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2320:53:4;;-1:-1:-1;2320:53:4;2384:52;;;;;-1:-1:-1;;;2384:52:4;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2384:52:4;;;;;;;;;;;;;;;2119:324;;;;;:::o;5062:242::-;5194:15;5221:16;1064:42;-1:-1:-1;;;;;5240:14:4;;5255:5;5240:21;;;;;;;;;;;;;-1:-1:-1;;;;;5240:21:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5240:21:4;;-1:-1:-1;5279:18:4;5240:21;5293:3;5279:13;:18::i;5310:379::-;5445:14;5461:15;5492:13;5508:9;:7;:9::i;:::-;5492:25;-1:-1:-1;5538:35:4;5569:3;5559;5540:15;;;5539:23;;;5538:30;:35::i;:::-;5528:45;;5584:16;1064:42;-1:-1:-1;;;;;5603:14:4;;5618:5;5603:21;;;;;;;;;;;;;-1:-1:-1;;;;;5603:21:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5603:21:4;;-1:-1:-1;5646:36:4;5678:3;5668;5648:16;;;5647:24;;5646:36;5635:47;;5310:379;;;;;;;:::o;2799:527::-;2913:14;2929:15;2960:13;2976:9;:7;:9::i;:::-;2960:25;-1:-1:-1;2996:19:4;3039:3;3020:15;;;3019:23;2996:47;;3054:13;1064:42;-1:-1:-1;;;;;3070:13:4;;3084:4;3090:11;3070:32;;;;;;;;;;;;;-1:-1:-1;;;;;3070:32:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3070:32:4;;-1:-1:-1;3070:32:4;3113:47;;;;;-1:-1:-1;;;3113:47:4;;;;;;;;;;;;-1:-1:-1;;;3113:47:4;;;;;;;;;;;;;;;3190:29;;;-1:-1:-1;;;3190:29:4;;3213:4;3190:29;;;;;;3171:16;;1064:42;;3190:14;;:29;;;;;;;;;;;;;;;1064:42;3190:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3190:29:4;;-1:-1:-1;3240:21:4;:11;3257:3;3240:16;:21::i;:::-;3230:31;-1:-1:-1;3283:36:4;3315:3;3305;3285:16;;;3284:24;;3283:36;3272:47;;2799:527;;;;;;;;;:::o;1202:112::-;1251:7;977:42;-1:-1:-1;;;;;1285:19:4;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1285:21:4;;-1:-1:-1;1202:112:4;:::o;4002:184::-;4073:15;4100:13;4116:9;:7;:9::i;:::-;4100:25;-1:-1:-1;4100:25:4;4147:17;:12;;;;4160:3;4147:12;:17::i;:::-;4167:3;4147:23;4146:33;;;;;;;4002:184;-1:-1:-1;;;4002:184:4:o;3688:308::-;3770:15;3797:13;3813:9;:7;:9::i;:::-;3797:25;-1:-1:-1;3797:25:4;3844:17;:12;;;;3857:3;3844:12;:17::i;:::-;3864:3;3844:23;3843:33;;;;;;3833:43;;3887:13;1064:42;-1:-1:-1;;;;;3903:13:4;;3917:4;3923:7;3903:28;;;;;;;;;;;;;-1:-1:-1;;;;;3903:28:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3903:28:4;;-1:-1:-1;3903:28:4;3942:47;;;;;-1:-1:-1;;;3942:47:4;;;;;;;;;;;;-1:-1:-1;;;3942:47:4;;;;;;;;;;;;;;;3688:308;;;;;;:::o;1320:467::-;1455:53;;;-1:-1:-1;;;1455:53:4;;1473:10;1455:53;;;;1493:4;1455:53;;;;;;;;;;;;1396:14;;;;;;1064:42;;1455:17;;:53;;;;;;;;;;;;;;;1396:14;1064:42;1455:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1455:53:4;;-1:-1:-1;1455:53:4;1519:52;;;;;-1:-1:-1;;;1519:52:4;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1519:52:4;;;;;;;;;;;;;;;1601:29;;;-1:-1:-1;;;1601:29:4;;1624:4;1601:29;;;;;;1582:16;;1064:42;;1601:14;;:29;;;;;;;;;;;;;;;1064:42;1601:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1601:29:4;;-1:-1:-1;1641:13:4;1657:9;:7;:9::i;:::-;1641:25;-1:-1:-1;1688:36:4;1720:3;1710;1690:16;;;1689:24;;1688:36;1677:47;-1:-1:-1;1745:35:4;1776:3;1766;1747:15;;;1746:23;;1745:35;1735:45;;1320:467;;;;;;:::o;4600:305::-;4675:15;4702:13;4718:9;:7;:9::i;:::-;4702:25;;4738:16;1064:42;-1:-1:-1;;;;;4757:14:4;;4772:5;4757:21;;;;;;;;;;;;;-1:-1:-1;;;;;4757:21:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4757:21:4;;-1:-1:-1;4793:13:4;4789:51;;4815:25;4838:1;4815:22;:25::i;:::-;4808:32;;;;;;4789:51;4862:36;4894:3;4884;4864:16;;;4863:24;;4862:36;4851:47;;4600:305;;;;;;:::o;2449:344::-;2589:15;2626:17;:12;;;;2639:3;2626:12;:17::i;:::-;2670:53;;;-1:-1:-1;;;2670:53:4;;2688:10;2670:53;;;;2708:4;2670:53;;;;;;;;;;;;2616:27;;-1:-1:-1;2654:13:4;;1064:42;;2670:17;;:53;;;;;;;;;;;;;;2654:13;1064:42;2670:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2670:53:4;;-1:-1:-1;2670:53:4;2734:52;;;;;-1:-1:-1;;;2734:52:4;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2734:52:4;;;;;;;;;;;;;;;2449:344;;;;;;;:::o;3332:350::-;3409:14;3435:13;3451:9;:7;:9::i;:::-;3435:25;-1:-1:-1;3471:19:4;3513:3;3494:15;;;3493:23;3471:45;;3527:13;1064:42;-1:-1:-1;;;;;3543:13:4;;3557:4;3563:11;3543:32;;;;;;;;;;;;;-1:-1:-1;;;;;3543:32:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3543:32:4;;-1:-1:-1;3543:32:4;3586:47;;;;;-1:-1:-1;;;3586:47:4;;;;;;;;;;;;-1:-1:-1;;;3586:47:4;;;;;;;;;;;;;;;3654:21;:11;3671:3;3654:16;:21::i;:::-;3644:31;3332:350;-1:-1:-1;;;;;;3332:350:4:o;4402:192::-;4480:14;4506:13;4522:9;:7;:9::i;:::-;4506:25;-1:-1:-1;4552:35:4;4583:3;4573;4554:15;;;4553:23;;4552:35;4542:45;4402:192;-1:-1:-1;;;4402:192:4:o;1793:320::-;1898:53;;;-1:-1:-1;;;1898:53:4;;1916:10;1898:53;;;;1936:4;1898:53;;;;;;;;;;;;1856:14;;;;1064:42;;1898:17;;:53;;;;;;;;;;;;;;1856:14;1064:42;1898:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1898:53:4;;-1:-1:-1;1898:53:4;1962:52;;;;;-1:-1:-1;;;1962:52:4;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1962:52:4;;;;;;;;;;;;;;;2025:13;2041:9;:7;:9::i;:::-;2025:25;-1:-1:-1;2071:35:4;2102:3;2092;2073:15;;;2072:23;;5938:455:0;5997:7;6016:6;6012:20;;-1:-1:-1;6031:1:0;6024:8;;6012:20;6053:1;6048;:6;;;;6039:16;;;;;;6076:11;;;;-1:-1:-1;;;;;6091:38:0;;6076:54;;6135:2;6075:62;;6176:3;6171:8;;;6156:24;-1:-1:-1;;;;;6196:56:0;;;6187:66;;;;;;6266:2;6259:9;6296:71;;6284:83;;;6275:93;;;;;;6381:7;;-1:-1:-1;5938:455:0;;;;;:::o;8214:203::-;8274:6;8297;8288:16;;;;;;8310:14;8327:12;8334:1;8337;8327:5;:12::i;:::-;8310:29;-1:-1:-1;958:34:0;-1:-1:-1;;;;;8354:29:0;;;;8345:39;;;;;1908:134;1961:6;1989:18;1984:1;:23;;1975:33;;;;;;-1:-1:-1;2034:2:0;2029:7;;1908:134::o;20427:1218::-;20487:7;20511:6;20502:16;;;;;;20525:14;-1:-1:-1;;;;;20550:1:0;:55;20546:1005;;20634:1;20628:2;20623:1;:7;;20622:13;;;;;;20613:22;;20546:1005;;;20668:3;20692:8;;;20718:11;20712:17;;20708:48;;20740:2;20744:9;;;;20733;20708:48;20773:7;20767:2;:13;20763:44;;20791:2;20795:9;;;;20784;20763:44;20824:5;20818:2;:11;20814:40;;20840:1;20843:8;;;;20833;20814:40;20871:4;20865:2;:10;20861:39;;20886:1;20889:8;;;;20879;20861:39;20917:3;20911:2;:9;20907:38;;20931:1;20934:8;;;;20924;20907:38;20962:3;20956:2;:9;20952:23;;20974:1;20967:8;;;;20952:23;21061:3;21055;:9;21050:1;21046;:5;:18;;21068:1;21045:24;21037:3;21031;:9;21026:1;:14;;21025:45;;;;;;21016:54;;-1:-1:-1;;;;;21087:6:0;:44;;21078:54;;;;;;21169:3;21164:8;;;21154:19;;-1:-1:-1;;;;;21204:38:0;;21194:49;;21270:3;21265:8;;;21299:2;21294:7;;;21314;;;21310:20;;;21329:1;21323:7;;;;21310:20;21402:3;21396:9;;;;21338:8;;21417:7;;;21413:20;;;21432:1;21426:7;;;;21413:20;21441:8;;;21515:3;21509:9;;;21503:15;;21495:24;;;;21543:1;21538:2;:6;;;;;;21528:16;;;;20546:1005;;;;;;;-1:-1:-1;;;;;21566:6:0;:44;;21557:54;;;;
Swarm Source
ipfs://fcd6b00b36523405ba8a47bd9351ba3ba40c8e095259f8bc5aa112aebac2758a
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ 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.