MATIC Price: $0.579836 (+0.44%)
Gas: 33 GWei
 

Overview

MATIC Balance

Polygon PoS Chain LogoPolygon PoS Chain LogoPolygon PoS Chain Logo0 MATIC

MATIC Value

$0.00

Sponsored

Transaction Hash
Method
Block
From
To
Value
0x60a06040235115222022-01-09 8:49:47893 days ago1641718187IN
 Create: SigmaPoolInitializerV1
0 MATIC0.0613789735

Parent Transaction Hash Block From To Value
View All Internal Transactions
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
SigmaPoolInitializerV1

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, GNU GPLv3 license
File 1 of 12 : SigmaPoolInitializerV1.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

/* ========== External Interfaces ========== */
import "@indexed-finance/uniswap-v2-oracle/contracts/interfaces/IIndexedUniswapV2Oracle.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/* ========== External Libraries ========== */
import "@openzeppelin/contracts/math/SafeMath.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";

/* ========== Internal Interfaces ========== */
import "./interfaces/IPoolInitializer.sol";


/**
 * @title SigmaPoolInitializerV1
 * @author d1ll0n
 * @dev Contract that acquires the initial balances for an index pool.
 *
 * This uses a short-term UniSwap price oracle to determine the ether
 * value of tokens sent to the contract. When users contribute tokens,
 * they are credited for the moving average ether value of said tokens.
 * When all the tokens needed are acquired, the index pool will be
 * initialized and this contract will receive the initial token supply (100).
 *
 * Once the contract receives the index pool tokens, users can claim their
 * share of the tokens proportional to their credited contribution value.
 */
contract SigmaPoolInitializerV1 is IPoolInitializer {
  using SafeMath for uint256;
  using SafeERC20 for IERC20;

/* ==========  Constants  ========== */

  uint32 internal constant SHORT_TWAP_MIN_TIME_ELAPSED = 20 minutes;
  uint32 internal constant SHORT_TWAP_MAX_TIME_ELAPSED = 2 days;
  uint256 internal constant TOKENS_MINTED = 1e20;

  IIndexedUniswapV2Oracle public immutable oracle;

/* ==========  Events  ========== */

  event TokensContributed(
    address from,
    address token,
    uint256 amount,
    uint256 credit
  );

  event TokensClaimed(address account, uint256 tokens);

/* ==========  Storage  ========== */
  // Token amounts to purchase
  mapping(address => uint256) internal _remainingDesiredAmounts;
  // Value contributed in ether
  mapping(address => uint256) internal _credits;
  address[] internal _tokens;

  // Address of the pool controller
  address public controller;
  // Total value in ether contributed to the pool, computed at the time
  // of receipt.
  uint256 internal _totalCredit;
  // Whether all the desired tokens have been received.
  bool internal _finished;
  address internal _poolAddress;
  bool internal _mutex;

/* ==========  Modifiers  ========== */

  modifier _lock_ {
    require(!_mutex, "ERR_REENTRY");
    _mutex = true;
    _;
    _mutex = false;
  }

  modifier _finished_ {
    require(_finished, "ERR_NOT_FINISHED");
    _;
  }

  modifier _not_finished_ {
    require(!_finished, "ERR_FINISHED");
    _;
  }

/* ==========  Constructor  ========== */

  constructor(IIndexedUniswapV2Oracle oracle_) public {
    oracle = oracle_;
  }

/* ==========  Start & Finish Functions  ========== */

  /**
   * @dev Sets up the pre-deployment pool.
   *
   * @param controller_ Address of the pool controller
   * @param poolAddress Address of the pool this pre-deployment pool is for
   * @param tokens Array of desired tokens
   * @param amounts Desired amounts of the corresponding `tokens`
   */
  function initialize(
    address controller_,
    address poolAddress,
    address[] calldata tokens,
    uint256[] calldata amounts
  )
    external
    override
  {
    require(_poolAddress == address(0), "ERR_INITIALIZED");
    _poolAddress = poolAddress;
    controller = controller_;
    uint256 len = tokens.length;
    require(amounts.length == len, "ERR_ARR_LEN");
    _tokens = tokens;
    for (uint256 i = 0; i < len; i++) {
      _remainingDesiredAmounts[tokens[i]] = amounts[i];
    }
  }

  /**
   * @dev Finishes the pre-deployment pool and triggers pool initialization.
   *
   * Note: The desired amounts of all tokens must be 0.
  */
  function finish()
    external
    override
    _lock_
    _not_finished_
  {
    uint256 len = _tokens.length;
    address controller_ = controller;
    address[] memory tokens = new address[](len);
    uint256[] memory balances = new uint256[](len);
    for (uint256 i = 0; i < len; i++) {
      address token = _tokens[i];
      tokens[i] = token;
      uint256 balance = IERC20(token).balanceOf(address(this));
      balances[i] = balance;
      IERC20(token).safeApprove(_poolAddress, balance);
      require(
        _remainingDesiredAmounts[token] == 0,
        "ERR_PENDING_TOKENS"
      );
    }
    PoolController(controller_).finishPreparedIndexPool(
      _poolAddress,
      tokens,
      balances
    );
    _finished = true;
  }

/* ==========  Pool Token Claims  ========== */

  /**
   * @dev Claims the tokens owed to `msg.sender` based on their proportion
   * of the total credits.
  */
  function claimTokens() external override _lock_ _finished_ {
    _claimTokens(msg.sender);
  }

  /**
   * @dev Claims the tokens owed to `account` based on their proportion
   * of the total credits.
  */
  function claimTokens(address account) external override _lock_ _finished_ {
    _claimTokens(account);
  }

  /**
   * @dev Claims the tokens owed to `account` based on their proportion
   * of the total credits.
  */
  function claimTokens(address[] calldata accounts) external override _lock_ _finished_ {
    for (uint256 i = 0; i < accounts.length; i++) {
      _claimTokens(accounts[i]);
    }
  }

/* ==========  Contribution  ========== */

  /**
   * @dev Contribute up to `amountIn` of `token` to the pool for credit.
   * The caller will be credited for the average weth value of the provided
   * tokens.
   *
   * Caller must receive at least `minimumCredit` to not revert.
   *
   * If `amountIn` is greater than the desired amount of `token`, the
   * desired amount will be used instead.
   */
  function contributeTokens(
    address token,
    uint256 amountIn,
    uint256 minimumCredit
  )
    external
    override
    _lock_
    _not_finished_
    returns (uint256 credit)
  {
    uint256 desiredAmount = _remainingDesiredAmounts[token];
    require(desiredAmount > 0, "ERR_NOT_NEEDED");
    if (amountIn > desiredAmount) {
      amountIn = desiredAmount;
    }
    credit = oracle.computeAverageEthForTokens(
      token,
      amountIn,
      SHORT_TWAP_MIN_TIME_ELAPSED,
      SHORT_TWAP_MAX_TIME_ELAPSED
    );
    require(credit > 0 && amountIn > 0, "ERR_ZERO_AMOUNT");
    require(credit >= minimumCredit, "ERR_MIN_CREDIT");
    IERC20(token).safeTransferFrom(msg.sender, address(this), amountIn);
    _remainingDesiredAmounts[token] = desiredAmount.sub(amountIn);
    _credits[msg.sender] = _credits[msg.sender].add(credit);
    _totalCredit = _totalCredit.add(credit);
    emit TokensContributed(msg.sender, token, amountIn, credit);
  }

  /**
   * @dev Contribute maximum values from `amountsIn` of the corresponding
   * tokens in `tokens` to the pool for credit.
   *
   * The caller will be credited for the average weth value of the provided
   * tokens.
   *
   * Caller must receive at least `minimumCredit` to not revert.
   *
   * If any input amount is greater than the desired amount of the corresponding
   * token, the desired amount will be used instead.
   */
  function contributeTokens(
    address[] calldata tokens,
    uint256[] calldata amountsIn,
    uint256 minimumCredit
  )
    external
    override
    _lock_
    _not_finished_
    returns (uint256 credit)
  {
    uint256 len = tokens.length;
    require(amountsIn.length == len, "ERR_ARR_LEN");
    credit = 0;
    for (uint256 i = 0; i < len; i++) {
      address token = tokens[i];
      uint256 amountIn = amountsIn[i];
      uint256 desiredAmount = _remainingDesiredAmounts[token];
      require(desiredAmount > 0, "ERR_NOT_NEEDED");
      if (amountIn > desiredAmount) {
        amountIn = desiredAmount;
      }
      uint256 creditOut = oracle.computeAverageEthForTokens(
        token,
        amountIn,
        SHORT_TWAP_MIN_TIME_ELAPSED,
        SHORT_TWAP_MAX_TIME_ELAPSED
      );
      require(creditOut > 0 && amountIn > 0, "ERR_ZERO_AMOUNT");
      IERC20(token).safeTransferFrom(msg.sender, address(this), amountIn);
      _remainingDesiredAmounts[token] = desiredAmount.sub(amountIn);
      credit = credit.add(creditOut);
      emit TokensContributed(msg.sender, token, amountIn, creditOut);
    }
    require(credit >= minimumCredit, "ERR_MIN_CREDIT");
    _credits[msg.sender] = _credits[msg.sender].add(credit);
    _totalCredit = _totalCredit.add(credit);
  }

/* ==========  Price Actions  ========== */

  /**
   * @dev Updates the prices of all tokens.
   */
  function updatePrices() external override {
    oracle.updatePrices(_tokens);
  }

/* ==========  Status Queries  ========== */

  /**
   * @dev Returns whether the pool has been initialized.
   */
  function isFinished() external view override returns (bool) {
    return _finished;
  }

/* ==========  Status Queries  ========== */

  /**
   * @dev Returns the total value credited for token contributions.
   */
  function getTotalCredit() external view override returns (uint256) {
    return _totalCredit;
  }

  /**
   * @dev Returns the amount of credit owed to `account`.
   */
  function getCreditOf(address account)
    external
    view
    override
    returns (uint256)
  {
    return _credits[account];
  }

/* ==========  Token Queries  ========== */

  function getDesiredTokens()
    external
    view
    override
    returns (address[] memory tokens)
  {
    tokens = _tokens;
  }

  function getDesiredAmount(address token)
    external
    view
    override
    returns (uint256)
  {
    return _remainingDesiredAmounts[token];
  }

  function getDesiredAmounts(address[] calldata tokens)
    external
    view
    override
    returns (uint256[] memory amounts)
  {
    amounts = new uint256[](tokens.length);
    for (uint256 i = 0; i < tokens.length; i++) {
      amounts[i] = _remainingDesiredAmounts[tokens[i]];
    }
  }

/* ==========  External Price Queries ========== */
  /**
   * @dev Get the amount of WETH the contract will credit a user
   * for providing `amountIn` of `token`.
   *
   * Note: If `amountIn` is greater than the desired amount of
   * `token`, this will calculate the output using the desired
   * amount instead of `amountIn`.
   */
  function getCreditForTokens(address token, uint256 amountIn)
    external
    view
    override
    returns (uint144 amountOut)
  {
    uint256 desiredAmount = _remainingDesiredAmounts[token];
    require(desiredAmount > 0, "ERR_NOT_NEEDED");
    if (amountIn > desiredAmount) {
      amountIn = desiredAmount;
    }
    uint144 averageWethValue = oracle.computeAverageEthForTokens(
      token,
      amountIn,
      SHORT_TWAP_MIN_TIME_ELAPSED,
      SHORT_TWAP_MAX_TIME_ELAPSED
    );
    amountOut = averageWethValue;
  }

/* ==========  Internal Claims Functions  ========== */

  /**
   * @dev Claims pool tokens owed to `account` based on their
   * proportion of the total credit.
   * Note: Must be called in a function with the `_finished` modifier.
   * Note: Must be called in a function with the `_lock_` modifier.
   */
  function _claimTokens(address account) internal {
    uint256 credit = _credits[account];
    require(credit > 0, "ERR_NULL_CREDIT");
    uint256 amountOut = (TOKENS_MINTED.mul(credit)).div(_totalCredit);
    _credits[account] = 0;
    IERC20(_poolAddress).safeTransfer(account, amountOut);
    emit TokensClaimed(account, amountOut);
  }
}


interface PoolController {
  function finishPreparedIndexPool(
    address poolAddress,
    address[] calldata tokens,
    uint256[] calldata balances
  ) external;
}

File 2 of 12 : IPoolInitializer.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;


interface IPoolInitializer {
/* ========== Events ========== */

  event TokensContributed(
    address from,
    address token,
    uint256 amount,
    uint256 credit
  );

/* ========== Mutative ========== */

  function initialize(
    address controller,
    address poolAddress,
    address[] calldata tokens,
    uint256[] calldata amounts
  ) external;

  function finish() external;

  function claimTokens() external;

  function claimTokens(address account) external;

  function claimTokens(address[] calldata accounts) external;

  function contributeTokens(
    address token,
    uint256 amountIn,
    uint256 minimumCredit
  ) external returns (uint256);

  function contributeTokens(
    address[] calldata tokens,
    uint256[] calldata amountsIn,
    uint256 minimumCredit
  ) external returns (uint256);

  function updatePrices() external;

/* ========== Views ========== */

  function isFinished() external view returns (bool);

  function getTotalCredit() external view returns (uint256);

  function getCreditOf(address account) external view returns (uint256);

  function getDesiredTokens() external view returns (address[] memory);

  function getDesiredAmount(address token) external view returns (uint256);

  function getDesiredAmounts(address[] calldata tokens) external view returns (uint256[] memory);

  function getCreditForTokens(address token, uint256 amountIn) external view returns (uint144);
}

File 3 of 12 : IIndexedUniswapV2Oracle.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

/* ==========  Libraries  ========== */
import "../lib/PriceLibrary.sol";
import "../lib/FixedPoint.sol";


interface IIndexedUniswapV2Oracle {
/* ==========  Mutative Functions  ========== */

  function updatePrice(address token) external returns (bool);

  function updatePrices(address[] calldata tokens) external returns (bool[] memory);

/* ==========  Meta Price Queries  ========== */

  function hasPriceObservationInWindow(address token, uint256 priceKey) external view returns (bool);

  function getPriceObservationInWindow(
    address token, uint256 priceKey
  ) external view returns (PriceLibrary.PriceObservation memory);

  function getPriceObservationsInRange(
    address token, uint256 timeFrom, uint256 timeTo
  ) external view returns (PriceLibrary.PriceObservation[] memory prices);

/* ==========  Price Update Queries  ========== */

  function canUpdatePrice(address token) external view returns (bool);

  function canUpdatePrices(address[] calldata tokens) external view returns (bool[] memory);

/* ==========  Price Queries: Singular  ========== */

  function computeTwoWayAveragePrice(
    address token, uint256 minTimeElapsed, uint256 maxTimeElapsed
  ) external view returns (PriceLibrary.TwoWayAveragePrice memory);

  function computeAverageTokenPrice(
    address token, uint256 minTimeElapsed, uint256 maxTimeElapsed
  ) external view returns (FixedPoint.uq112x112 memory);

  function computeAverageEthPrice(
    address token, uint256 minTimeElapsed, uint256 maxTimeElapsed
  ) external view returns (FixedPoint.uq112x112 memory);

/* ==========  Price Queries: Multiple  ========== */

  function computeTwoWayAveragePrices(
    address[] calldata tokens,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (PriceLibrary.TwoWayAveragePrice[] memory);

  function computeAverageTokenPrices(
    address[] calldata tokens,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (FixedPoint.uq112x112[] memory);

  function computeAverageEthPrices(
    address[] calldata tokens,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (FixedPoint.uq112x112[] memory);

/* ==========  Value Queries: Singular  ========== */

  function computeAverageEthForTokens(
    address token,
    uint256 tokenAmount,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (uint144);

  function computeAverageTokensForEth(
    address token,
    uint256 wethAmount,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (uint144);

/* ==========  Value Queries: Multiple  ========== */

  function computeAverageEthForTokens(
    address[] calldata tokens,
    uint256[] calldata tokenAmounts,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (uint144[] memory);

  function computeAverageTokensForEth(
    address[] calldata tokens,
    uint256[] calldata wethAmounts,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (uint144[] memory);
}

File 4 of 12 : PriceLibrary.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

/* ==========  Internal Libraries  ========== */
import "./FixedPoint.sol";
import "./UniswapV2OracleLibrary.sol";
import "./UniswapV2Library.sol";


library PriceLibrary {
  using FixedPoint for FixedPoint.uq112x112;
  using FixedPoint for FixedPoint.uq144x112;

/* ========= Structs ========= */

  struct PriceObservation {
    uint32 timestamp;
    uint224 priceCumulativeLast;
    uint224 ethPriceCumulativeLast;
  }

  /**
   * @dev Average prices for a token in terms of weth and weth in terms of the token.
   *
   * Note: The average weth price is not equivalent to the reciprocal of the average
   * token price. See the UniSwap whitepaper for more info.
   */
  struct TwoWayAveragePrice {
    uint224 priceAverage;
    uint224 ethPriceAverage;
  }

/* ========= View Functions ========= */

  function pairInitialized(
    address uniswapFactory,
    address token,
    address weth
  )
    internal
    view
    returns (bool)
  {
    address pair = UniswapV2Library.pairFor(uniswapFactory, token, weth);
    (uint112 reserve0, uint112 reserve1,) = IUniswapV2Pair(pair).getReserves();
    return reserve0 != 0 && reserve1 != 0;
  }

  function observePrice(
    address uniswapFactory,
    address tokenIn,
    address quoteToken
  )
    internal
    view
    returns (uint32 /* timestamp */, uint224 /* priceCumulativeLast */)
  {
    (address token0, address token1) = UniswapV2Library.sortTokens(tokenIn, quoteToken);
    address pair = UniswapV2Library.calculatePair(uniswapFactory, token0, token1);
    if (token0 == tokenIn) {
      (uint256 price0Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrice0(pair);
      return (blockTimestamp, uint224(price0Cumulative));
    } else {
      (uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrice1(pair);
      return (blockTimestamp, uint224(price1Cumulative));
    }
  }

  /**
   * @dev Query the current cumulative price of a token in terms of weth
   * and the current cumulative price of weth in terms of the token.
   */
  function observeTwoWayPrice(
    address uniswapFactory,
    address token,
    address weth
  ) internal view returns (PriceObservation memory) {
    (address token0, address token1) = UniswapV2Library.sortTokens(token, weth);
    address pair = UniswapV2Library.calculatePair(uniswapFactory, token0, token1);
    // Get the sorted token prices
    (
      uint256 price0Cumulative,
      uint256 price1Cumulative,
      uint32 blockTimestamp
    ) = UniswapV2OracleLibrary.currentCumulativePrices(pair);
    // Check which token is weth and which is the token,
    // then build the price observation.
    if (token0 == token) {
      return PriceObservation({
        timestamp: blockTimestamp,
        priceCumulativeLast: uint224(price0Cumulative),
        ethPriceCumulativeLast: uint224(price1Cumulative)
      });
    } else {
      return PriceObservation({
        timestamp: blockTimestamp,
        priceCumulativeLast: uint224(price1Cumulative),
        ethPriceCumulativeLast: uint224(price0Cumulative)
      });
    }
  }

/* ========= Utility Functions ========= */

  /**
   * @dev Computes the average price of a token in terms of weth
   * and the average price of weth in terms of a token using two
   * price observations.
   */
  function computeTwoWayAveragePrice(
    PriceObservation memory observation1,
    PriceObservation memory observation2
  ) internal pure returns (TwoWayAveragePrice memory) {
    uint32 timeElapsed = uint32(observation2.timestamp - observation1.timestamp);
    FixedPoint.uq112x112 memory priceAverage = UniswapV2OracleLibrary.computeAveragePrice(
      observation1.priceCumulativeLast,
      observation2.priceCumulativeLast,
      timeElapsed
    );
    FixedPoint.uq112x112 memory ethPriceAverage = UniswapV2OracleLibrary.computeAveragePrice(
      observation1.ethPriceCumulativeLast,
      observation2.ethPriceCumulativeLast,
      timeElapsed
    );
    return TwoWayAveragePrice({
      priceAverage: priceAverage._x,
      ethPriceAverage: ethPriceAverage._x
    });
  }

  function computeAveragePrice(
    uint32 timestampStart,
    uint224 priceCumulativeStart,
    uint32 timestampEnd,
    uint224 priceCumulativeEnd
  ) internal pure returns (FixedPoint.uq112x112 memory) {
    return UniswapV2OracleLibrary.computeAveragePrice(
      priceCumulativeStart,
      priceCumulativeEnd,
      uint32(timestampEnd - timestampStart)
    );
  }

  /**
   * @dev Computes the average price of the token the price observations
   * are for in terms of weth.
   */
  function computeAverageTokenPrice(
    PriceObservation memory observation1,
    PriceObservation memory observation2
  ) internal pure returns (FixedPoint.uq112x112 memory) {
    return UniswapV2OracleLibrary.computeAveragePrice(
      observation1.priceCumulativeLast,
      observation2.priceCumulativeLast,
      uint32(observation2.timestamp - observation1.timestamp)
    );
  }

  /**
   * @dev Computes the average price of weth in terms of the token
   * the price observations are for.
   */
  function computeAverageEthPrice(
    PriceObservation memory observation1,
    PriceObservation memory observation2
  ) internal pure returns (FixedPoint.uq112x112 memory) {
    return UniswapV2OracleLibrary.computeAveragePrice(
      observation1.ethPriceCumulativeLast,
      observation2.ethPriceCumulativeLast,
      uint32(observation2.timestamp - observation1.timestamp)
    );
  }

  /**
   * @dev Compute the average value in weth of `tokenAmount` of the
   * token that the average price values are for.
   */
  function computeAverageEthForTokens(
    TwoWayAveragePrice memory prices,
    uint256 tokenAmount
  ) internal pure returns (uint144) {
    return FixedPoint.uq112x112(prices.priceAverage).mul(tokenAmount).decode144();
  }

  /**
   * @dev Compute the average value of `wethAmount` weth in terms of
   * the token that the average price values are for.
   */
  function computeAverageTokensForEth(
    TwoWayAveragePrice memory prices,
    uint256 wethAmount
  ) internal pure returns (uint144) {
    return FixedPoint.uq112x112(prices.ethPriceAverage).mul(wethAmount).decode144();
  }
}

File 5 of 12 : FixedPoint.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;


/************************************************************************************************
From https://github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/FixedPoint.sol

Copied from the github repository at commit hash 9642a0705fdaf36b477354a4167a8cd765250860.

Modifications:
- Removed `sqrt` function

Subject to the GPL-3.0 license
*************************************************************************************************/


// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
library FixedPoint {
  // range: [0, 2**112 - 1]
  // resolution: 1 / 2**112
  struct uq112x112 {
    uint224 _x;
  }

  // range: [0, 2**144 - 1]
  // resolution: 1 / 2**112
  struct uq144x112 {
    uint _x;
  }

  uint8 private constant RESOLUTION = 112;
  uint private constant Q112 = uint(1) << RESOLUTION;
  uint private constant Q224 = Q112 << RESOLUTION;

  // encode a uint112 as a UQ112x112
  function encode(uint112 x) internal pure returns (uq112x112 memory) {
    return uq112x112(uint224(x) << RESOLUTION);
  }

  // encodes a uint144 as a UQ144x112
  function encode144(uint144 x) internal pure returns (uq144x112 memory) {
    return uq144x112(uint256(x) << RESOLUTION);
  }

  // divide a UQ112x112 by a uint112, returning a UQ112x112
  function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
    require(x != 0, "FixedPoint: DIV_BY_ZERO");
    return uq112x112(self._x / uint224(x));
  }

  // multiply a UQ112x112 by a uint, returning a UQ144x112
  // reverts on overflow
  function mul(uq112x112 memory self, uint y) internal pure returns (uq144x112 memory) {
    uint z;
    require(
      y == 0 || (z = uint(self._x) * y) / y == uint(self._x),
      "FixedPoint: MULTIPLICATION_OVERFLOW"
    );
    return uq144x112(z);
  }

  // returns a UQ112x112 which represents the ratio of the numerator to the denominator
  // equivalent to encode(numerator).div(denominator)
  function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
    require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
    return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
  }

  // decode a UQ112x112 into a uint112 by truncating after the radix point
  function decode(uq112x112 memory self) internal pure returns (uint112) {
    return uint112(self._x >> RESOLUTION);
  }

  // decode a UQ144x112 into a uint144 by truncating after the radix point
  function decode144(uq144x112 memory self) internal pure returns (uint144) {
    return uint144(self._x >> RESOLUTION);
  }

  // take the reciprocal of a UQ112x112
  function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
    require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
    return uq112x112(uint224(Q224 / self._x));
  }
}

File 6 of 12 : UniswapV2OracleLibrary.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;

/* ==========  Internal Interfaces  ========== */
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";

/* ==========  Internal Libraries  ========== */
import "./FixedPoint.sol";


/************************************************************************************************
Originally from https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2OracleLibrary.sol

This source code has been modified from the original, which was copied from the github repository
at commit hash 6d03bede0a97c72323fa1c379ed3fdf7231d0b26.

Subject to the GPL-3.0 license
*************************************************************************************************/


// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
  using FixedPoint for *;

  // helper function that returns the current block timestamp within the range of uint32, i.e. [0, 2**32 - 1]
  function currentBlockTimestamp() internal view returns (uint32) {
    return uint32(block.timestamp % 2**32);
  }

  // produces the cumulative prices using counterfactuals to save gas and avoid a call to sync.
  function currentCumulativePrices(address pair)
    internal
    view
    returns (
      uint256 price0Cumulative,
      uint256 price1Cumulative,
      uint32 blockTimestamp
    )
  {
    blockTimestamp = currentBlockTimestamp();
    price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
    price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();

    // if time has elapsed since the last update on the pair, mock the accumulated price values
    (
      uint112 reserve0,
      uint112 reserve1,
      uint32 blockTimestampLast
    ) = IUniswapV2Pair(pair).getReserves();
    require(
      reserve0 != 0 && reserve1 != 0,
      "UniswapV2OracleLibrary::currentCumulativePrices: Pair has no reserves."
    );
    if (blockTimestampLast != blockTimestamp) {
      // subtraction overflow is desired
      uint32 timeElapsed = blockTimestamp - blockTimestampLast;
      // addition overflow is desired
      // counterfactual
      price0Cumulative += (
        uint256(FixedPoint.fraction(reserve1, reserve0)._x) *
        timeElapsed
      );
      // counterfactual
      price1Cumulative += (
        uint256(FixedPoint.fraction(reserve0, reserve1)._x) *
        timeElapsed
      );
    }
  }

  // produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
  // only gets the first price
  function currentCumulativePrice0(address pair)
    internal
    view
    returns (uint256 price0Cumulative, uint32 blockTimestamp)
  {
    blockTimestamp = currentBlockTimestamp();
    price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();

    // if time has elapsed since the last update on the pair, mock the accumulated price values
    (
      uint112 reserve0,
      uint112 reserve1,
      uint32 blockTimestampLast
    ) = IUniswapV2Pair(pair).getReserves();
    require(
      reserve0 != 0 && reserve1 != 0,
      "UniswapV2OracleLibrary::currentCumulativePrice0: Pair has no reserves."
    );
    if (blockTimestampLast != blockTimestamp) {
      // subtraction overflow is desired
      uint32 timeElapsed = blockTimestamp - blockTimestampLast;
      // addition overflow is desired
      // counterfactual
      price0Cumulative += (
        uint256(FixedPoint.fraction(reserve1, reserve0)._x) *
        timeElapsed
      );
    }
  }

  // produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
  // only gets the second price
  function currentCumulativePrice1(address pair)
    internal
    view
    returns (uint256 price1Cumulative, uint32 blockTimestamp)
  {
    blockTimestamp = currentBlockTimestamp();
    price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();

    // if time has elapsed since the last update on the pair, mock the accumulated price values
    (
      uint112 reserve0,
      uint112 reserve1,
      uint32 blockTimestampLast
    ) = IUniswapV2Pair(pair).getReserves();
    require(
      reserve0 != 0 && reserve1 != 0,
      "UniswapV2OracleLibrary::currentCumulativePrice1: Pair has no reserves."
    );
    if (blockTimestampLast != blockTimestamp) {
      // subtraction overflow is desired
      uint32 timeElapsed = blockTimestamp - blockTimestampLast;
      // addition overflow is desired
      // counterfactual
      price1Cumulative += (
        uint256(FixedPoint.fraction(reserve0, reserve1)._x) *
        timeElapsed
      );
    }
  }

  function computeAveragePrice(
    uint224 priceCumulativeStart,
    uint224 priceCumulativeEnd,
    uint32 timeElapsed
  ) internal pure returns (FixedPoint.uq112x112 memory priceAverage) {
    // overflow is desired.
    priceAverage = FixedPoint.uq112x112(
      uint224((priceCumulativeEnd - priceCumulativeStart) / timeElapsed)
    );
  }
}

File 7 of 12 : IUniswapV2Pair.sol
pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

File 8 of 12 : UniswapV2Library.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;

/************************************************************************************************
Originally from https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2Library.sol

This source code has been modified from the original, which was copied from the github repository
at commit hash 87edfdcaf49ccc52591502993db4c8c08ea9eec0.

Subject to the GPL-3.0 license
*************************************************************************************************/


library UniswapV2Library {
  // returns sorted token addresses, used to handle return values from pairs sorted in this order
  function sortTokens(address tokenA, address tokenB)
    internal
    pure
    returns (address token0, address token1)
  {
    require(tokenA != tokenB, "UniswapV2Library: IDENTICAL_ADDRESSES");
    (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
    require(token0 != address(0), "UniswapV2Library: ZERO_ADDRESS");
  }

  function calculatePair(
    address factory,
    address token0,
    address token1
  ) internal pure returns (address pair) {
    pair = address(
      uint256(
        keccak256(
          abi.encodePacked(
            hex"ff",
            factory,
            keccak256(abi.encodePacked(token0, token1)),
            hex"96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f" // init code hash
          )
        )
      )
    );
  }

  // calculates the CREATE2 address for a pair without making any external calls
  function pairFor(
    address factory,
    address tokenA,
    address tokenB
  ) internal pure returns (address pair) {
    (address token0, address token1) = sortTokens(tokenA, tokenB);
    pair = calculatePair(factory, token0, token1);
  }
}

File 9 of 12 : IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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);
}

File 10 of 12 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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;
    }
}

File 11 of 12 : SafeERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

File 12 of 12 : Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

Settings
{
  "metadata": {
    "useLiteralContent": false
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract IIndexedUniswapV2Oracle","name":"oracle_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"TokensClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"credit","type":"uint256"}],"name":"TokensContributed","type":"event"},{"inputs":[],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"minimumCredit","type":"uint256"}],"name":"contributeTokens","outputs":[{"internalType":"uint256","name":"credit","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amountsIn","type":"uint256[]"},{"internalType":"uint256","name":"minimumCredit","type":"uint256"}],"name":"contributeTokens","outputs":[{"internalType":"uint256","name":"credit","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finish","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"getCreditForTokens","outputs":[{"internalType":"uint144","name":"amountOut","type":"uint144"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCreditOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"getDesiredAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"}],"name":"getDesiredAmounts","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDesiredTokens","outputs":[{"internalType":"address[]","name":"tokens","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalCredit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller_","type":"address"},{"internalType":"address","name":"poolAddress","type":"address"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isFinished","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oracle","outputs":[{"internalType":"contract IIndexedUniswapV2Oracle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"updatePrices","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000095129751769f99cc39824a0793ef4933dd8bb74b

-----Decoded View---------------
Arg [0] : oracle_ (address): 0x95129751769f99CC39824a0793eF4933DD8Bb74B

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000095129751769f99cc39824a0793ef4933dd8bb74b


Deployed Bytecode Sourcemap

1211:10195:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9311:130;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5757:955;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;4738:94::-;;;:::i;:::-;;8542:81;;;:::i;10230:525::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;9445:149::-;;;;;;:::i;:::-;;:::i;7153:1284::-;;;;;;:::i;:::-;;:::i;8742:87::-;;;:::i;:::-;;;;;;;:::i;1554:47::-;;;:::i;:::-;;;;;;;:::i;9598:291::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;9130:132::-;;;;;;:::i;:::-;;:::i;3829:743::-;;;:::i;4946:106::-;;;;;;:::i;:::-;;:::i;3176:500::-;;;;;;:::i;:::-;;:::i;5166:182::-;;;;;;:::i;:::-;;:::i;8959:97::-;;;:::i;2092:25::-;;;:::i;9311:130::-;9387:23;9429:7;9420:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9420:16:10;;;;;;;;;;;;;;;;;;;;;;;9311:130;:::o;5757:955::-;2456:6;;5924:14;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;;;;;;;;;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2652:9:::1;2651:10;2643:35;;;;-1:-1:-1::0;;;2643:35:10::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;5972:31:10;::::2;5948:21;5972:31:::0;;;::::2;::::0;;;;;;;6017:17;6009:44:::2;;;;-1:-1:-1::0;;;6009:44:10::2;;;;;;;:::i;:::-;6074:13;6063:8;:24;6059:69;;;6108:13;6097:24;;6059:69;6142:138;::::0;-1:-1:-1;;;6142:138:10;;-1:-1:-1;;;;;6142:6:10::2;:33;::::0;::::2;::::0;:138:::2;::::0;6183:5;;6196:8;;1424:10:::2;::::0;1493:6:::2;::::0;6142:138:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6133:147:10::2;;;6303:1;6294:6;:10;:26;;;;;6319:1;6308:8;:12;6294:26;6286:54;;;;-1:-1:-1::0;;;6286:54:10::2;;;;;;;:::i;:::-;6364:13;6354:6;:23;;6346:50;;;;-1:-1:-1::0;;;6346:50:10::2;;;;;;;:::i;:::-;6402:67;-1:-1:-1::0;;;;;6402:30:10;::::2;6433:10;6453:4;6460:8:::0;6402:30:::2;:67::i;:::-;6509:27;:13:::0;6527:8;6509:17:::2;:27::i;:::-;-1:-1:-1::0;;;;;6475:31:10;::::2;:24;:31:::0;;;::::2;::::0;;;;;;;:61;;;;6574:10:::2;6565:20:::0;;:8:::2;:20:::0;;;;:32:::2;::::0;6590:6;6565:24:::2;:32::i;:::-;6551:10;6542:20;::::0;;;:8:::2;:20;::::0;;;;:55;6618:12:::2;::::0;:24:::2;::::0;6635:6;6618:16:::2;:24::i;:::-;6603:12;:39:::0;6653:54:::2;::::0;::::2;::::0;::::2;::::0;6671:10:::2;::::0;6683:5;;6690:8;;6700:6;;6653:54:::2;:::i;:::-;;;;;;;;-1:-1:-1::0;2510:6:10;:14;;-1:-1:-1;;;;2510:14:10;;;5757:955;;-1:-1:-1;;;5757:955:10:o;4738:94::-;2456:6;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2567:9:::1;2559:38;;;;-1:-1:-1::0;;;2559:38:10::1;;;;;;;:::i;:::-;4803:24:::2;4816:10;4803:12;:24::i;:::-;2510:6:::0;:14;;-1:-1:-1;;;;2510:14:10;;;4738:94::o;8542:81::-;8590:28;;-1:-1:-1;;;8590:28:10;;-1:-1:-1;;;;;8590:6:10;:19;;;;:28;;8610:7;;8590:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;8590:28:10;;;;;;;;;;;;:::i;:::-;;8542:81::o;10230:525::-;-1:-1:-1;;;;;10390:31:10;;10339:17;10390:31;;;;;;;;;;;10435:17;10427:44;;;;-1:-1:-1;;;10427:44:10;;;;;;;:::i;:::-;10492:13;10481:8;:24;10477:69;;;10526:13;10515:24;;10477:69;10578:138;;-1:-1:-1;;;10578:138:10;;10551:24;;-1:-1:-1;;;;;10578:6:10;:33;;;;:138;;10619:5;;10632:8;;1424:10;;1493:6;;10578:138;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10551:165;10230:525;-1:-1:-1;;;;;10230:525:10:o;9445:149::-;-1:-1:-1;;;;;9558:31:10;9534:7;9558:31;;;;;;;;;;;;9445:149::o;7153:1284::-;2456:6;;7344:14;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2652:9:::1;2651:10;2643:35;;;;-1:-1:-1::0;;;2643:35:10::1;;;;;;;:::i;:::-;7382:6:::0;7409:23;;::::2;7401:47;;;;-1:-1:-1::0;;;7401:47:10::2;;;;;;;:::i;:::-;7463:1;7454:10;;7475:9;7470:801;7494:3;7490:1;:7;7470:801;;;7512:13;7528:6;;7535:1;7528:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;7512:25;;7545:16;7564:9;;7574:1;7564:12;;;;;;;-1:-1:-1::0;;;;;7608:31:10;::::2;7584:21;7608:31:::0;;;7564:12:::2;7608:31:::0;;;;;;;;7564:12;::::2;::::0;;;::::2;;::::0;-1:-1:-1;;7655:17:10;7647:44:::2;;;;-1:-1:-1::0;;;7647:44:10::2;;;;;;;:::i;:::-;7714:13;7703:8;:24;7699:73;;;7750:13;7739:24;;7699:73;7799:148;::::0;-1:-1:-1;;;7799:148:10;;7779:17:::2;::::0;-1:-1:-1;;;;;7799:6:10::2;:33;::::0;::::2;::::0;:148:::2;::::0;7842:5;;7857:8;;1424:10:::2;::::0;1493:6:::2;::::0;7799:148:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;7779:168:10::2;;;7975:1;7963:9;:13;:29;;;;;7991:1;7980:8;:12;7963:29;7955:57;;;;-1:-1:-1::0;;;7955:57:10::2;;;;;;;:::i;:::-;8020:67;-1:-1:-1::0;;;;;8020:30:10;::::2;8051:10;8071:4;8078:8:::0;8020:30:::2;:67::i;:::-;8129:27;:13:::0;8147:8;8129:17:::2;:27::i;:::-;-1:-1:-1::0;;;;;8095:31:10;::::2;:24;:31:::0;;;::::2;::::0;;;;;;:61;8173:21:::2;:6:::0;8184:9;8173:10:::2;:21::i;:::-;8164:30;;8207:57;8225:10;8237:5;8244:8;8254:9;8207:57;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;7499:3:10::2;::::0;;::::2;::::0;-1:-1:-1;7470:801:10::2;::::0;-1:-1:-1;7470:801:10::2;;;8294:13;8284:6;:23;;8276:50;;;;-1:-1:-1::0;;;8276:50:10::2;;;;;;;:::i;:::-;8364:10;8355:20;::::0;;;:8:::2;:20;::::0;;;;;:32:::2;::::0;8380:6;8355:24:::2;:32::i;:::-;8341:10;8332:20;::::0;;;:8:::2;:20;::::0;;;;:55;8408:12:::2;::::0;:24:::2;::::0;8425:6;8408:16:::2;:24::i;:::-;8393:12;:39:::0;-1:-1:-1;2510:6:10;:14;;-1:-1:-1;;;;2510:14:10;;;7153:1284;;-1:-1:-1;;;;;7153:1284:10:o;8742:87::-;8815:9;;;;8742:87;:::o;1554:47::-;;;:::o;9598:291::-;9700:24;9758:6;9744:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9744:28:10;;9734:38;;9783:9;9778:107;9798:17;;;9778:107;;;9843:24;:35;9868:6;;9875:1;9868:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9843:35:10;-1:-1:-1;;;;;9843:35:10;;;;;;;;;;;;;9830:7;9838:1;9830:10;;;;;;;;;;;;;;;;;:48;9817:3;;9778:107;;;;9598:291;;;;:::o;9130:132::-;-1:-1:-1;;;;;9240:17:10;9216:7;9240:17;;;:8;:17;;;;;;;9130:132::o;3829:743::-;2456:6;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2652:9:::1;2651:10;2643:35;;;;-1:-1:-1::0;;;2643:35:10::1;;;;;;;:::i;:::-;3925:7:::2;:14:::0;3967:10:::2;::::0;-1:-1:-1;;;;;3967:10:10::2;3983:23;3925:14:::0;4009:18:::2;::::0;::::2;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;4009:18:10::2;;3983:44;;4033:25;4075:3;4061:18;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;4061:18:10::2;;4033:46;;4090:9;4085:348;4109:3;4105:1;:7;4085:348;;;4127:13;4143:7;4151:1;4143:10;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;4143:10:10::2;4127:26;;4173:5;4161:6;4168:1;4161:9;;;;;;;;-1:-1:-1::0;;;;;4161:17:10;;::::2;:9;::::0;;::::2;::::0;;;;;:17;4204:38:::2;::::0;-1:-1:-1;;;4204:38:10;;4186:15:::2;::::0;4204:23;::::2;::::0;::::2;::::0;:38:::2;::::0;4236:4:::2;::::0;4204:38:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4186:56;;4264:7;4250:8;4259:1;4250:11;;;;;;;;;::::0;;::::2;::::0;;;;;:21;4305:12:::2;::::0;4279:48:::2;::::0;-1:-1:-1;;;;;4279:25:10;;::::2;::::0;4305:12:::2;::::0;::::2;;4319:7:::0;4279:25:::2;:48::i;:::-;-1:-1:-1::0;;;;;4352:31:10;::::2;:24;:31:::0;;;::::2;::::0;;;;;;;:36;4335:91:::2;;;;-1:-1:-1::0;;;4335:91:10::2;;;;;;;:::i;:::-;-1:-1:-1::0;;4114:3:10::2;;4085:348;;;-1:-1:-1::0;4497:12:10::2;::::0;4438:107:::2;::::0;-1:-1:-1;;;4438:107:10;;-1:-1:-1;;;;;4438:51:10;;::::2;::::0;::::2;::::0;:107:::2;::::0;4497:12:::2;::::0;;::::2;::::0;;::::2;::::0;4517:6;;4531:8;;4438:107:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;4551:9:10::2;:16:::0;;-1:-1:-1;;;;;;4551:16:10;;::::2;4563:4;4551:16;2510:14:::0;;;-1:-1:-1;;;;;;3829:743:10:o;4946:106::-;2456:6;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2567:9:::1;2559:38;;;;-1:-1:-1::0;;;2559:38:10::1;;;;;;;:::i;:::-;5026:21:::2;5039:7;5026:12;:21::i;:::-;-1:-1:-1::0;2510:6:10;:14;;-1:-1:-1;;;;2510:14:10;;;4946:106::o;3176:500::-;3355:12;;;;;-1:-1:-1;;;;;3355:12:10;:26;3347:54;;;;-1:-1:-1;;;3347:54:10;;;;;;;:::i;:::-;3407:12;:26;;-1:-1:-1;;;;;;3407:26:10;;-1:-1:-1;;;;;3407:26:10;;;;;;;;;;;;;;3439:10;:24;;-1:-1:-1;;;;;;3439:24:10;;;;;;;;;;3483:6;3510:21;;;3502:45;;;;-1:-1:-1;;;3502:45:10;;;;;;;:::i;:::-;3553:16;:7;3563:6;;3553:16;:::i;:::-;;3580:9;3575:97;3599:3;3595:1;:7;3575:97;;;3655:7;;3663:1;3655:10;;;;;;;;;;;;;3617:24;:35;3642:6;;3649:1;3642:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;3617:35:10;;;;;;;;;;;;-1:-1:-1;3617:35:10;:48;3604:3;;3575:97;;;;3176:500;;;;;;;:::o;5166:182::-;2456:6;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2567:9:::1;2559:38;;;;-1:-1:-1::0;;;2559:38:10::1;;;;;;;:::i;:::-;5263:9:::2;5258:86;5278:19:::0;;::::2;5258:86;;;5312:25;5325:8;;5334:1;5325:11;;;;;;;;;;;;;;;;;;;;:::i;:::-;5312:12;:25::i;:::-;5299:3;;5258:86;;;-1:-1:-1::0;;2510:6:10;:14;;-1:-1:-1;;;;2510:14:10;;;-1:-1:-1;5166:182:10:o;8959:97::-;9039:12;;8959:97;:::o;2092:25::-;;;-1:-1:-1;;;;;2092:25:10;;:::o;877:203:7:-;977:96;997:5;1027:27;;;1056:4;1062:2;1066:5;1004:68;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1004:68:7;;;;;;;;;;;;;;-1:-1:-1;;;;;1004:68:7;-1:-1:-1;;;;;;1004:68:7;;;;;;;;;;977:19;:96::i;:::-;877:203;;;;:::o;1321:134:5:-;1379:7;1405:43;1409:1;1412;1405:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1398:50;;1321:134;;;;;:::o;874:176::-;932:7;963:5;;;986:6;;;;978:46;;;;-1:-1:-1;;;978:46:5;;;;;;;:::i;11066:338:10:-;-1:-1:-1;;;;;11137:17:10;;11120:14;11137:17;;;:8;:17;;;;;;11168:10;11160:38;;;;-1:-1:-1;;;11160:38:10;;;;;;;:::i;:::-;11256:12;;11204:17;;11224:45;;11225:25;1545:4;11243:6;11225:17;:25::i;:::-;11224:31;;:45::i;:::-;-1:-1:-1;;;;;11275:17:10;;;11295:1;11275:17;;;:8;:17;;;;;:21;11309:12;;11204:65;;-1:-1:-1;11302:53:10;;11309:12;;;;11284:7;11204:65;11302:33;:53::i;:::-;11366:33;11380:7;11389:9;11366:33;;;;;;;:::i;:::-;;;;;;;;11066:338;;;:::o;1340:613:7:-;1705:10;;;1704:62;;-1:-1:-1;1721:39:7;;-1:-1:-1;;;1721:39:7;;-1:-1:-1;;;;;1721:15:7;;;;;:39;;1745:4;;1752:7;;1721:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;1704:62;1696:150;;;;-1:-1:-1;;;1696:150:7;;;;;;;:::i;:::-;1856:90;1876:5;1906:22;;;1930:7;1939:5;1883:62;;;;;;;;;:::i;1856:90::-;1340:613;;;:::o;2959:751::-;3378:23;3404:69;3432:4;3404:69;;;;;;;;;;;;;;;;;3412:5;-1:-1:-1;;;;;3404:27:7;;;:69;;;;;:::i;:::-;3487:17;;3378:95;;-1:-1:-1;3487:21:7;3483:221;;3627:10;3616:30;;;;;;;;;;;;:::i;:::-;3608:85;;;;-1:-1:-1;;;3608:85:7;;;;;;;:::i;1746:187:5:-;1832:7;1867:12;1859:6;;;;1851:29;;;;-1:-1:-1;;;1851:29:5;;;;;;;;:::i;:::-;-1:-1:-1;;;1902:5:5;;;1746:187::o;2180:459::-;2238:7;2479:6;2475:45;;-1:-1:-1;2508:1:5;2501:8;;2475:45;2542:5;;;2546:1;2542;:5;:1;2565:5;;;;;:10;2557:56;;;;-1:-1:-1;;;2557:56:5;;;;;;;:::i;3101:130::-;3159:7;3185:39;3189:1;3192;3185:39;;;;;;;;;;;;;;;;;:3;:39::i;696:175:7:-;778:86;798:5;828:23;;;853:2;857:5;805:58;;;;;;;;;:::i;3573:194:8:-;3676:12;3707:53;3730:6;3738:4;3744:1;3747:12;3707:22;:53::i;:::-;3700:60;3573:194;-1:-1:-1;;;;3573:194:8:o;3713:272:5:-;3799:7;3833:12;3826:5;3818:28;;;;-1:-1:-1;;;3818:28:5;;;;;;;;:::i;:::-;;3856:9;3872:1;3868;:5;;;;;;;3713:272;-1:-1:-1;;;;;3713:272:5:o;4920:958:8:-;5050:12;5082:18;5093:6;5082:10;:18::i;:::-;5074:60;;;;-1:-1:-1;;;5074:60:8;;;;;;;:::i;:::-;5205:12;5219:23;5246:6;-1:-1:-1;;;;;5246:11:8;5266:8;5277:4;5246:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5204:78;;;;5296:7;5292:580;;;5326:10;-1:-1:-1;5319:17:8;;-1:-1:-1;5319:17:8;5292:580;5437:17;;:21;5433:429;;5695:10;5689:17;5755:15;5742:10;5738:2;5734:19;5727:44;5644:145;5834:12;5827:20;;-1:-1:-1;;;5827:20:8;;;;;;;;:::i;718:413::-;1078:20;1116:8;;;718:413::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;5:130;72:20;;-1:-1;;;;;31331:54;;33705:35;;33695:2;;33754:1;;33744:12;160:352;;;290:3;283:4;275:6;271:17;267:27;257:2;;-1:-1;;298:12;257:2;-1:-1;328:20;;368:18;357:30;;354:2;;;-1:-1;;390:12;354:2;434:4;426:6;422:17;410:29;;485:3;434:4;;469:6;465:17;426:6;451:32;;448:41;445:2;;;502:1;;492:12;445:2;250:262;;;;;:::o;1634:128::-;1709:13;;31561;;31554:21;33826:32;;33816:2;;33872:1;;33862:12;2188:241;;2292:2;2280:9;2271:7;2267:23;2263:32;2260:2;;;-1:-1;;2298:12;2260:2;2360:53;2405:7;2381:22;2360:53;:::i;2436:929::-;;;;;;;2661:3;2649:9;2640:7;2636:23;2632:33;2629:2;;;-1:-1;;2668:12;2629:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2720:63;-1:-1;2820:2;2859:22;;72:20;97:33;72:20;97:33;:::i;:::-;2828:63;-1:-1;2956:2;2941:18;;2928:32;2980:18;2969:30;;;2966:2;;;-1:-1;;3002:12;2966:2;3040:80;3112:7;3103:6;3092:9;3088:22;3040:80;:::i;:::-;3022:98;;-1:-1;3022:98;-1:-1;3185:2;3170:18;;3157:32;;-1:-1;3198:30;;;3195:2;;;-1:-1;;3231:12;3195:2;;3269:80;3341:7;3332:6;3321:9;3317:22;3269:80;:::i;:::-;2623:742;;;;-1:-1;2623:742;;-1:-1;2623:742;;3251:98;;2623:742;-1:-1;;;2623:742::o;3372:366::-;;;3493:2;3481:9;3472:7;3468:23;3464:32;3461:2;;;-1:-1;;3499:12;3461:2;3561:53;3606:7;3582:22;3561:53;:::i;:::-;3551:63;3651:2;3690:22;;;;1977:20;;-1:-1;;;3455:283::o;3745:491::-;;;;3883:2;3871:9;3862:7;3858:23;3854:32;3851:2;;;-1:-1;;3889:12;3851:2;3951:53;3996:7;3972:22;3951:53;:::i;:::-;3941:63;4041:2;4080:22;;1977:20;;-1:-1;4149:2;4188:22;;;1977:20;;3845:391;-1:-1;;;3845:391::o;4243:397::-;;;4382:2;4370:9;4361:7;4357:23;4353:32;4350:2;;;-1:-1;;4388:12;4350:2;4446:17;4433:31;4484:18;4476:6;4473:30;4470:2;;;-1:-1;;4506:12;4470:2;4544:80;4616:7;4607:6;4596:9;4592:22;4544:80;:::i;:::-;4526:98;;;;-1:-1;4344:296;-1:-1;;;;4344:296::o;4647:803::-;;;;;;4855:2;4843:9;4834:7;4830:23;4826:32;4823:2;;;-1:-1;;4861:12;4823:2;4919:17;4906:31;4957:18;;4949:6;4946:30;4943:2;;;-1:-1;;4979:12;4943:2;5017:80;5089:7;5080:6;5069:9;5065:22;5017:80;:::i;:::-;4999:98;;-1:-1;4999:98;-1:-1;5162:2;5147:18;;5134:32;;-1:-1;5175:30;;;5172:2;;;-1:-1;;5208:12;5172:2;;5246:80;5318:7;5309:6;5298:9;5294:22;5246:80;:::i;:::-;4817:633;;;;-1:-1;5228:98;5363:2;5402:22;1977:20;;4817:633;-1:-1;;;;4817:633::o;5457:386::-;;5594:2;;5582:9;5573:7;5569:23;5565:32;5562:2;;;-1:-1;;5600:12;5562:2;5651:17;5645:24;5689:18;;5681:6;5678:30;5675:2;;;-1:-1;;5711:12;5675:2;5810:6;5799:9;5795:22;;;660:3;653:4;645:6;641:17;637:27;627:2;;-1:-1;;668:12;627:2;708:6;702:13;5689:18;28866:6;28863:30;28860:2;;;-1:-1;;28896:12;28860:2;5594;28933:6;28929:17;;;730:77;5594:2;28929:17;28994:15;730:77;:::i;:::-;835:21;;;892:14;;;;867:17;;;972:27;;;;;969:36;-1:-1;966:2;;;-1:-1;;1008:12;966:2;-1:-1;1034:10;;1028:214;1053:6;1050:1;1047:13;1028:214;;;1133:45;1174:3;1162:10;1133:45;:::i;:::-;1121:58;;1075:1;1068:9;;;;;1193:14;;;;1221;;1028:214;;;-1:-1;5731:96;5556:287;-1:-1;;;;;;;;5556:287::o;5850:257::-;;5962:2;5950:9;5941:7;5937:23;5933:32;5930:2;;;-1:-1;;5968:12;5930:2;1715:6;1709:13;33851:5;31561:13;31554:21;33829:5;33826:32;33816:2;;-1:-1;;33862:12;6114:263;;6229:2;6217:9;6208:7;6204:23;6200:32;6197:2;;;-1:-1;;6235:12;6197:2;1853:6;1847:13;-1:-1;;;;;33975:5;31649:50;33950:5;33947:35;33937:2;;-1:-1;;33986:12;6384:263;;6499:2;6487:9;6478:7;6474:23;6470:32;6467:2;;;-1:-1;;6505:12;6467:2;-1:-1;2125:13;;6461:186;-1:-1;6461:186::o;7428:690::-;;7621:5;29625:12;30688:6;30683:3;30676:19;30725:4;;30720:3;30716:14;7633:93;;30725:4;7797:5;29141:14;-1:-1;7836:260;7861:6;7858:1;7855:13;7836:260;;;7922:13;;-1:-1;;;;;31331:54;7228:37;;6808:14;;;;30304;;;;31342:42;7876:9;7836:260;;;-1:-1;8102:10;;7552:566;-1:-1;;;;;7552:566::o;8905:690::-;;9098:5;29625:12;30688:6;30683:3;30676:19;30725:4;;30720:3;30716:14;9110:93;;30725:4;9274:5;29141:14;-1:-1;9313:260;9338:6;9335:1;9332:13;9313:260;;;9399:13;;15879:37;;6990:14;;;;30304;;;;9360:1;9353:9;9313:260;;16179:271;;9874:5;29625:12;9985:52;10030:6;10025:3;10018:4;10011:5;10007:16;9985:52;:::i;:::-;10049:16;;;;;16313:137;-1:-1;;16313:137::o;16457:222::-;-1:-1;;;;;31331:54;;;;7228:37;;16584:2;16569:18;;16555:124::o;16686:572::-;-1:-1;;;;;31331:54;;;7097:58;;31331:54;;;;17078:2;17063:18;;7228:37;17161:2;17146:18;;15879:37;17244:2;17229:18;;15879:37;;;;16905:3;16890:19;;16876:382::o;17265:333::-;-1:-1;;;;;31331:54;;;7228:37;;31331:54;;17584:2;17569:18;;7228:37;17420:2;17405:18;;17391:207::o;17605:444::-;-1:-1;;;;;31331:54;;;7228:37;;31331:54;;;;17952:2;17937:18;;7228:37;18035:2;18020:18;;15879:37;;;;17788:2;17773:18;;17759:290::o;18056:740::-;-1:-1;;;;;31331:54;;7228:37;;18339:2;18457;18442:18;;18435:48;;;18056:740;;18497:108;;18324:18;;18591:6;18497:108;:::i;:::-;18653:9;18647:4;18643:20;18638:2;18627:9;18623:18;18616:48;18678:108;18781:4;18772:6;18678:108;:::i;:::-;18670:116;18310:486;-1:-1;;;;;;18310:486::o;18803:333::-;-1:-1;;;;;31331:54;;;;7228:37;;19122:2;19107:18;;15879:37;18958:2;18943:18;;18929:207::o;19143:552::-;-1:-1;;;;;31331:54;;;;7228:37;;19517:2;19502:18;;15879:37;;;;31990:10;31979:22;;;19599:2;19584:18;;16118:49;31979:22;19681:2;19666:18;;16118:49;19352:3;19337:19;;19323:372::o;19702:370::-;;19879:2;19900:17;19893:47;19954:108;19879:2;19868:9;19864:18;20048:6;19954:108;:::i;20079:364::-;20253:2;20267:47;;;29772:12;;20238:18;;;30676:19;;;20079:364;29294:14;;;29323:18;;;20079:364;;20253:2;30716:14;;;;20079:364;8556:288;8581:6;8578:1;8575:13;8556:288;;;33407:11;;-1:-1;;;;;31331:54;7228:37;;31342:42;30416:14;;;;6808;;;;8596:9;8556:288;;;-1:-1;20320:113;;20224:219;-1:-1;;;;;;20224:219::o;20450:370::-;;20627:2;20648:17;20641:47;20702:108;20627:2;20616:9;20612:18;20796:6;20702:108;:::i;20827:210::-;31561:13;;31554:21;9668:34;;20948:2;20933:18;;20919:118::o;21335:310::-;;21482:2;21503:17;21496:47;10417:5;29625:12;30688:6;21482:2;21471:9;21467:18;30676:19;10511:52;10556:6;30716:14;21471:9;30716:14;21482:2;10537:5;10533:16;10511:52;:::i;:::-;33515:7;33499:14;-1:-1;;33495:28;10575:39;;;;30716:14;10575:39;;21453:192;-1:-1;;21453:192::o;21652:416::-;21852:2;21866:47;;;10851:2;21837:18;;;30676:19;-1:-1;;;30716:14;;;10867:39;10925:12;;;21823:245::o;22075:416::-;22275:2;22289:47;;;11176:2;22260:18;;;30676:19;11212:29;30716:14;;;11192:50;11261:12;;;22246:245::o;22498:416::-;22698:2;22712:47;;;11512:2;22683:18;;;30676:19;-1:-1;;;30716:14;;;11528:38;11585:12;;;22669:245::o;22921:416::-;23121:2;23135:47;;;11836:2;23106:18;;;30676:19;-1:-1;;;30716:14;;;11852:38;11909:12;;;23092:245::o;23344:416::-;23544:2;23558:47;;;12160:2;23529:18;;;30676:19;-1:-1;;;30716:14;;;12176:37;12232:12;;;23515:245::o;23767:416::-;23967:2;23981:47;;;12483:2;23952:18;;;30676:19;-1:-1;;;30716:14;;;12499:34;12552:12;;;23938:245::o;24190:416::-;24390:2;24404:47;;;12803:2;24375:18;;;30676:19;12839:34;30716:14;;;12819:55;-1:-1;;;12894:12;;;12887:25;12931:12;;;24361:245::o;24613:416::-;24813:2;24827:47;;;13182:2;24798:18;;;30676:19;-1:-1;;;30716:14;;;13198:41;13258:12;;;24784:245::o;25036:416::-;25236:2;25250:47;;;13509:2;25221:18;;;30676:19;-1:-1;;;30716:14;;;13525:34;13578:12;;;25207:245::o;25459:416::-;25659:2;25673:47;;;13829:2;25644:18;;;30676:19;-1:-1;;;30716:14;;;13845:37;13901:12;;;25630:245::o;25882:416::-;26082:2;26096:47;;;14152:2;26067:18;;;30676:19;-1:-1;;;30716:14;;;14168:38;14225:12;;;26053:245::o;26305:416::-;26505:2;26519:47;;;14476:2;26490:18;;;30676:19;14512:31;30716:14;;;14492:52;14563:12;;;26476:245::o;26728:416::-;26928:2;26942:47;;;14814:2;26913:18;;;30676:19;-1:-1;;;30716:14;;;14830:35;14884:12;;;26899:245::o;27151:416::-;27351:2;27365:47;;;15135:2;27336:18;;;30676:19;15171:34;30716:14;;;15151:55;-1:-1;;;15226:12;;;15219:34;15272:12;;;27322:245::o;27574:416::-;27774:2;27788:47;;;15523:2;27759:18;;;30676:19;15559:34;30716:14;;;15539:55;-1:-1;;;15614:12;;;15607:46;15672:12;;;27745:245::o;27997:222::-;-1:-1;;;;;31649:50;;;;15769:37;;28124:2;28109:18;;28095:124::o;28226:222::-;15879:37;;;28353:2;28338:18;;28324:124::o;28455:256::-;28517:2;28511:9;28543:17;;;28618:18;28603:34;;28639:22;;;28600:62;28597:2;;;28675:1;;28665:12;28597:2;28517;28684:22;28495:216;;-1:-1;28495:216::o;32842:268::-;32907:1;32914:101;32928:6;32925:1;32922:13;32914:101;;;32995:11;;;32989:18;32976:11;;;32969:39;32950:2;32943:10;32914:101;;;33030:6;33027:1;33024:13;33021:2;;;-1:-1;;32907:1;33077:16;;33070:27;32891:219::o;33646:117::-;-1:-1;;;;;31331:54;;33705:35;;33695:2;;33754:1;;33744:12

Swarm Source

ipfs://e3520d0bf6e7a682da5f0f912a2f067897e91df436e3457862ff872026b15fe9

Block Transaction Gas Used Reward
view all blocks produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ 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.