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 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 12442882 | 1048 days ago | IN | Create: XsgdToUsdAssimilator | 0 ETH | 0.08759934 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
XsgdToUsdAssimilator
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 "./SafeMath.sol"; import "./ABDKMath64x64.sol"; import "./IAssimilator.sol"; import "./IOracle.sol"; contract XsgdToUsdAssimilator is IAssimilator { using ABDKMath64x64 for int128; using ABDKMath64x64 for uint256; using SafeMath for uint256; IERC20 private constant usdc = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48); IOracle private constant oracle = IOracle(0xe25277fF4bbF9081C75Ab0EB13B4A13a721f3E13); IERC20 private constant xsgd = IERC20(0x70e8dE73cE538DA2bEEd35d14187F6959a8ecA96); // solhint-disable-next-line constructor() {} function getRate() public view override returns (uint256) { (, int256 price, , , ) = oracle.latestRoundData(); return uint256(price); } // takes raw xsgd amount, transfers it in, calculates corresponding numeraire amount and returns it function intakeRawAndGetBalance(uint256 _amount) external override returns (int128 amount_, int128 balance_) { bool _transferSuccess = xsgd.transferFrom(msg.sender, address(this), _amount); require(_transferSuccess, "Curve/XSGD-transfer-from-failed"); uint256 _balance = xsgd.balanceOf(address(this)); uint256 _rate = getRate(); balance_ = ((_balance * _rate) / 1e8).divu(1e6); amount_ = ((_amount * _rate) / 1e8).divu(1e6); } // takes raw xsgd amount, transfers it in, calculates corresponding numeraire amount and returns it function intakeRaw(uint256 _amount) external override returns (int128 amount_) { bool _transferSuccess = xsgd.transferFrom(msg.sender, address(this), _amount); require(_transferSuccess, "Curve/XSGD-transfer-from-failed"); uint256 _rate = getRate(); amount_ = ((_amount * _rate) / 1e8).divu(1e6); } // takes a numeraire amount, calculates the raw amount of xsgd, transfers it in and returns the corresponding raw amount function intakeNumeraire(int128 _amount) external override returns (uint256 amount_) { uint256 _rate = getRate(); amount_ = (_amount.mulu(1e6) * 1e8) / _rate; bool _transferSuccess = xsgd.transferFrom(msg.sender, address(this), amount_); require(_transferSuccess, "Curve/XSGD-transfer-from-failed"); } // takes a numeraire amount, calculates the raw amount of xsgd, transfers it in and returns the corresponding raw amount function intakeNumeraireLPRatio( uint256 _baseWeight, uint256 _quoteWeight, address _addr, int128 _amount ) external override returns (uint256 amount_) { uint256 _xsgdBal = xsgd.balanceOf(_addr); if (_xsgdBal <= 0) return 0; // 1e6 _xsgdBal = _xsgdBal.mul(1e18).div(_baseWeight); // 1e6 uint256 _usdcBal = usdc.balanceOf(_addr).mul(1e18).div(_quoteWeight); // Rate is in 1e6 uint256 _rate = _usdcBal.mul(1e6).div(_xsgdBal); amount_ = (_amount.mulu(1e6) * 1e6) / _rate; bool _transferSuccess = xsgd.transferFrom(msg.sender, address(this), amount_); require(_transferSuccess, "Curve/XSGD-transfer-failed"); } // takes a raw amount of xsgd and transfers it out, returns numeraire value of the raw amount function outputRawAndGetBalance(address _dst, uint256 _amount) external override returns (int128 amount_, int128 balance_) { uint256 _rate = getRate(); uint256 _xsgdAmount = ((_amount) * _rate) / 1e8; bool _transferSuccess = xsgd.transfer(_dst, _xsgdAmount); require(_transferSuccess, "Curve/XSGD-transfer-failed"); uint256 _balance = xsgd.balanceOf(address(this)); amount_ = _xsgdAmount.divu(1e6); balance_ = ((_balance * _rate) / 1e8).divu(1e6); } // takes a raw amount of xsgd and transfers it out, returns numeraire value of the raw amount function outputRaw(address _dst, uint256 _amount) external override returns (int128 amount_) { uint256 _rate = getRate(); uint256 _xsgdAmount = (_amount * _rate) / 1e8; bool _transferSuccess = xsgd.transfer(_dst, _xsgdAmount); require(_transferSuccess, "Curve/XSGD-transfer-failed"); amount_ = _xsgdAmount.divu(1e6); } // takes a numeraire value of xsgd, figures out the raw amount, transfers raw amount out, and returns raw amount function outputNumeraire(address _dst, int128 _amount) external override returns (uint256 amount_) { uint256 _rate = getRate(); amount_ = (_amount.mulu(1e6) * 1e8) / _rate; bool _transferSuccess = xsgd.transfer(_dst, amount_); require(_transferSuccess, "Curve/XSGD-transfer-failed"); } // takes a numeraire amount and returns the raw amount function viewRawAmount(int128 _amount) external view override returns (uint256 amount_) { uint256 _rate = getRate(); amount_ = (_amount.mulu(1e6) * 1e8) / _rate; } function viewRawAmountLPRatio( uint256 _baseWeight, uint256 _quoteWeight, address _addr, int128 _amount ) external view override returns (uint256 amount_) { uint256 _xsgdBal = xsgd.balanceOf(_addr); if (_xsgdBal <= 0) return 0; // 1e6 _xsgdBal = _xsgdBal.mul(1e18).div(_baseWeight); // 1e6 uint256 _usdcBal = usdc.balanceOf(_addr).mul(1e18).div(_quoteWeight); // Rate is in 1e6 uint256 _rate = _usdcBal.mul(1e6).div(_xsgdBal); amount_ = (_amount.mulu(1e6) * 1e6) / _rate; } // takes a raw amount and returns the numeraire amount function viewNumeraireAmount(uint256 _amount) external view override returns (int128 amount_) { uint256 _rate = getRate(); amount_ = ((_amount * _rate) / 1e8).divu(1e6); } // views the numeraire value of the current balance of the reserve, in this case xsgd function viewNumeraireBalance(address _addr) external view override returns (int128 balance_) { uint256 _rate = getRate(); uint256 _balance = xsgd.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, in this case xsgd 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 = xsgd.balanceOf(_addr); balance_ = ((_balance * _rate) / 1e8).divu(1e6); } // views the numeraire value of the current balance of the reserve, in this case xsgd // instead of calculating with chainlink's "rate" it'll be determined by the existing // token ratio // Mainly to protect LP from losing function viewNumeraireBalanceLPRatio( uint256 _baseWeight, uint256 _quoteWeight, address _addr ) external view override returns (int128 balance_) { uint256 _xsgdBal = xsgd.balanceOf(_addr); if (_xsgdBal <= 0) return ABDKMath64x64.fromUInt(0); uint256 _usdcBal = usdc.balanceOf(_addr).mul(1e18).div(_quoteWeight); // Rate is in 1e6 uint256 _rate = _usdcBal.mul(1e18).div(_xsgdBal.mul(1e18).div(_baseWeight)); balance_ = ((_xsgdBal * _rate) / 1e6).divu(1e18); } }
// 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); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } }
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":"_baseWeight","type":"uint256"},{"internalType":"uint256","name":"_quoteWeight","type":"uint256"},{"internalType":"address","name":"_addr","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":"_baseWeight","type":"uint256"},{"internalType":"uint256","name":"_quoteWeight","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":"_baseWeight","type":"uint256"},{"internalType":"uint256","name":"_quoteWeight","type":"uint256"},{"internalType":"address","name":"_addr","type":"address"},{"internalType":"int128","name":"_amount","type":"int128"}],"name":"viewRawAmountLPRatio","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
834:7352:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5671:590;;;;;;;;;;;;;;;;-1:-1:-1;5671:590:5;;;;;;;;-1:-1:-1;;;;;5671:590:5;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2640:340;;;;;;;;;;;;;;;;-1:-1:-1;2640:340:5;;;;:::i;7641:543::-;;;;;;;;;;;;;;;;-1:-1:-1;7641:543:5;;;;;;;;;;;-1:-1:-1;;;;;7641:543:5;;:::i;:::-;;;;;;;;;;;;;;;;;;;;7017:379;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;7017:379:5;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3956:543;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;3956:543:5;;;;;;;;:::i;1315:155::-;;;:::i;5481:184::-;;;;;;;;;;;;;;;;-1:-1:-1;5481:184:5;;;;:::i;5092:324::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;5092:324:5;;;;;;;;;;:::i;1580:483::-;;;;;;;;;;;;;;;;-1:-1:-1;1580:483:5;;:::i;6614:307::-;;;;;;;;;;;;;;;;-1:-1:-1;6614:307:5;-1:-1:-1;;;;;6614:307:5;;:::i;3111:741::-;;;;;;;;;;;;;;;;-1:-1:-1;3111:741:5;;;;;;;;-1:-1:-1;;;;;3111:741:5;;;;;;;;;;;;:::i;4603:366::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;4603:366:5;;;;;;;;:::i;6326:192::-;;;;;;;;;;;;;;;;-1:-1:-1;6326:192:5;;:::i;2173:336::-;;;;;;;;;;;;;;;;-1:-1:-1;2173:336:5;;:::i;5671:590::-;5845:15;5872:16;-1:-1:-1;;;;;;;;;;;;;;;;5891:14:5;;5906:5;5891:21;;;;;;;;;;;;;-1:-1:-1;;;;;5891:21:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5891:21:5;;-1:-1:-1;5927:13:5;5923:27;;5949:1;5942:8;;;;;5923:27;5987:35;6010:11;5987:18;:8;6000:4;5987:12;:18::i;:::-;:22;;:35::i;:::-;5976:46;;6048:16;6067:49;6103:12;6067:31;6093:4;1031:42;-1:-1:-1;;;;;6067:14:5;;6082:5;6067:21;;;;;;;;;;;;;-1:-1:-1;;;;;6067:21:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6067:21:5;;:25;:31::i;:49::-;6048:68;-1:-1:-1;6153:13:5;6169:31;6191:8;6169:17;6048:68;6182:3;6169:12;:17::i;:31::-;6153:47;-1:-1:-1;6153:47:5;6222:17;:12;;;;6235:3;6222:12;:17::i;:::-;6242:3;6222:23;6221:33;;;;;;6211:43;;5671:590;;;;;;;;;;:::o;2640:340::-;2708:15;2735:13;2751:9;:7;:9::i;:::-;2735:25;-1:-1:-1;2735:25:5;2782:17;:12;;;;2795:3;2782:12;:17::i;:::-;2802:3;2782:23;2781:33;;;;;2849:53;;;-1:-1:-1;;;2849:53:5;;2867:10;2849:53;;;;2887:4;2849:53;;;;2781:33;;;;2849:53;;;;;;;;2781:33;;-1:-1:-1;2825:21:5;;-1:-1:-1;;;;;;;;;;;1210:42:5;2849:17;;:53;;;;;;;;;;;;;;;2825:21;1210:42;2849:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2849:53:5;;-1:-1:-1;2849:53:5;2913:60;;;;;-1:-1:-1;;;2913:60:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;2640:340;;;;;:::o;7641:543::-;7798:15;7825:16;-1:-1:-1;;;;;;;;;;;;;;;;7844:14:5;;7859:5;7844:21;;;;;;;;;;;;;-1:-1:-1;;;;;7844:21:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7844:21:5;;-1:-1:-1;7880:13:5;7876:51;;7902:25;7925:1;7902:22;:25::i;:::-;7895:32;;;;;7876:51;7938:16;7957:49;7993:12;7957:31;7983:4;1031:42;-1:-1:-1;;;;;7957:14:5;;7972:5;7957:21;;;;;;;;;;;;;-1:-1:-1;;;;;7957:21:5;;;;;;;;;;;;;;;;;;;;;;;;;;:49;7938:68;-1:-1:-1;8043:13:5;8059:59;8082:35;8105:11;8082:18;:8;8095:4;8082:12;:18::i;:35::-;8059:18;:8;8072:4;8059:12;:18::i;:59::-;8043:75;-1:-1:-1;8140:37:5;8172:4;8162:3;8142:16;;;8141:24;;;8140:31;:37::i;:::-;8129:48;;7641:543;;;;;;;;;:::o;7017:379::-;7152:14;7168:15;7199:13;7215:9;:7;:9::i;:::-;7199:25;-1:-1:-1;7245:35:5;7276:3;7266;7247:15;;;7246:23;;7245:35;7235:45;;7291:16;-1:-1:-1;;;;;;;;;;;;;;;;7310:14:5;;7325:5;7310:21;;;;;;;;;;;;;-1:-1:-1;;;;;7310:21:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7310:21:5;;-1:-1:-1;7353:36:5;7385:3;7375;7355:16;;;7354:24;;7353:36;7342:47;;7017:379;;;;;;;:::o;3956:543::-;4070:14;4086:15;4117:13;4133:9;:7;:9::i;:::-;4117:25;-1:-1:-1;4153:19:5;4197:3;4176:17;;;4175:25;4153:47;;4211:21;-1:-1:-1;;;;;;;;;;;;;;;;4235:13:5;;4249:4;4255:11;4235:32;;;;;;;;;;;;;-1:-1:-1;;;;;4235:32:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4235:32:5;;-1:-1:-1;4235:32:5;4278:55;;;;;-1:-1:-1;;;4278:55:5;;;;;;;;;;;;-1:-1:-1;;;4278:55:5;;;;;;;;;;;;;;;4363:29;;;-1:-1:-1;;;4363:29:5;;4386:4;4363:29;;;;;;4344:16;;-1:-1:-1;;;;;;;;;;;1210:42:5;4363:14;;:29;;;;;;;;;;;;;;;1210:42;4363:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4363:29:5;;-1:-1:-1;4413:21:5;:11;4430:3;4413:16;:21::i;:::-;4403:31;-1:-1:-1;4456:36:5;4488:3;4478;4458:16;;;4457:24;;4456:36;4445:47;;3956:543;;;;;;;;;:::o;1315:155::-;1364:7;1386:12;1123:42;-1:-1:-1;;;;;1408:22:5;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1408:24:5;;;;-1:-1:-1;;1315:155:5;:::o;5481:184::-;5552:15;5579:13;5595:9;:7;:9::i;:::-;5579:25;-1:-1:-1;5579:25:5;5626:17;:12;;;;5639:3;5626:12;:17::i;:::-;5646:3;5626:23;5625:33;;;;;;;5481:184;-1:-1:-1;;;5481:184:5:o;5092:324::-;5174:15;5201:13;5217:9;:7;:9::i;:::-;5201:25;-1:-1:-1;5201:25:5;5248:17;:12;;;;5261:3;5248:12;:17::i;:::-;5268:3;5248:23;5247:33;;;;;;5237:43;;5291:21;-1:-1:-1;;;;;;;;;;;;;;;;5315:13:5;;5329:4;5335:7;5315:28;;;;;;;;;;;;;-1:-1:-1;;;;;5315:28:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5315:28:5;;-1:-1:-1;5315:28:5;5354:55;;;;;-1:-1:-1;;;5354:55:5;;;;;;;;;;;;-1:-1:-1;;;5354:55:5;;;;;;;;;;;;;;;5092:324;;;;;;:::o;1580:483::-;1723:53;;;-1:-1:-1;;;1723:53:5;;1741:10;1723:53;;;;1761:4;1723:53;;;;;;;;;;;;1656:14;;;;;;-1:-1:-1;;;;;;;;;;;1210:42:5;1723:17;;:53;;;;;;;;;;;;;;;1656:14;1210:42;1723:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1723:53:5;;-1:-1:-1;1723:53:5;1787:60;;;;;-1:-1:-1;;;1787:60:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;1877:29;;;-1:-1:-1;;;1877:29:5;;1900:4;1877:29;;;;;;1858:16;;-1:-1:-1;;;;;;;;;;;1210:42:5;1877:14;;:29;;;;;;;;;;;;;;;1210:42;1877:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1877:29:5;;-1:-1:-1;1917:13:5;1933:9;:7;:9::i;:::-;1917:25;-1:-1:-1;1964:36:5;1996:3;1986;1966:16;;;1965:24;;1964:36;1953:47;-1:-1:-1;2021:35:5;2052:3;2042;2023:15;;;2022:23;;2021:35;2011:45;;1580:483;;;;;;:::o;6614:307::-;6691:15;6718:13;6734:9;:7;:9::i;:::-;6718:25;;6754:16;-1:-1:-1;;;;;;;;;;;;;;;;6773:14:5;;6788:5;6773:21;;;;;;;;;;;;;-1:-1:-1;;;;;6773:21:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6773:21:5;;-1:-1:-1;6809:13:5;6805:51;;6831:25;6854:1;6831:22;:25::i;:::-;6824:32;;;;;;6805:51;6878:36;6910:3;6900;6880:16;;;6879:24;;6878:36;6867:47;;6614:307;;;;;;:::o;3111:741::-;3282:15;3309:16;-1:-1:-1;;;;;;;;;;;;;;;;3328:14:5;;3343:5;3328:21;;;;;;;;;;;;;-1:-1:-1;;;;;3328:21:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3328:21:5;;-1:-1:-1;3364:13:5;3360:27;;3386:1;3379:8;;;;;3360:27;3424:35;3447:11;3424:18;:8;3437:4;3424:12;:18::i;:35::-;3413:46;;3485:16;3504:49;3540:12;3504:31;3530:4;1031:42;-1:-1:-1;;;;;3504:14:5;;3519:5;3504:21;;;;;;;;;;;;;-1:-1:-1;;;;;3504:21:5;;;;;;;;;;;;;;;;;;;;;;;;;;:49;3485:68;-1:-1:-1;3590:13:5;3606:31;3628:8;3606:17;3485:68;3619:3;3606:12;:17::i;:31::-;3590:47;-1:-1:-1;3590:47:5;3659:17;:12;;;;3672:3;3659:12;:17::i;:::-;3679:3;3659:23;3658:33;;;;;3726:53;;;-1:-1:-1;;;3726:53:5;;3744:10;3726:53;;;;3764:4;3726:53;;;;3658:33;;;;3726:53;;;;;;;;3658:33;;-1:-1:-1;3702:21:5;;-1:-1:-1;;;;;;;;;;;1210:42:5;3726:17;;:53;;;;;;;;;;;;;;;3702:21;1210:42;3726:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3726:53:5;;-1:-1:-1;3726:53:5;3790:55;;;;;-1:-1:-1;;;3790:55:5;;;;;;;;;;;;-1:-1:-1;;;3790:55:5;;;;;;;;;;;;;;;3111:741;;;;;;;;;;:::o;4603:366::-;4680:14;4706:13;4722:9;:7;:9::i;:::-;4706:25;-1:-1:-1;4742:19:5;4784:3;4765:15;;;4764:23;4742:45;;4798:21;-1:-1:-1;;;;;;;;;;;;;;;;4822:13:5;;4836:4;4842:11;4822:32;;;;;;;;;;;;;-1:-1:-1;;;;;4822:32:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4822:32:5;;-1:-1:-1;4822:32:5;4865:55;;;;;-1:-1:-1;;;4865:55:5;;;;;;;;;;;;-1:-1:-1;;;4865:55:5;;;;;;;;;;;;;;;4941:21;:11;4958:3;4941:16;:21::i;:::-;4931:31;4603:366;-1:-1:-1;;;;;;4603:366:5:o;6326:192::-;6404:14;6430:13;6446:9;:7;:9::i;:::-;6430:25;-1:-1:-1;6476:35:5;6507:3;6497;6478:15;;;6477:23;;2173:336;2286:53;;;-1:-1:-1;;;2286:53:5;;2304:10;2286:53;;;;2324:4;2286:53;;;;;;;;;;;;2236:14;;;;-1:-1:-1;;;;;;;;;;;1210:42:5;2286:17;;:53;;;;;;;;;;;;;;2236:14;1210:42;2286:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2286:53:5;;-1:-1:-1;2286:53:5;2350:60;;;;;-1:-1:-1;;;2350:60:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;2421:13;2437:9;:7;:9::i;:::-;2421:25;-1:-1:-1;2467:35:5;2498:3;2488;2469:15;;;2468:23;;2188:459:4;2246:7;2487:6;2483:45;;-1:-1:-1;2516:1:4;2509:8;;2483:45;2550:5;;;2554:1;2550;:5;:1;2573:5;;;;;:10;2565:56;;;;-1:-1:-1;;;2565:56:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2639:1;-1:-1:-1;2188:459:4;;;;;:::o;3109:130::-;3167:7;3193:39;3197:1;3200;3193:39;;;;;;;;;;;;;;;;;:3;:39::i;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;;5938:455;-1:-1:-1;;;5938:455:0:o;1908:134::-;1961:6;1989:18;1984:1;:23;;1975:33;;;;;;-1:-1:-1;2034:2:0;2029:7;;1908:134::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;;;;;3721:272:4;3807:7;3841:12;3834:5;3826:28;;;;-1:-1:-1;;;3826:28:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3864:9;3880:1;3876;:5;;;;;;;3721:272;-1:-1:-1;;;;;3721:272:4:o;20427:1218:0:-;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://779e45d78799a44baec2bc1eb3e2cccfe208256eed78811df1523a47c90886e0
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 24 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.