Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 15 from a total of 15 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Feed | 12440397 | 1170 days ago | IN | 0 ETH | 0.01221428 | ||||
Transfer Ownersh... | 12420626 | 1173 days ago | IN | 0 ETH | 0.01151351 | ||||
Configure | 12312342 | 1190 days ago | IN | 0 ETH | 0.00255662 | ||||
Configure | 12312065 | 1190 days ago | IN | 0 ETH | 0.00337839 | ||||
Feed | 12311851 | 1190 days ago | IN | 0 ETH | 0.01116563 | ||||
Configure | 12311847 | 1190 days ago | IN | 0 ETH | 0.00333151 | ||||
Feed | 12311818 | 1190 days ago | IN | 0 ETH | 0.01254045 | ||||
Configure | 12311818 | 1190 days ago | IN | 0 ETH | 0.00208905 | ||||
Configure | 12311817 | 1190 days ago | IN | 0 ETH | 0.01346865 | ||||
Feed | 12311810 | 1190 days ago | IN | 0 ETH | 0.01378965 | ||||
Set Oracle | 12311799 | 1190 days ago | IN | 0 ETH | 0.0032256 | ||||
Set Curve | 12311687 | 1190 days ago | IN | 0 ETH | 0.00211968 | ||||
Set Target | 12311670 | 1190 days ago | IN | 0 ETH | 0.00211866 | ||||
Set Token | 12311665 | 1190 days ago | IN | 0 ETH | 0.00212175 | ||||
0x60806040 | 12311657 | 1190 days ago | IN | 0 ETH | 0.05367625 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
WeightFeeder
Compiler Version
v0.7.6+commit.7338295f
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol'; import {IPoolStore, IPoolStoreGov} from './PoolStore.sol'; import {Operator} from '../access/Operator.sol'; import {IOracle} from '../oracle/Oracle.sol'; import {ICurve} from '../curve/Curve.sol'; contract WeightFeeder is Operator { using SafeMath for uint256; enum FeedStatus {Neutral, BelowPeg, AbovePeg} uint256 public constant ETH = 1e18; // gov address public token; address public target; address public curve; address public oracle; function setToken(address _newToken) public onlyOwner { token = _newToken; } function setTarget(address _newTarget) public onlyOwner { target = _newTarget; } function setCurve(address _newCurve) public onlyOwner { curve = _newCurve; } function setOracle(address _newOracle) public onlyOwner { oracle = _newOracle; } // pools uint256 public cashLP; uint256 public cashVault; uint256 public shareLP; uint256 public boardroom; uint256 public bondroom; uint256 public strategicPair; uint256 public communityFund; FeedStatus public lastUpdated = FeedStatus.Neutral; function configure( uint256 _cashLP, uint256 _cashVault, uint256 _shareLP, uint256 _boardroom, uint256 _bondroom, uint256 _strategicPair, uint256 _communityFund ) public onlyOwner { cashLP = _cashLP; cashVault = _cashVault; shareLP = _shareLP; boardroom = _boardroom; bondroom = _bondroom; strategicPair = _strategicPair; communityFund = _communityFund; } function feed() public onlyOperator { uint256 price = IOracle(oracle).consult(token, ETH); uint256 rate = ICurve(curve).calcCeiling(price); // 60 * 1e18 IPoolStoreGov(target).setPool(cashLP, rate.mul(60)); IPoolStoreGov(target).setPool(cashVault, ETH.sub(rate).mul(60)); if (IPoolStore(target).weightOf(shareLP) != ETH.mul(10)) { IPoolStoreGov(target).setPool(shareLP, ETH.mul(10)); } // below peg if (lastUpdated != FeedStatus.BelowPeg && price < ETH) { /* 15% BAS boardroom stakers 5% BAB staking pool 5% Strategic pairs 5% CDF/Vision fund */ IPoolStoreGov(target).setPool(boardroom, ETH.mul(15)); IPoolStoreGov(target).setPool(bondroom, ETH.mul(5)); IPoolStoreGov(target).setPool(strategicPair, ETH.mul(5)); IPoolStoreGov(target).setPool(communityFund, ETH.mul(5)); lastUpdated = FeedStatus.BelowPeg; } // above peg if (lastUpdated != FeedStatus.AbovePeg && price >= ETH) { /* 5% BAS boardroom stakers 0% BAB staking pool 10% Strategic pairs 15% the CDF/Vision fund */ IPoolStoreGov(target).setPool(boardroom, ETH.mul(5)); IPoolStoreGov(target).setPool(bondroom, 0); IPoolStoreGov(target).setPool(strategicPair, ETH.mul(10)); IPoolStoreGov(target).setPool(communityFund, ETH.mul(15)); lastUpdated = FeedStatus.AbovePeg; } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @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) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @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) { 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, reverting 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) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting 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) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * 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); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * 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); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * 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; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol'; import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol'; import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/SafeERC20.sol'; import {Operator} from '../access/Operator.sol'; interface IPoolStore { /* ================= EVENTS ================= */ event Deposit( address indexed operator, address indexed owner, uint256 indexed pid, uint256 amount ); event Withdraw( address indexed operator, address indexed owner, uint256 indexed pid, uint256 amount ); /* ================= CALLS ================= */ // common function totalWeight() external view returns (uint256); function poolLength() external view returns (uint256); // index function poolIdsOf(address _token) external view returns (uint256[] memory); // pool info function nameOf(uint256 _pid) external view returns (string memory); function tokenOf(uint256 _pid) external view returns (address); function weightOf(uint256 _pid) external view returns (uint256); function totalSupply(uint256 _pid) external view returns (uint256); function balanceOf(uint256 _pid, address _owner) external view returns (uint256); /* ================= TXNS ================= */ function deposit( uint256 _pid, address _owner, uint256 _amount ) external; function withdraw( uint256 _pid, address _owner, uint256 _amount ) external; function emergencyWithdraw(uint256 _pid) external; } interface IPoolStoreGov { /* ================= EVENTS ================= */ event EmergencyReported(address indexed reporter); event EmergencyResolved(address indexed resolver); event WeightFeederChanged( address indexed operator, address indexed oldFeeder, address indexed newFeeder ); event PoolAdded( address indexed operator, uint256 indexed pid, string name, address token, uint256 weight ); event PoolWeightChanged( address indexed operator, uint256 indexed pid, uint256 from, uint256 to ); event PoolNameChanged( address indexed operator, uint256 indexed pid, string from, string to ); /* ================= TXNS ================= */ // emergency function reportEmergency() external; function resolveEmergency() external; // feeder function setWeightFeeder(address _newFeeder) external; // pool setting function addPool( string memory _name, IERC20 _token, uint256 _weight ) external; function setPool(uint256 _pid, uint256 _weight) external; function setPool(uint256 _pid, string memory _name) external; } contract PoolStore is IPoolStore, IPoolStoreGov, Operator { using SafeMath for uint256; using SafeERC20 for IERC20; /* ================= DATA STRUCTURE ================= */ struct Pool { string name; IERC20 token; uint256 weight; uint256 totalSupply; } /* ================= STATES ================= */ uint256 public override totalWeight = 0; Pool[] public pools; mapping(uint256 => mapping(address => uint256)) balances; mapping(address => uint256[]) public indexByToken; bool public emergency = false; address public weightFeeder; constructor() Operator() { weightFeeder = _msgSender(); } /* ================= GOV - OWNER ONLY ================= */ /** * @dev CAUTION: DO NOT USE IN NORMAL SITUATION * @notice Enable emergency withdraw */ function reportEmergency() public override onlyOwner { emergency = true; emit EmergencyReported(_msgSender()); } /** * @dev CAUTION: DO NOT USE IN NORMAL SITUATION * @notice Disable emergency withdraw */ function resolveEmergency() public override onlyOwner { emergency = false; emit EmergencyResolved(_msgSender()); } /* * @param _newFeeder weight feeder address to change */ function setWeightFeeder(address _newFeeder) public override onlyOwner { address oldFeeder = weightFeeder; weightFeeder = _newFeeder; emit WeightFeederChanged(_msgSender(), oldFeeder, _newFeeder); } /** * @param _token pool token * @param _weight pool weight */ function addPool( string memory _name, IERC20 _token, uint256 _weight ) public override onlyOwner { totalWeight = totalWeight.add(_weight); uint256 index = pools.length; indexByToken[address(_token)].push(index); pools.push( Pool({name: _name, token: _token, weight: _weight, totalSupply: 0}) ); emit PoolAdded(_msgSender(), index, _name, address(_token), _weight); } /** * @param _pid pool id * @param _weight target pool weight */ function setPool(uint256 _pid, uint256 _weight) public override onlyWeightFeeder checkPoolId(_pid) { Pool memory pool = pools[_pid]; uint256 oldWeight = pool.weight; totalWeight = totalWeight.add(_weight).sub(pool.weight); pool.weight = _weight; pools[_pid] = pool; emit PoolWeightChanged(_msgSender(), _pid, oldWeight, _weight); } /** * @param _pid pool id * @param _name name of pool */ function setPool(uint256 _pid, string memory _name) public override checkPoolId(_pid) onlyOwner { string memory oldName = pools[_pid].name; pools[_pid].name = _name; emit PoolNameChanged(_msgSender(), _pid, oldName, _name); } /* ================= MODIFIER ================= */ modifier onlyWeightFeeder { require(_msgSender() == weightFeeder, 'PoolStore: unauthorized'); _; } modifier checkPoolId(uint256 _pid) { require(_pid <= pools.length, 'PoolStore: invalid pid'); _; } /* ================= CALLS - ANYONE ================= */ /** * @return total pool length */ function poolLength() public view override returns (uint256) { return pools.length; } /** * @param _token pool token address * @return pool id */ function poolIdsOf(address _token) public view override returns (uint256[] memory) { return indexByToken[_token]; } /** * @param _pid pool id * @return name of pool */ function nameOf(uint256 _pid) public view override checkPoolId(_pid) returns (string memory) { return pools[_pid].name; } /** * @param _pid pool id * @return pool token */ function tokenOf(uint256 _pid) public view override checkPoolId(_pid) returns (address) { return address(pools[_pid].token); } /** * @param _pid pool id * @return pool weight */ function weightOf(uint256 _pid) public view override checkPoolId(_pid) returns (uint256) { return pools[_pid].weight; } /** * @param _pid pool id * @return total staked token amount */ function totalSupply(uint256 _pid) public view override checkPoolId(_pid) returns (uint256) { return pools[_pid].totalSupply; } /** * @param _pid pool id * @param _sender staker address * @return staked amount of user */ function balanceOf(uint256 _pid, address _sender) public view override checkPoolId(_pid) returns (uint256) { return balances[_pid][_sender]; } /* ================= TXNS - OPERATOR ONLY ================= */ /** * @param _pid pool id * @param _owner stake address * @param _amount stake amount */ function deposit( uint256 _pid, address _owner, uint256 _amount ) public override checkPoolId(_pid) onlyOperator { pools[_pid].totalSupply = pools[_pid].totalSupply.add(_amount); balances[_pid][_owner] = balances[_pid][_owner].add(_amount); IERC20(tokenOf(_pid)).safeTransferFrom( _msgSender(), address(this), _amount ); emit Deposit(_msgSender(), _owner, _pid, _amount); } function _withdraw( uint256 _pid, address _owner, uint256 _amount ) internal { pools[_pid].totalSupply = pools[_pid].totalSupply.sub(_amount); balances[_pid][_owner] = balances[_pid][_owner].sub(_amount); IERC20(tokenOf(_pid)).safeTransfer(_msgSender(), _amount); emit Withdraw(_msgSender(), _owner, _pid, _amount); } /** * @param _pid pool id * @param _owner stake address * @param _amount stake amount */ function withdraw( uint256 _pid, address _owner, uint256 _amount ) public override checkPoolId(_pid) onlyOperator { _withdraw(_pid, _owner, _amount); } /** * @notice Anyone can withdraw its balance even if is not the operator * @param _pid pool id */ function emergencyWithdraw(uint256 _pid) public override checkPoolId(_pid) { require(emergency, 'PoolStore: not in emergency'); _withdraw(_pid, msg.sender, balanceOf(_pid, _msgSender())); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; import {Context, Ownable} from '@openzeppelin/contracts/access/Ownable.sol'; abstract contract Operator is Context, Ownable { address private _operator; event OperatorTransferred( address indexed previousOperator, address indexed newOperator ); constructor() { _operator = _msgSender(); emit OperatorTransferred(address(0), _operator); } function operator() public view returns (address) { return _operator; } modifier onlyOperator() { require( _operator == _msgSender(), 'operator: caller is not the operator' ); _; } function isOperator() public view returns (bool) { return _msgSender() == _operator; } function transferOperator(address newOperator_) public onlyOwner { _transferOperator(newOperator_); } function _transferOperator(address newOperator_) internal { require( newOperator_ != address(0), 'operator: zero address given for new operator' ); emit OperatorTransferred(address(0), newOperator_); _operator = newOperator_; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol'; import {Babylonian} from '../lib/Babylonian.sol'; import {FixedPoint} from '../lib/FixedPoint.sol'; import {UniswapV2Library} from '../lib/UniswapV2Library.sol'; import {UniswapV2OracleLibrary} from '../lib/UniswapV2OracleLibrary.sol'; import {Epoch} from '../utils/Epoch.sol'; import {IUniswapV2Pair} from '../interfaces/IUniswapV2Pair.sol'; import {IUniswapV2Factory} from '../interfaces/IUniswapV2Factory.sol'; interface IOracle { function update() external; function consult(address token, uint256 amountIn) external view returns (uint256 amountOut); // function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestamp); } // fixed window oracle that recomputes the average price for the entire period once every period // note that the price average is only guaranteed to be over at least 1 period, but may be over a longer period contract Oracle is Epoch { using FixedPoint for *; using SafeMath for uint256; /* ========== STATE VARIABLES ========== */ // uniswap address public token0; address public token1; IUniswapV2Pair public pair; // oracle uint32 public blockTimestampLast; uint256 public price0CumulativeLast; uint256 public price1CumulativeLast; FixedPoint.uq112x112 public price0Average; FixedPoint.uq112x112 public price1Average; /* ========== CONSTRUCTOR ========== */ constructor( address _factory, address _tokenA, address _tokenB, uint256 _period, uint256 _startTime ) Epoch(_period, _startTime, 0) { IUniswapV2Pair _pair = IUniswapV2Pair( UniswapV2Library.pairFor(_factory, _tokenA, _tokenB) ); pair = _pair; token0 = _pair.token0(); token1 = _pair.token1(); price0CumulativeLast = _pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0) price1CumulativeLast = _pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1) uint112 reserve0; uint112 reserve1; (reserve0, reserve1, blockTimestampLast) = _pair.getReserves(); require(reserve0 != 0 && reserve1 != 0, 'Oracle: NO_RESERVES'); // ensure that there's liquidity in the pair } /* ========== MUTABLE FUNCTIONS ========== */ /** @dev Updates 1-day EMA price from Uniswap. */ function update() external checkEpoch { ( uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp ) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair)); uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired if (timeElapsed == 0) { // prevent divided by zero return; } // overflow is desired, casting never truncates // cumulative price is in (uq112x112 price * seconds) units so we simply wrap it after division by time elapsed price0Average = FixedPoint.uq112x112( uint224((price0Cumulative - price0CumulativeLast) / timeElapsed) ); price1Average = FixedPoint.uq112x112( uint224((price1Cumulative - price1CumulativeLast) / timeElapsed) ); price0CumulativeLast = price0Cumulative; price1CumulativeLast = price1Cumulative; blockTimestampLast = blockTimestamp; emit Updated(price0Cumulative, price1Cumulative); } // note this will always return 0 before update has been called successfully for the first time. function consult(address token, uint256 amountIn) external view returns (uint144 amountOut) { if (token == token0) { amountOut = price0Average.mul(amountIn).decode144(); } else { require(token == token1, 'Oracle: INVALID_TOKEN'); amountOut = price1Average.mul(amountIn).decode144(); } } // collaboration of update / consult function expectedPrice(address token, uint256 amountIn) external view returns (uint224 amountOut) { ( uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp ) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair)); uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired FixedPoint.uq112x112 memory avg0 = FixedPoint.uq112x112( uint224((price0Cumulative - price0CumulativeLast) / timeElapsed) ); FixedPoint.uq112x112 memory avg1 = FixedPoint.uq112x112( uint224((price1Cumulative - price1CumulativeLast) / timeElapsed) ); if (token == token0) { amountOut = avg0.mul(amountIn).decode144(); } else { require(token == token1, 'Oracle: INVALID_TOKEN'); amountOut = avg1.mul(amountIn).decode144(); } return amountOut; } function pairFor( address factory, address tokenA, address tokenB ) external pure returns (address lpt) { return UniswapV2Library.pairFor(factory, tokenA, tokenB); } event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast); }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; interface ICurve { function minSupply() external view returns (uint256); function maxSupply() external view returns (uint256); function minCeiling() external view returns (uint256); function maxCeiling() external view returns (uint256); function calcCeiling(uint256 _supply) external view returns (uint256); } abstract contract Curve is ICurve { /* ========== EVENTS ========== */ event MinSupplyChanged( address indexed operator, uint256 _old, uint256 _new ); event MaxSupplyChanged( address indexed operator, uint256 _old, uint256 _new ); event MinCeilingChanged( address indexed operator, uint256 _old, uint256 _new ); event MaxCeilingChanged( address indexed operator, uint256 _old, uint256 _new ); /* ========== STATE VARIABLES ========== */ uint256 public override minSupply; uint256 public override maxSupply; uint256 public override minCeiling; uint256 public override maxCeiling; /* ========== GOVERNANCE ========== */ function setMinSupply(uint256 _newMinSupply) public virtual { uint256 oldMinSupply = minSupply; minSupply = _newMinSupply; emit MinSupplyChanged(msg.sender, oldMinSupply, _newMinSupply); } function setMaxSupply(uint256 _newMaxSupply) public virtual { uint256 oldMaxSupply = maxSupply; maxSupply = _newMaxSupply; emit MaxSupplyChanged(msg.sender, oldMaxSupply, _newMaxSupply); } function setMinCeiling(uint256 _newMinCeiling) public virtual { uint256 oldMinCeiling = _newMinCeiling; minCeiling = _newMinCeiling; emit MinCeilingChanged(msg.sender, oldMinCeiling, _newMinCeiling); } function setMaxCeiling(uint256 _newMaxCeiling) public virtual { uint256 oldMaxCeiling = _newMaxCeiling; maxCeiling = _newMaxCeiling; emit MaxCeilingChanged(msg.sender, oldMaxCeiling, _newMaxCeiling); } function calcCeiling(uint256 _supply) external view virtual override returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.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"); } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; /** * @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 on 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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { 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); } } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; library Babylonian { function sqrt(uint256 y) internal pure returns (uint256 z) { if (y > 3) { z = y; uint256 x = y / 2 + 1; while (x < z) { z = x; x = (y / x + x) / 2; } } else if (y != 0) { z = 1; } // else z = 0 } }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; import {Babylonian} from './Babylonian.sol'; // 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 { uint256 _x; } uint8 private constant RESOLUTION = 112; uint256 private constant Q112 = uint256(1) << RESOLUTION; uint256 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, uint256 y) internal pure returns (uq144x112 memory) { uint256 z; require( y == 0 || (z = uint256(self._x) * y) / y == uint256(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)); } // square root of a UQ112x112 function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) { return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56)); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol'; import {IUniswapV2Pair} from '../interfaces/IUniswapV2Pair.sol'; library UniswapV2Library { using SafeMath for uint256; // 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'); } // 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 = address( uint256( keccak256( abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash ) ) ) ); } // fetches and sorts the reserves for a pair function getReserves( address factory, address tokenA, address tokenB ) internal view returns (uint256 reserveA, uint256 reserveB) { (address token0, ) = sortTokens(tokenA, tokenB); (uint256 reserve0, uint256 reserve1, ) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves(); (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0); } // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset function quote( uint256 amountA, uint256 reserveA, uint256 reserveB ) internal pure returns (uint256 amountB) { require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT'); require( reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY' ); amountB = amountA.mul(reserveB) / reserveA; } // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset function getAmountOut( uint256 amountIn, uint256 reserveIn, uint256 reserveOut ) internal pure returns (uint256 amountOut) { require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT'); require( reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY' ); uint256 amountInWithFee = amountIn.mul(997); uint256 numerator = amountInWithFee.mul(reserveOut); uint256 denominator = reserveIn.mul(1000).add(amountInWithFee); amountOut = numerator / denominator; } // given an output amount of an asset and pair reserves, returns a required input amount of the other asset function getAmountIn( uint256 amountOut, uint256 reserveIn, uint256 reserveOut ) internal pure returns (uint256 amountIn) { require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT'); require( reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY' ); uint256 numerator = reserveIn.mul(amountOut).mul(1000); uint256 denominator = reserveOut.sub(amountOut).mul(997); amountIn = (numerator / denominator).add(1); } // performs chained getAmountOut calculations on any number of pairs function getAmountsOut( address factory, uint256 amountIn, address[] memory path ) internal view returns (uint256[] memory amounts) { require(path.length >= 2, 'UniswapV2Library: INVALID_PATH'); amounts = new uint256[](path.length); amounts[0] = amountIn; for (uint256 i; i < path.length - 1; i++) { (uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i], path[i + 1]); amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut); } } // performs chained getAmountIn calculations on any number of pairs function getAmountsIn( address factory, uint256 amountOut, address[] memory path ) internal view returns (uint256[] memory amounts) { require(path.length >= 2, 'UniswapV2Library: INVALID_PATH'); amounts = new uint256[](path.length); amounts[amounts.length - 1] = amountOut; for (uint256 i = path.length - 1; i > 0; i--) { (uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i - 1], path[i]); amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut); } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import {FixedPoint} from './FixedPoint.sol'; import {IUniswapV2Pair} from '../interfaces/IUniswapV2Pair.sol'; // 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 price 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(); 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; } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; import '@openzeppelin/contracts/math/Math.sol'; import '@openzeppelin/contracts/math/SafeMath.sol'; import '../access/Operator.sol'; contract Epoch is Operator { using SafeMath for uint256; uint256 private period; uint256 private startTime; uint256 private lastExecutedAt; /* ========== CONSTRUCTOR ========== */ constructor( uint256 _period, uint256 _startTime, uint256 _startEpoch ) { require(_startTime > block.timestamp, 'Epoch: invalid start time'); period = _period; startTime = _startTime; lastExecutedAt = startTime.add(_startEpoch.mul(period)); } /* ========== Modifier ========== */ modifier checkStartTime { require(block.timestamp >= startTime, 'Epoch: not started yet'); _; } modifier checkEpoch { require(block.timestamp > startTime, 'Epoch: not started yet'); require(callable(), 'Epoch: not allowed'); _; lastExecutedAt = block.timestamp; } /* ========== VIEW FUNCTIONS ========== */ function callable() public view returns (bool) { return getCurrentEpoch() >= getNextEpoch(); } // epoch function getLastEpoch() public view returns (uint256) { return lastExecutedAt.sub(startTime).div(period); } function getCurrentEpoch() public view returns (uint256) { return Math.max(startTime, block.timestamp).sub(startTime).div(period); } function getNextEpoch() public view returns (uint256) { if (startTime == lastExecutedAt) { return getLastEpoch(); } return getLastEpoch().add(1); } function nextEpochPoint() public view returns (uint256) { return startTime.add(getNextEpoch().mul(period)); } // params function getPeriod() public view returns (uint256) { return period; } function getStartTime() public view returns (uint256) { return startTime; } /* ========== GOVERNANCE ========== */ function setPeriod(uint256 _period) external onlyOperator { period = _period; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; interface IUniswapV2Pair { event Approval( address indexed owner, address indexed spender, uint256 value ); event Transfer(address indexed from, address indexed to, uint256 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 (uint256); function balanceOf(address owner) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 value) external returns (bool); function transfer(address to, uint256 value) external returns (bool); function transferFrom( address from, address to, uint256 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 (uint256); function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; event Mint(address indexed sender, uint256 amount0, uint256 amount1); event Burn( address indexed sender, uint256 amount0, uint256 amount1, address indexed to ); event Swap( address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint256); 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 (uint256); function price1CumulativeLast() external view returns (uint256); function kLast() external view returns (uint256); function mint(address to) external returns (uint256 liquidity); function burn(address to) external returns (uint256 amount0, uint256 amount1); function swap( uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data ) external; function skim(address to) external; function sync() external; function initialize(address, address) external; }
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.8.0; interface IUniswapV2Factory { event PairCreated( address indexed token0, address indexed token1, address pair, uint256 ); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint256) external view returns (address pair); function allPairsLength() external view returns (uint256); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function createPair(address tokenA, address tokenB) external returns (address pair); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOperator","type":"address"},{"indexed":true,"internalType":"address","name":"newOperator","type":"address"}],"name":"OperatorTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"ETH","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"boardroom","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bondroom","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cashLP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cashVault","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"communityFund","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cashLP","type":"uint256"},{"internalType":"uint256","name":"_cashVault","type":"uint256"},{"internalType":"uint256","name":"_shareLP","type":"uint256"},{"internalType":"uint256","name":"_boardroom","type":"uint256"},{"internalType":"uint256","name":"_bondroom","type":"uint256"},{"internalType":"uint256","name":"_strategicPair","type":"uint256"},{"internalType":"uint256","name":"_communityFund","type":"uint256"}],"name":"configure","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"curve","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdated","outputs":[{"internalType":"enum WeightFeeder.FeedStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oracle","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newCurve","type":"address"}],"name":"setCurve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOracle","type":"address"}],"name":"setOracle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newTarget","type":"address"}],"name":"setTarget","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newToken","type":"address"}],"name":"setToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shareLP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"strategicPair","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"target","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOperator_","type":"address"}],"name":"transferOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.