Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library ABDKMath64x64
•    - function fromInt (int256 x)
•    - function toInt (int128 x)
•    - function fromUInt (uint256 x)
•    - function toUInt (int128 x)
•    - function from128x128 (int256 x)
•    - function to128x128 (int128 x)
•    - function add (int128 x, int128 y)
•    - function sub (int128 x, int128 y)
•    - function mul (int128 x, int128 y)
•    - function muli (int128 x, int256 y)
•    - function mulu (int128 x, uint256 y)
•    - function div (int128 x, int128 y)
•    - function divi (int256 x, int256 y)
•    - function divu (uint256 x, uint256 y)
•    - function neg (int128 x)
•    - function abs (int128 x)
•    - function inv (int128 x)
•    - function avg (int128 x, int128 y)
•    - function gavg (int128 x, int128 y)
•    - function pow (int128 x, uint256 y)
•    - function sqrt (int128 x)
•    - function log_2 (int128 x)
•    - function ln (int128 x)
•    - function exp_2 (int128 x)
•    - function exp (int128 x)
•    - function divuu (uint256 x, uint256 y)
•    - function powu (uint256 x, uint256 y)
•    - function sqrtu (uint256 x, uint256 r)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• interface ICoFiXVaultForLP
•    - function setGovernance(address _new)
•    - function setInitCoFiRate(uint256 _new ...
•    - function setDecayPeriod(uint256 _new)
•    - function setDecayRate(uint256 _new)
•    - function addPool(address pool)
•    - function enablePool(address pool)
•    - function disablePool(address pool)
•    - function setPoolWeight(address pool, ...
•    - function batchSetPoolWeight(address[] ...
•    - function distributeReward(address to, ...
•    - function getPendingRewardOfLP(address ...
•    - function currentPeriod()
•    - function currentCoFiRate()
•    - function currentPoolRate(address pool ...
•    - function currentPoolRateByPair(addres ...
•    - function stakingPoolForPair(address p ...
•    - function getPoolInfo(address pool)
•    - function getPoolInfoByPair(address pa ...
•    - function getEnabledPoolCnt()
•    - function getCoFiStakingPool()
• interface ICoFiXStakingRewards
•    - function rewardsVault()
•    - function lastBlockRewardApplicable()
•    - function rewardPerToken()
•    - function earned(address account)
•    - function accrued()
•    - function rewardRate()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function stakingToken()
•    - function rewardsToken()
•    - function stake(uint256 amount)
•    - function stakeForOther(address other, ...
•    - function withdraw(uint256 amount)
•    - function emergencyWithdraw()
•    - function getReward()
•    - function getRewardAndStake()
•    - function exit()
•    - function addReward(uint256 amount)
• interface ICoFiToken is IERC20
•    - function setGovernance(address _new)
•    - function addMinter(address _minter)
•    - function removeMinter(address _minter ...
•    - function mint(address _to, uint256 _a ...
•  contract ReentrancyGuard
• interface ICoFiXFactory
•    - function createPair(
•    - function getPair(address token)
•    - function allPairs(uint256)
•    - function allPairsLength()
•    - function getTradeMiningStatus(address ...
•    - function setTradeMiningStatus(address ...
•    - function getFeeVaultForLP(address tok ...
•    - function setFeeVaultForLP(address tok ...
•    - function setGovernance(address _new)
•    - function setController(address _new)
•    - function setFeeReceiver(address _new)
•    - function setVaultForLP(address _new)
•    - function setVaultForTrader(address _n ...
•    - function setVaultForCNode(address _ne ...
•    - function getController()
•    - function getFeeReceiver()
•    - function getVaultForLP()
•    - function getVaultForTrader()
•    - function getVaultForCNode()
• interface ICoFiXVaultForTrader
•    - function setGovernance(address gov)
•    - function setExpectedYieldRatio(uint25 ...
•    - function setLRatio(uint256 lRatio)
•    - function setTheta(uint256 theta)
•    - function allowRouter(address router)
•    - function disallowRouter(address route ...
•    - function calcCoFiRate(uint256 bt_phi, ...
•    - function currentCoFiRate(address pair ...
•    - function currentThreshold(address pai ...
•    - function stdMiningRateAndAmount(addre ...
•    - function calcDensity(uint256 _stdAmou ...
•    - function calcLambda(uint256 x, uint25 ...
•    - function actualMiningAmountAndDensity ...
•    - function distributeReward(address pai ...
•    - function clearPendingRewardOfCNode()
•    - function clearPendingRewardOfLP(addre ...
•    - function getPendingRewardOfCNode()
•    - function getPendingRewardOfLP(address ...
•    - function getCoFiRateCache(address pai ...
•  contract CoFiXVaultForLP is ICoFiX ... *
•    - function setGovernance(address _new)
•    - function setInitCoFiRate(uint256 _new ...
•    - function setDecayPeriod(uint256 _new)
•    - function setDecayRate(uint256 _new)
•    - function addPool(address pool)
•    - function enablePool(address pool)
•    - function disablePool(address pool)
•    - function setPoolWeight(address pool, ...
•    - function batchSetPoolWeight(address[] ...
•    - function getPendingRewardOfLP(address ...
•    - function distributeReward(address to, ...
•    - function currentPeriod()
•    - function currentCoFiRate()
•    - function currentPoolRate(address pool ...
•    - function currentPoolRateByPair(addres ...
•    - function stakingPoolForPair(address p ...
•    - function getPoolInfo(address pool)
•    - function getPoolInfoByPair(address pa ...
•    - function getEnabledPoolCnt()
•    - function getCoFiStakingPool()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-10-12
*/

// SPDX-License-Identifier: GPL-3.0-or-later

/**

Author: CoFiX Core, https://cofix.io
Commit hash: v0.9.5-1-g7141c43
Repository: https://github.com/Computable-Finance/CoFiX
Issues: https://github.com/Computable-Finance/CoFiX/issues

*/

pragma solidity 0.6.12;


// 
/**
 * @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;
    }
}

// 
/*
 * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
 * Author: Mikhail Vladimirov <[email protected]>
 */
/**
 * 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 {
  /**
   * @dev Minimum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;

  /**
   * @dev 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), uint256 (x) + uint256 (y) >> 1));
  }

  /**
   * 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, 0x10000000000000000));
  }

  /**
   * 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) << 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 >>= 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 >>= xe;
      else x <<= -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 <<= re;
      else if (re < 0) result >>= -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, uint256 r) private pure returns (uint128) {
    if (x == 0) return 0;
    else {
      require (r > 0);
      while (true) {
        uint256 rr = x / r;
        if (r == rr || r + 1 == rr) return uint128 (r);
        else if (r == rr + 1) return uint128 (rr);
        r = r + rr + 1 >> 1;
      }
    }
  }
}

// 
/**
 * @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);
}

// 
interface ICoFiXVaultForLP {

    enum POOL_STATE {INVALID, ENABLED, DISABLED}

    event NewPoolAdded(address pool, uint256 index);
    event PoolEnabled(address pool);
    event PoolDisabled(address pool);

    function setGovernance(address _new) external;
    function setInitCoFiRate(uint256 _new) external;
    function setDecayPeriod(uint256 _new) external;
    function setDecayRate(uint256 _new) external;

    function addPool(address pool) external;
    function enablePool(address pool) external;
    function disablePool(address pool) external;
    function setPoolWeight(address pool, uint256 weight) external;
    function batchSetPoolWeight(address[] memory pools, uint256[] memory weights) external;
    function distributeReward(address to, uint256 amount) external;

    function getPendingRewardOfLP(address pair) external view returns (uint256);
    function currentPeriod() external view returns (uint256);
    function currentCoFiRate() external view returns (uint256);
    function currentPoolRate(address pool) external view returns (uint256 poolRate);
    function currentPoolRateByPair(address pair) external view returns (uint256 poolRate);

    /// @dev Get the award staking pool address of pair (XToken)
    /// @param  pair The address of XToken(pair) contract
    /// @return pool The pool address
    function stakingPoolForPair(address pair) external view returns (address pool);

    function getPoolInfo(address pool) external view returns (POOL_STATE state, uint256 weight);
    function getPoolInfoByPair(address pair) external view returns (POOL_STATE state, uint256 weight);

    function getEnabledPoolCnt() external view returns (uint256);

    function getCoFiStakingPool() external view returns (address pool);

}

// 
interface ICoFiXStakingRewards {
    // Views

    /// @dev The rewards vault contract address set in factory contract
    /// @return Returns the vault address
    function rewardsVault() external view returns (address);

    /// @dev The lastBlock reward applicable
    /// @return Returns the latest block.number on-chain
    function lastBlockRewardApplicable() external view returns (uint256);

    /// @dev Reward amount represents by per staking token
    function rewardPerToken() external view returns (uint256);

    /// @dev How many reward tokens a user has earned but not claimed at present
    /// @param  account The target account
    /// @return The amount of reward tokens a user earned
    function earned(address account) external view returns (uint256);

    /// @dev How many reward tokens accrued recently
    /// @return The amount of reward tokens accrued recently
    function accrued() external view returns (uint256);

    /// @dev Get the latest reward rate of this mining pool (tokens amount per block)
    /// @return The latest reward rate
    function rewardRate() external view returns (uint256);

    /// @dev How many stakingToken (XToken) deposited into to this reward pool (mining pool)
    /// @return The total amount of XTokens deposited in this mining pool
    function totalSupply() external view returns (uint256);

    /// @dev How many stakingToken (XToken) deposited by the target account
    /// @param  account The target account
    /// @return The total amount of XToken deposited in this mining pool
    function balanceOf(address account) external view returns (uint256);

    /// @dev Get the address of token for staking in this mining pool
    /// @return The staking token address
    function stakingToken() external view returns (address);

    /// @dev Get the address of token for rewards in this mining pool
    /// @return The rewards token address
    function rewardsToken() external view returns (address);

    // Mutative

    /// @dev Stake/Deposit into the reward pool (mining pool)
    /// @param  amount The target amount
    function stake(uint256 amount) external;

    /// @dev Stake/Deposit into the reward pool (mining pool) for other account
    /// @param  other The target account
    /// @param  amount The target amount
    function stakeForOther(address other, uint256 amount) external;

    /// @dev Withdraw from the reward pool (mining pool), get the original tokens back
    /// @param  amount The target amount
    function withdraw(uint256 amount) external;

    /// @dev Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw() external;

    /// @dev Claim the reward the user earned
    function getReward() external;

    function getRewardAndStake() external;

    /// @dev User exit the reward pool, it's actually withdraw and getReward
    function exit() external;

    /// @dev Add reward to the mining pool
    function addReward(uint256 amount) external;

    // Events
    event RewardAdded(address sender, uint256 reward);
    event Staked(address indexed user, uint256 amount);
    event StakedForOther(address indexed user, address indexed other, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);
}

// 
interface ICoFiToken is IERC20 {

    /// @dev An event thats emitted when a new governance account is set
    /// @param  _new The new governance address
    event NewGovernance(address _new);

    /// @dev An event thats emitted when a new minter account is added
    /// @param  _minter The new minter address added
    event MinterAdded(address _minter);

    /// @dev An event thats emitted when a minter account is removed
    /// @param  _minter The minter address removed
    event MinterRemoved(address _minter);

    /// @dev Set governance address of CoFi token. Only governance has the right to execute.
    /// @param  _new The new governance address
    function setGovernance(address _new) external;

    /// @dev Add a new minter account to CoFi token, who can mint tokens. Only governance has the right to execute.
    /// @param  _minter The new minter address
    function addMinter(address _minter) external;

    /// @dev Remove a minter account from CoFi token, who can mint tokens. Only governance has the right to execute.
    /// @param  _minter The minter address removed
    function removeMinter(address _minter) external;

    /// @dev mint is used to distribute CoFi token to users, minters are CoFi mining pools
    /// @param  _to The receiver address
    /// @param  _amount The amount of tokens minted
    function mint(address _to, uint256 _amount) external;
}

// 
/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// 
interface ICoFiXFactory {
    // All pairs: {ETH <-> ERC20 Token}
    event PairCreated(address indexed token, address pair, uint256);
    event NewGovernance(address _new);
    event NewController(address _new);
    event NewFeeReceiver(address _new);
    event NewFeeVaultForLP(address token, address feeVault);
    event NewVaultForLP(address _new);
    event NewVaultForTrader(address _new);
    event NewVaultForCNode(address _new);

    /// @dev Create a new token pair for trading
    /// @param  token the address of token to trade
    /// @return pair the address of new token pair
    function createPair(
        address token
        )
        external
        returns (address pair);

    function getPair(address token) external view returns (address pair);
    function allPairs(uint256) external view returns (address pair);
    function allPairsLength() external view returns (uint256);

    function getTradeMiningStatus(address token) external view returns (bool status);
    function setTradeMiningStatus(address token, bool status) external;
    function getFeeVaultForLP(address token) external view returns (address feeVault); // for LPs
    function setFeeVaultForLP(address token, address feeVault) external;

    function setGovernance(address _new) external;
    function setController(address _new) external;
    function setFeeReceiver(address _new) external;
    function setVaultForLP(address _new) external;
    function setVaultForTrader(address _new) external;
    function setVaultForCNode(address _new) external;
    function getController() external view returns (address controller);
    function getFeeReceiver() external view returns (address feeReceiver); // For CoFi Holders
    function getVaultForLP() external view returns (address vaultForLP);
    function getVaultForTrader() external view returns (address vaultForTrader);
    function getVaultForCNode() external view returns (address vaultForCNode);
}

// 
interface ICoFiXVaultForTrader {

    event RouterAllowed(address router);
    event RouterDisallowed(address router);

    event ClearPendingRewardOfCNode(uint256 pendingAmount);
    event ClearPendingRewardOfLP(uint256 pendingAmount);

    function setGovernance(address gov) external;

    function setExpectedYieldRatio(uint256 r) external;
    function setLRatio(uint256 lRatio) external;
    function setTheta(uint256 theta) external;

    function allowRouter(address router) external;

    function disallowRouter(address router) external;

    function calcCoFiRate(uint256 bt_phi, uint256 xt, uint256 np) external view returns (uint256 at);

    function currentCoFiRate(address pair, uint256 np) external view returns (uint256);

    function currentThreshold(address pair, uint256 np, uint256 cofiRate) external view returns (uint256);

    function stdMiningRateAndAmount(address pair, uint256 np, uint256 thetaFee) external view returns (uint256 cofiRate, uint256 stdAmount);

    function calcDensity(uint256 _stdAmount) external view returns (uint256);

    function calcLambda(uint256 x, uint256 y) external pure returns (uint256);

    function actualMiningAmountAndDensity(address pair, uint256 thetaFee, uint256 x, uint256 y, uint256 np) external view returns (uint256 amount, uint256 density, uint256 cofiRate);

    function distributeReward(address pair, uint256 thetaFee, uint256 x, uint256 y, uint256 np, address rewardTo) external;

    function clearPendingRewardOfCNode() external;

    function clearPendingRewardOfLP(address pair) external;

    function getPendingRewardOfCNode() external view returns (uint256);

    function getPendingRewardOfLP(address pair) external view returns (uint256);

    function getCoFiRateCache(address pair) external view returns (uint256 cofiRate, uint256 updatedBlock);
}

// 
// Reward Pool Controller for Liquidity Provider
contract CoFiXVaultForLP is ICoFiXVaultForLP, ReentrancyGuard {

    using SafeMath for uint256;

    uint256 public constant RATE_BASE = 1e18;
    uint256 public constant WEIGHT_BASE = 100;

    address public immutable cofiToken;
    address public immutable factory;

    uint256 public immutable genesisBlock;

    // managed by governance
    address public governance;

    uint256 public initCoFiRate = 9*1e18; // yield per block
    uint256 public decayPeriod = 2400000; // yield decays for every 2,400,000 blocks
    uint256 public decayRate = 80;

    address[] public allPools; // add every pool addr to record, make it easier to track

    uint256 public enabledCnt;

    struct PoolInfo {
        POOL_STATE state;
        uint256 weight;
    }

    mapping (address => PoolInfo) public poolInfo; // pool -> poolInfo

    mapping (address => address) public pairToStakingPool; // pair -> staking pool

    modifier onlyGovernance() {
        require(msg.sender == governance, "CVaultForLP: !governance");
        _;
    }

    constructor(address cofi, address _factory) public {
        cofiToken = cofi;
        factory = _factory;
        governance = msg.sender;
        genesisBlock = 11040688; // https://etherscan.io/block/countdown/11040688
    }

    /* setters for protocol governance */
    function setGovernance(address _new) external override onlyGovernance {
        governance = _new;
    }

    function setInitCoFiRate(uint256 _new) external override onlyGovernance {
        initCoFiRate = _new;
    }

    function setDecayPeriod(uint256 _new) external override onlyGovernance {
        require(_new != 0, "CVaultForLP: wrong period setting");
        decayPeriod = _new;
    }

    function setDecayRate(uint256 _new) external override onlyGovernance {
        decayRate = _new;
    }

    function addPool(address pool) external override onlyGovernance {
        require(poolInfo[pool].state == POOL_STATE.INVALID, "CVaultForLP: pool added"); // INVALID -> ENABLED
        require(pool != address(0), "CVaultForTrader: invalid pool");
        poolInfo[pool].state = POOL_STATE.ENABLED;
        // default rate is zero, to ensure safety
        enabledCnt = enabledCnt.add(1);
        // set pair to reward pool map
        address pair = ICoFiXStakingRewards(pool).stakingToken();
        require(pairToStakingPool[pair] == address(0), "CVaultForLP: pair added");
        pairToStakingPool[pair] = pool; // staking token is CoFiXPair (XToken)
        allPools.push(pool); // add once never delete, using for track
        emit NewPoolAdded(pool, allPools.length);
    }

    function enablePool(address pool) external override onlyGovernance {
        require(poolInfo[pool].state == POOL_STATE.DISABLED, "CVaultForLP: pool not disabled"); // DISABLED -> ENABLED
        require(pool != address(0), "CVaultForTrader: invalid pool");
        poolInfo[pool].state = POOL_STATE.ENABLED;
        enabledCnt = enabledCnt.add(1);
        // set pair to reward pool map
        address pair = ICoFiXStakingRewards(pool).stakingToken();
        require(pairToStakingPool[pair] == address(0), "CVaultForLP: pair added");
        pairToStakingPool[pair] = pool; // staking token is CoFiXPair (XToken)
        emit PoolEnabled(pool);
    }

    function disablePool(address pool) external override onlyGovernance {
        require(poolInfo[pool].state == POOL_STATE.ENABLED, "CVaultForLP: pool not enabled"); // ENABLED -> DISABLED
        require(pool != address(0), "CVaultForTrader: invalid pool");
        poolInfo[pool].state = POOL_STATE.DISABLED;
        poolInfo[pool].weight = 0; // set pool weight to zero;
        enabledCnt = enabledCnt.sub(1);
        address pair = ICoFiXStakingRewards(pool).stakingToken();
        pairToStakingPool[pair] = address(0); // set pair mapping to zero
        emit PoolDisabled(pool);
    }

    function setPoolWeight(address pool, uint256 weight) public override onlyGovernance {
        require(weight <= WEIGHT_BASE, "CVaultForLP: invalid weight");
        require(pool != address(0), "CVaultForTrader: invalid pool");
        require(poolInfo[pool].state == POOL_STATE.ENABLED, "CVaultForLP: pool not enabled"); // only set weight if pool is enabled
        poolInfo[pool].weight = weight;
    }

    function batchSetPoolWeight(address[] memory pools, uint256[] memory weights) external override onlyGovernance {
        uint256 cnt = pools.length;
        require(cnt == weights.length, "CVaultForLP: mismatch len");
        for (uint256 i = 0; i < cnt; i++) {
            require(pools[i] != address(0), "CVaultForTrader: invalid pool");
            require(weights[i] <= WEIGHT_BASE, "CVaultForLP: invalid weight");
            require(poolInfo[pools[i]].state == POOL_STATE.ENABLED, "CVaultForLP: pool not enabled"); // only set weight if pool is enabled
            poolInfo[pools[i]].weight = weights[i];
        }
        // governance should ensure total weights equal to WEIGHT_BASE
    }
    
    function getPendingRewardOfLP(address pair) external override view returns (uint256) {
        POOL_STATE poolState = poolInfo[msg.sender].state;
        if (poolState == POOL_STATE.INVALID || poolState == POOL_STATE.DISABLED) {
            return 0; // if pool is disabled, it can't mint by call distributeReward, so don't count on any reward for it
        }
        // if poolState is enabled, then go on
        address vaultForTrader = ICoFiXFactory(factory).getVaultForTrader();
        if (vaultForTrader == address(0)) {
            return 0; // vaultForTrader is not set yet
        }
        uint256 pending = ICoFiXVaultForTrader(vaultForTrader).getPendingRewardOfLP(pair);
        return pending;
    }

    function distributeReward(address to, uint256 amount) external override nonReentrant {
        POOL_STATE poolState = poolInfo[msg.sender].state;
        require(poolState != POOL_STATE.INVALID, "CVaultForLP: only pool valid");
        if (poolState == POOL_STATE.DISABLED) {
            return; // make sure tx would revert because user still want to withdraw and getReward
        }
        require(to != address(0), "CVaultForTrader: invalid to");
        // if poolState is enabled, then go on. caution: be careful when adding new pool
        address vaultForTrader = ICoFiXFactory(factory).getVaultForTrader();
        if (vaultForTrader != address(0)) { // if equal, means vaultForTrader is not set yet
            address pair = ICoFiXStakingRewards(msg.sender).stakingToken();
            require(pair != address(0), "CVaultForTrader: invalid pair");
            uint256 pending = ICoFiXVaultForTrader(vaultForTrader).getPendingRewardOfLP(pair);
            if (pending > 0) {
                ICoFiXVaultForTrader(vaultForTrader).clearPendingRewardOfLP(pair);
            }
        }
        ICoFiToken(cofiToken).mint(to, amount); // allows zero
    }

    function currentPeriod() public override view returns (uint256) {
        return (block.number).sub(genesisBlock).div(decayPeriod);
    }

    function currentCoFiRate() public override view returns (uint256) {
        uint256 periodIdx = currentPeriod();
        if (periodIdx > 4) {
            periodIdx = 4; // after 5 years, the rate keep constant
        }
        uint256 cofiRate = initCoFiRate;
        uint256 _decayRate = decayRate;
        for (uint256 i = 0; i < periodIdx; i++) {
            cofiRate = cofiRate.mul(_decayRate).div(100);
        }
        return cofiRate;
    }

    function currentPoolRate(address pool) public override view returns (uint256 poolRate) {
        uint256 cnt = enabledCnt;
        if (cnt == 0) {
            return 0;
        }
        uint256 cofiRate = currentCoFiRate();
        uint256 weight = poolInfo[pool].weight;
        poolRate = cofiRate.mul(weight).div(WEIGHT_BASE);
        return poolRate;
    }

    function currentPoolRateByPair(address pair) external override view returns (uint256 poolRate) {
        address pool = pairToStakingPool[pair];
        poolRate = currentPoolRate(pool);
        return poolRate;
    }

    function stakingPoolForPair(address pair) external override view returns (address pool) {
        return pairToStakingPool[pair];
    }

    function getPoolInfo(address pool) public override view returns (POOL_STATE state, uint256 weight) {
        state = poolInfo[pool].state;
        weight = poolInfo[pool].weight;
        return (state, weight);
    }

    function getPoolInfoByPair(address pair) external override view returns (POOL_STATE state, uint256 weight) {
        address pool = pairToStakingPool[pair];
        return getPoolInfo(pool);
    }

    // pools in enabled state
    function getEnabledPoolCnt() external override view returns (uint256) {
        return enabledCnt;
    }

    function getCoFiStakingPool() external override view returns (address pool) {
        return ICoFiXFactory(factory).getFeeReceiver();
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"cofi","type":"address"},{"internalType":"address","name":"_factory","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool","type":"address"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"}],"name":"NewPoolAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool","type":"address"}],"name":"PoolDisabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pool","type":"address"}],"name":"PoolEnabled","type":"event"},{"inputs":[],"name":"RATE_BASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WEIGHT_BASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"addPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allPools","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"pools","type":"address[]"},{"internalType":"uint256[]","name":"weights","type":"uint256[]"}],"name":"batchSetPoolWeight","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cofiToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentCoFiRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"currentPoolRate","outputs":[{"internalType":"uint256","name":"poolRate","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"currentPoolRateByPair","outputs":[{"internalType":"uint256","name":"poolRate","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decayPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decayRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"disablePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"distributeReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"enablePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"enabledCnt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"genesisBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCoFiStakingPool","outputs":[{"internalType":"address","name":"pool","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getEnabledPoolCnt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"getPendingRewardOfLP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"getPoolInfo","outputs":[{"internalType":"enum ICoFiXVaultForLP.POOL_STATE","name":"state","type":"uint8"},{"internalType":"uint256","name":"weight","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"getPoolInfoByPair","outputs":[{"internalType":"enum ICoFiXVaultForLP.POOL_STATE","name":"state","type":"uint8"},{"internalType":"uint256","name":"weight","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initCoFiRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"pairToStakingPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"poolInfo","outputs":[{"internalType":"enum ICoFiXVaultForLP.POOL_STATE","name":"state","type":"uint8"},{"internalType":"uint256","name":"weight","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_new","type":"uint256"}],"name":"setDecayPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_new","type":"uint256"}],"name":"setDecayRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_new","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_new","type":"uint256"}],"name":"setInitCoFiRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"},{"internalType":"uint256","name":"weight","type":"uint256"}],"name":"setPoolWeight","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"stakingPoolForPair","outputs":[{"internalType":"address","name":"pool","type":"address"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000001a23a6bfbadb59fa563008c0fb7cf96dfcf34ea100000000000000000000000066c64ecc3a6014733325a8f2ebee46b4ca3ed550

-----Decoded View---------------
Arg [0] : cofi (address): 0x1a23a6BfBAdB59fa563008c0fB7cf96dfCF34Ea1
Arg [1] : _factory (address): 0x66C64ecC3A6014733325a8f2EBEE46B4CA3ED550

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000001a23a6bfbadb59fa563008c0fb7cf96dfcf34ea1
Arg [1] : 00000000000000000000000066c64ecc3a6014733325a8f2ebee46b4ca3ed550