Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IStakePoolCreator
•    - function version()
•    - function create()
•    - function initialize(
• interface IValueLiquidRouter
•    - function factory()
•    - function controller()
•    - function formula()
•    - function WETH()
•    - function addLiquidity(
•    - function addLiquidityETH(
•    - function swapExactTokensForTokens(
•    - function swapTokensForExactTokens(
•    - function swapExactETHForTokens(
•    - function swapTokensForExactETH(
•    - function swapExactTokensForETH(
•    - function swapETHForExactTokens(
•    - function swapExactTokensForTokensSupp ...
•    - function swapExactETHForTokensSupport ...
•    - function swapExactTokensForETHSupport ...
•    - function addStakeLiquidity(
•    - function addStakeLiquidityETH(
•    - function multihopBatchSwapExactIn(
•    - function multihopBatchSwapExactOut(
•    - function createPair(
•    - function createPairETH(
• interface IValueLiquidFactory
•    - function feeTo()
•    - function formula()
•    - function protocolFee()
•    - function feeToSetter()
•    - function getPair(
•    - function allPairs(uint256)
•    - function isPair(address)
•    - function allPairsLength()
•    - function createPair(
•    - function getWeightsAndSwapFee(address ...
•    - function setFeeTo(address)
•    - function setFeeToSetter(address)
•    - function setProtocolFee(uint256)
• library TransferHelper
•    - function safeApprove(
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeTransferETH(address to, ...
• interface IValueLiquidPair
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint256 ...
•    - function transferFrom(
•    - function DOMAIN_SEPARATOR()
•    - function PERMIT_TYPEHASH()
•    - function nonces(address owner)
•    - function permit(
•    - function MINIMUM_LIQUIDITY()
•    - function factory()
•    - function token0()
•    - function token1()
•    - function getReserves()
•    - function getCollectedFees()
•    - function getTokenWeights()
•    - function getSwapFee()
•    - function price0CumulativeLast()
•    - function price1CumulativeLast()
•    - function mint(address to)
•    - function burn(address to)
•    - function swap(
•    - function skim(address to)
•    - function sync()
•    - function initialize(
• library SafeMath
•    - function add(uint256 x, uint256 y)
•    - function sub(uint256 x, uint256 y)
•    - function mul(uint256 x, uint256 y)
•    - function div(uint256 a, uint256 b)
•  contract TimeLock
•    - function initialize(address _admin, u ...
•    - function setDelay(uint256 _delay)
•    - function acceptAdmin()
•    - function setPendingAdmin(address _pen ...
•    - function queueTransaction(
•    - function cancelTransaction(
•    - function executeTransaction(
•    - function getBlockTimestamp()
• interface IEpochController
•    - function epoch()
•    - function nextEpochPoint()
•    - function nextEpochLength()
•    - function nextEpochAllocatedReward(add ...
• interface IStakePoolEpochReward
•    - function version()
•    - function pair()
•    - function allowRecoverRewardToken(addr ...
•    - function epoch()
•    - function nextEpochPoint()
•    - function nextEpochLength()
•    - function nextEpochAllocatedReward()
•    - function earned(address _account)
•    - function unlockWithdrawEpoch(address ...
•    - function unlockRewardEpoch(address _a ...
•    - function stake(uint256)
•    - function stakeFor(address _account)
•    - function withdraw(uint256)
•    - function claimReward()
•    - function emergencyWithdraw()
•    - function setEpochController(address)
•    - function setLockUp(uint256 _withdrawL ...
•    - function allocateReward(uint256 _amou ...
•    - function removeLiquidity(
•    - function removeLiquidityETH(
•    - function removeLiquidityETHSupporting ...
• interface IValueLiquidProvider
•    - function factory()
•    - function controller()
•    - function formula()
•    - function WETH()
•    - function removeLiquidity(
•    - function removeLiquidityETH(
•    - function removeLiquidityWithPermit(
•    - function removeLiquidityETHWithPermit ...
•    - function removeLiquidityETHSupporting ...
•    - function removeLiquidityETHWithPermit ...
•    - function stake(
•    - function stakeWithPermit(
• interface IStakePoolController
•    - function allStakePools(uint256)
•    - function isStakePool(address contract ...
•    - function isStakePoolVerifier(address ...
•    - function isWhitelistStakingFor(addres ...
•    - function isWhitelistStakePool(address ...
•    - function setStakePoolVerifier(address ...
•    - function setWhitelistStakingFor(addre ...
•    - function setWhitelistStakePool(addres ...
•    - function addStakePoolCreator(address ...
•    - function isWhitelistRewardRebaser(add ...
•    - function isAllowEmergencyWithdrawStak ...
•    - function setWhitelistRewardRebaser(ad ...
•    - function isWhitelistRewardMultiplier( ...
•    - function setAllowEmergencyWithdrawSta ...
•    - function setWhitelistRewardMultiplier ...
•    - function setEnableWhitelistRewardReba ...
•    - function setEnableWhitelistRewardMult ...
•    - function allStakePoolsLength()
•    - function create(
•    - function createPair(
•    - function setGovernance(address)
•    - function setFeeCollector(address _add ...
•    - function setFeeToken(address _token)
•    - function setFeeAmount(uint256 _token)
• interface IStakePoolRewardRebaser
•    - function getRebaseAmount(address rewa ...
• interface IStakePoolRewardMultiplier
•    - function getRewardMultiplier(
• interface IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint256 ...
•    - function transferFrom(
• interface IStakePoolRewardFund
•    - function initialize(address _stakePoo ...
•    - function safeTransfer(
•  contract StakePoolEpochReward is I ... *
•    - function initialize(
•    - function setEpochController(address _ ...
•    - function setLockUp(uint256 _withdrawL ...
•    - function allocateReward(uint256 _amou ...
•    - function allowRecoverRewardToken(addr ...
•    - function epoch()
•    - function nextEpochPoint()
•    - function nextEpochLength()
•    - function nextEpochAllocatedReward()
•    - function latestSnapshotIndex()
•    - function getLatestSnapshot()
•    - function getLastSnapshotIndexOf(addre ...
•    - function getLastSnapshotOf(address _a ...
•    - function rewardPerShare()
•    - function earned(address _account)
•    - function canWithdraw(address _account ...
•    - function canClaimReward(address _acco ...
•    - function unlockWithdrawEpoch(address ...
•    - function unlockRewardEpoch(address _a ...
•    - function stake(uint256 _amount)
•    - function stakeFor(address _account)
•    - function _stakeFor(address _account)
•    - function removeStakeInternal(uint256 ...
•    - function withdraw(uint256 _amount)
•    - function exit()
•    - function _claimReward(bool _lockCheck ...
•    - function claimReward()
•    - function emergencyWithdraw()
•    - function removeLiquidity(
•    - function removeLiquidityETH(
•    - function removeLiquidityETHSupporting ...
•  contract StakePoolEpochRewardCreat ... *
•    - function create()
•    - function initialize(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-01-28
*/

// SPDX-License-Identifier: SEE LICENSE IN LICENSE

pragma abicoder v2;
pragma solidity >=0.7.6;

interface IStakePoolCreator {
    function version() external returns (uint256);

    function create() external returns (address);

    function initialize(
        address poolAddress,
        address pair,
        address rewardToken,
        address timelock,
        address stakePoolRewardFund,
        bytes calldata data
    ) external;
}

interface IValueLiquidRouter {
    struct Swap {
        address pool;
        address tokenIn;
        address tokenOut;
        uint256 swapAmount; // tokenInAmount / tokenOutAmount
        uint256 limitReturnAmount; // minAmountOut / maxAmountIn
        uint256 maxPrice;
        bool isBPool;
    }

    function factory() external view returns (address);

    function controller() external view returns (address);

    function formula() external view returns (address);

    function WETH() external view returns (address);

    function addLiquidity(
        address pair,
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address pair,
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function swapExactTokensForTokens(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        address tokenIn,
        address tokenOut,
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        address tokenOut,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        address tokenIn,
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        address tokenIn,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        address tokenOut,
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external payable returns (uint256[] memory amounts);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        address tokenOut,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        address tokenIn,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline,
        uint8 flag
    ) external;

    function addStakeLiquidity(
        address stakePool,
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addStakeLiquidityETH(
        address stakePool,
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function multihopBatchSwapExactIn(
        Swap[][] memory swapSequences,
        address tokenIn,
        address tokenOut,
        uint256 totalAmountIn,
        uint256 minTotalAmountOut,
        uint256 deadline,
        uint8 flag
    ) external payable returns (uint256 totalAmountOut);

    function multihopBatchSwapExactOut(
        Swap[][] memory swapSequences,
        address tokenIn,
        address tokenOut,
        uint256 maxTotalAmountIn,
        uint256 deadline,
        uint8 flag
    ) external payable returns (uint256 totalAmountIn);

    function createPair(
        address tokenA,
        address tokenB,
        uint256 amountA,
        uint256 amountB,
        uint32 tokenWeightA,
        uint32 swapFee,
        address to,
        uint8 flag
    ) external returns (uint256 liquidity);

    function createPairETH(
        address token,
        uint256 amountToken,
        uint32 tokenWeight,
        uint32 swapFee,
        address to,
        uint8 flag
    ) external payable returns (uint256 liquidity);
}

interface IValueLiquidFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint32 tokenWeight0, uint32 swapFee, uint256);

    function feeTo() external view returns (address);

    function formula() external view returns (address);

    function protocolFee() external view returns (uint256);

    function feeToSetter() external view returns (address);

    function getPair(
        address tokenA,
        address tokenB,
        uint32 tokenWeightA,
        uint32 swapFee
    ) external view returns (address pair);

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

    function isPair(address) external view returns (bool);

    function allPairsLength() external view returns (uint256);

    function createPair(
        address tokenA,
        address tokenB,
        uint32 tokenWeightA,
        uint32 swapFee
    ) external returns (address pair);

    function getWeightsAndSwapFee(address pair)
        external
        view
        returns (
            uint32 tokenWeight0,
            uint32 tokenWeight1,
            uint32 swapFee
        );

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;

    function setProtocolFee(uint256) external;
}

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper: APPROVE_FAILED");
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper: TRANSFER_FAILED");
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper: TRANSFER_FROM_FAILED");
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, "TransferHelper: ETH_TRANSFER_FAILED");
    }
}

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

    function name() external view returns (string memory);

    function symbol() external view 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 PaidProtocolFee(uint112 collectedFee0, uint112 collectedFee1);
    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 getCollectedFees() external view returns (uint112 _collectedFee0, uint112 _collectedFee1);

    function getTokenWeights() external view returns (uint32 tokenWeight0, uint32 tokenWeight1);

    function getSwapFee() external view returns (uint32);

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() 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,
        uint32,
        uint32
    ) external;
}

// a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)
library SafeMath {
    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x + y) >= x, "ds-math-add-overflow");
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x - y) <= x, "ds-math-sub-underflow");
    }

    function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
        require(b > 0, "ds-math-division-by-zero");
        c = a / b;
    }
}

contract TimeLock {
    using SafeMath for uint256;
    event NewAdmin(address indexed newAdmin);
    event NewPendingAdmin(address indexed newPendingAdmin);
    event NewDelay(uint256 indexed newDelay);
    event CancelTransaction(bytes32 indexed txHash, address indexed target, uint256 value, string signature, bytes data, uint256 eta);
    event ExecuteTransaction(bytes32 indexed txHash, address indexed target, uint256 value, string signature, bytes data, uint256 eta);
    event QueueTransaction(bytes32 indexed txHash, address indexed target, uint256 value, string signature, bytes data, uint256 eta);

    uint256 public constant GRACE_PERIOD = 14 days;
    uint256 public constant MINIMUM_DELAY = 1 days;
    uint256 public constant MAXIMUM_DELAY = 30 days;
    bool private _initialized;
    address public admin;
    address public pendingAdmin;
    uint256 public delay;
    bool public admin_initialized;
    mapping(bytes32 => bool) public queuedTransactions;

    constructor() {
        admin_initialized = false;
        _initialized = false;
    }

    function initialize(address _admin, uint256 _delay) public {
        require(_initialized == false, "Timelock::constructor: Initialized must be false.");
        require(_delay >= MINIMUM_DELAY, "Timelock::setDelay: Delay must exceed minimum delay.");
        require(_delay <= MAXIMUM_DELAY, "Timelock::setDelay: Delay must not exceed maximum delay.");
        delay = _delay;
        admin = _admin;
        _initialized = true;
        emit NewAdmin(admin);
        emit NewDelay(delay);
    }

    receive() external payable {}

    function setDelay(uint256 _delay) public {
        require(msg.sender == address(this), "Timelock::setDelay: Call must come from Timelock.");
        require(_delay >= MINIMUM_DELAY, "Timelock::setDelay: Delay must exceed minimum delay.");
        require(_delay <= MAXIMUM_DELAY, "Timelock::setDelay: Delay must not exceed maximum delay.");
        delay = _delay;
        emit NewDelay(delay);
    }

    function acceptAdmin() public {
        require(msg.sender == pendingAdmin, "Timelock::acceptAdmin: Call must come from pendingAdmin.");
        admin = msg.sender;
        pendingAdmin = address(0);
        emit NewAdmin(admin);
    }

    function setPendingAdmin(address _pendingAdmin) public {
        // allows one time setting of admin for deployment purposes
        if (admin_initialized) {
            require(msg.sender == address(this), "Timelock::setPendingAdmin: Call must come from Timelock.");
        } else {
            require(msg.sender == admin, "Timelock::setPendingAdmin: First call must come from admin.");
            admin_initialized = true;
        }
        pendingAdmin = _pendingAdmin;

        emit NewPendingAdmin(pendingAdmin);
    }

    function queueTransaction(
        address target,
        uint256 value,
        string memory signature,
        bytes memory data,
        uint256 eta
    ) public returns (bytes32) {
        require(msg.sender == admin, "Timelock::queueTransaction: Call must come from admin.");
        require(eta >= getBlockTimestamp().add(delay), "Timelock::queueTransaction: Estimated execution block must satisfy delay.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        queuedTransactions[txHash] = true;

        emit QueueTransaction(txHash, target, value, signature, data, eta);
        return txHash;
    }

    function cancelTransaction(
        address target,
        uint256 value,
        string memory signature,
        bytes memory data,
        uint256 eta
    ) public {
        require(msg.sender == admin, "Timelock::cancelTransaction: Call must come from admin.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        queuedTransactions[txHash] = false;

        emit CancelTransaction(txHash, target, value, signature, data, eta);
    }

    function executeTransaction(
        address target,
        uint256 value,
        string memory signature,
        bytes memory data,
        uint256 eta
    ) public payable returns (bytes memory) {
        require(msg.sender == admin, "Timelock::executeTransaction: Call must come from admin.");

        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
        require(queuedTransactions[txHash], "Timelock::executeTransaction: Transaction hasn't been queued.");
        require(getBlockTimestamp() >= eta, "Timelock::executeTransaction: Transaction hasn't surpassed time lock.");
        require(getBlockTimestamp() <= eta.add(GRACE_PERIOD), "Timelock::executeTransaction: Transaction is stale.");

        queuedTransactions[txHash] = false;

        bytes memory callData;

        if (bytes(signature).length == 0) {
            callData = data;
        } else {
            callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
        }

        // solium-disable-next-line security/no-call-value
        (bool success, bytes memory returnData) = target.call{value: value}(callData);
        require(success, "Timelock::executeTransaction: Transaction execution reverted.");

        emit ExecuteTransaction(txHash, target, value, signature, data, eta);

        return returnData;
    }

    function getBlockTimestamp() internal view returns (uint256) {
        return block.timestamp;
    }
}

interface IEpochController {
    function epoch() external view returns (uint256);

    function nextEpochPoint() external view returns (uint256);

    function nextEpochLength() external view returns (uint256);

    function nextEpochAllocatedReward(address _pool) external view returns (uint256);
}

interface IStakePoolEpochReward {
    event AllocateReward(uint256 blocktime, uint256 amount);
    event Deposit(address indexed account, uint256 amount);
    event PayRewardPool(
        uint256 indexed poolId,
        address indexed rewardToken,
        address indexed account,
        uint256 pendingReward,
        uint256 rebaseAmount,
        uint256 paidReward
    );
    event Withdraw(address indexed account, uint256 amount);

    function version() external returns (uint256);

    function pair() external returns (address);

    function allowRecoverRewardToken(address _token) external view returns (bool);

    function epoch() external view returns (uint256);

    function nextEpochPoint() external view returns (uint256);

    function nextEpochLength() external view returns (uint256);

    function nextEpochAllocatedReward() external view returns (uint256);

    function earned(address _account) external view returns (uint256);

    function unlockWithdrawEpoch(address _account) external view returns (uint256);

    function unlockRewardEpoch(address _account) external view returns (uint256);

    function stake(uint256) external;

    function stakeFor(address _account) external;

    function withdraw(uint256) external;

    function claimReward() external;

    function emergencyWithdraw() external;

    function setEpochController(address) external;

    function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external;

    function allocateReward(uint256 _amount) external;

    function removeLiquidity(
        address provider,
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address provider,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address provider,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);
}

interface IValueLiquidProvider {
    function factory() external view returns (address);

    function controller() external view returns (address);

    function formula() external view returns (address);

    function WETH() external view returns (address);

    function removeLiquidity(
        address pair,
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address pair,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityWithPermit(
        address pair,
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETHWithPermit(
        address pair,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address pair,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address pair,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountETH);

    function stake(
        address stakePool,
        uint256 amount,
        uint256 deadline
    ) external;

    function stakeWithPermit(
        address stakePool,
        uint256 amount,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

interface IStakePoolController {
    event MasterCreated(address indexed farm, address indexed pair, uint256 version, address timelock, address stakePoolRewardFund, uint256 totalStakePool);
    event SetWhitelistStakingFor(address indexed contractAddress, bool value);
    event SetWhitelistStakePool(address indexed contractAddress, int8 value);
    event SetStakePoolCreator(address indexed contractAddress, uint256 verion);
    event SetWhitelistRewardRebaser(address indexed contractAddress, bool value);
    event SetWhitelistRewardMultiplier(address indexed contractAddress, bool value);
    event SetStakePoolVerifier(address indexed contractAddress, bool value);
    event ChangeGovernance(address indexed governance);
    event SetFeeCollector(address indexed feeCollector);
    event SetFeeToken(address indexed token);
    event SetFeeAmount(uint256 indexed amount);

    function allStakePools(uint256) external view returns (address stakePool);

    function isStakePool(address contractAddress) external view returns (bool);

    function isStakePoolVerifier(address contractAddress) external view returns (bool);

    function isWhitelistStakingFor(address contractAddress) external view returns (bool);

    function isWhitelistStakePool(address contractAddress) external view returns (int8);

    function setStakePoolVerifier(address contractAddress, bool state) external;

    function setWhitelistStakingFor(address contractAddress, bool state) external;

    function setWhitelistStakePool(address contractAddress, int8 state) external;

    function addStakePoolCreator(address contractAddress) external;

    function isWhitelistRewardRebaser(address contractAddress) external view returns (bool);

    function isAllowEmergencyWithdrawStakePool(address _address) external view returns (bool);

    function setWhitelistRewardRebaser(address contractAddress, bool state) external;

    function isWhitelistRewardMultiplier(address contractAddress) external view returns (bool);

    function setAllowEmergencyWithdrawStakePool(address _address, bool state) external;

    function setWhitelistRewardMultiplier(address contractAddress, bool state) external;

    function setEnableWhitelistRewardRebaser(bool value) external;

    function setEnableWhitelistRewardMultiplier(bool value) external;

    function allStakePoolsLength() external view returns (uint256);

    function create(
        uint256 version,
        address pair,
        address rewardToken,
        uint256 rewardFundAmount,
        uint256 delayTimeLock,
        bytes calldata data,
        uint8 flag
    ) external returns (address);

    function createPair(
        uint256 version,
        address tokenA,
        address tokenB,
        uint32 tokenWeightA,
        uint32 swapFee,
        address rewardToken,
        uint256 rewardFundAmount,
        uint256 delayTimeLock,
        bytes calldata poolRewardInfo,
        uint8 flag
    ) external returns (address);

    function setGovernance(address) external;

    function setFeeCollector(address _address) external;

    function setFeeToken(address _token) external;

    function setFeeAmount(uint256 _token) external;
}

interface IStakePoolRewardRebaser {
    function getRebaseAmount(address rewardToken, uint256 baseAmount) external view returns (uint256);
}

interface IStakePoolRewardMultiplier {
    function getRewardMultiplier(
        uint256 _start,
        uint256 _end,
        uint256 _from,
        uint256 _to,
        uint256 _rewardPerBlock
    ) external view returns (uint256);
}

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

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view 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);
}

interface IStakePoolRewardFund {
    function initialize(address _stakePool, address _timelock) external;

    function safeTransfer(
        address _token,
        address _to,
        uint256 _value
    ) external;
}

// This implements BPool contract, and allows for generalized staking, yield farming (by epoch), and token distribution.
contract StakePoolEpochReward is IStakePoolEpochReward {
    using SafeMath for uint256;
    uint256 public override version;

    /* ========== DATA STRUCTURES ========== */

    struct UserInfo {
        uint256 amount;
        uint256 lastSnapshotIndex;
        uint256 rewardEarned;
        uint256 epochTimerStart;
    }

    struct Snapshot {
        uint256 time;
        uint256 rewardReceived;
        uint256 rewardPerShare;
    }

    /* ========== STATE VARIABLES ========== */

    address public epochController;
    address public rewardToken;

    uint256 public withdrawLockupEpochs;
    uint256 public rewardLockupEpochs;

    mapping(address => UserInfo) public userInfo;
    Snapshot[] public snapshotHistory;

    address public override pair;
    address public rewardFund;
    address public timelock;
    address public controller;

    uint256 public balance;
    uint256 private _unlocked = 1;
    bool private _initialized = false;

    constructor(address _controller, uint256 _version) {
        controller = _controller;
        timelock = msg.sender;
        version = _version;
        Snapshot memory genesisSnapshot = Snapshot({time: block.number, rewardReceived: 0, rewardPerShare: 0});
        snapshotHistory.push(genesisSnapshot);
    }

    modifier lock() {
        require(_unlocked == 1, "StakePoolEpochReward: LOCKED");
        _unlocked = 0;
        _;
        _unlocked = 1;
    }

    modifier onlyTimeLock() {
        require(msg.sender == timelock, "StakePoolEpochReward: !timelock");
        _;
    }

    modifier onlyEpochController() {
        require(msg.sender == epochController, "StakePoolEpochReward: !epochController");
        _;
    }

    modifier updateReward(address _account) {
        if (_account != address(0)) {
            UserInfo storage user = userInfo[_account];
            user.rewardEarned = earned(_account);
            user.lastSnapshotIndex = latestSnapshotIndex();
        }
        _;
    }

    // called once by the factory at time of deployment
    function initialize(
        address _pair,
        address _rewardFund,
        address _timelock,
        address _epochController,
        address _rewardToken,
        uint256 _withdrawLockupEpochs,
        uint256 _rewardLockupEpochs
    ) external {
        require(_initialized == false, "StakePoolEpochReward: Initialize must be false.");
        pair = _pair;
        rewardFund = _rewardFund;
        timelock = _timelock;
        withdrawLockupEpochs = _withdrawLockupEpochs;
        rewardLockupEpochs = _rewardLockupEpochs;
        epochController = _epochController;
        rewardToken = _rewardToken;
        _initialized = true;
    }

    /* ========== GOVERNANCE ========== */

    function setEpochController(address _epochController) external override lock onlyTimeLock {
        epochController = _epochController;
    }

    function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external override lock onlyTimeLock {
        require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
        withdrawLockupEpochs = _withdrawLockupEpochs;
        rewardLockupEpochs = _rewardLockupEpochs;
    }

    function allocateReward(uint256 _amount) external override lock onlyEpochController {
        require(_amount > 0, "StakePoolEpochReward: Cannot allocate 0");
        uint256 _before = IERC20(rewardToken).balanceOf(address(rewardFund));
        TransferHelper.safeTransferFrom(rewardToken, msg.sender, rewardFund, _amount);
        if (balance > 0) {
            uint256 _after = IERC20(rewardToken).balanceOf(address(rewardFund));
            _amount = _after.sub(_before);

            // Create & add new snapshot
            uint256 _prevRPS = getLatestSnapshot().rewardPerShare;
            uint256 _nextRPS = _prevRPS.add(_amount.mul(1e18).div(balance));

            Snapshot memory _newSnapshot = Snapshot({time: block.number, rewardReceived: _amount, rewardPerShare: _nextRPS});
            emit AllocateReward(block.number, _amount);
            snapshotHistory.push(_newSnapshot);
        }
    }

    function allowRecoverRewardToken(address _token) external view override returns (bool) {
        if (rewardToken == _token) {
            // do not allow to drain reward token if less than 1 months after pool ends
            if (block.timestamp < (getLatestSnapshot().time + 7 days)) {
                return false;
            }
        }
        return true;
    }

    // =========== Epoch getters

    function epoch() public view override returns (uint256) {
        return IEpochController(epochController).epoch();
    }

    function nextEpochPoint() external view override returns (uint256) {
        return IEpochController(epochController).nextEpochPoint();
    }

    function nextEpochLength() external view override returns (uint256) {
        return IEpochController(epochController).nextEpochLength();
    }

    function nextEpochAllocatedReward() external view override returns (uint256) {
        return IEpochController(epochController).nextEpochAllocatedReward(address(this));
    }

    // =========== Snapshot getters

    function latestSnapshotIndex() public view returns (uint256) {
        return snapshotHistory.length.sub(1);
    }

    function getLatestSnapshot() internal view returns (Snapshot memory) {
        return snapshotHistory[latestSnapshotIndex()];
    }

    function getLastSnapshotIndexOf(address _account) public view returns (uint256) {
        return userInfo[_account].lastSnapshotIndex;
    }

    function getLastSnapshotOf(address _account) internal view returns (Snapshot memory) {
        return snapshotHistory[getLastSnapshotIndexOf(_account)];
    }

    // =========== _account getters

    function rewardPerShare() public view returns (uint256) {
        return getLatestSnapshot().rewardPerShare;
    }

    function earned(address _account) public view override returns (uint256) {
        uint256 latestRPS = getLatestSnapshot().rewardPerShare;
        uint256 storedRPS = getLastSnapshotOf(_account).rewardPerShare;

        UserInfo memory user = userInfo[_account];
        return user.amount.mul(latestRPS.sub(storedRPS)).div(1e18).add(user.rewardEarned);
    }

    function canWithdraw(address _account) external view returns (bool) {
        return userInfo[_account].epochTimerStart.add(withdrawLockupEpochs) <= epoch();
    }

    function canClaimReward(address _account) external view returns (bool) {
        return userInfo[_account].epochTimerStart.add(rewardLockupEpochs) <= epoch();
    }

    function unlockWithdrawEpoch(address _account) public view override returns (uint256) {
        return userInfo[_account].epochTimerStart.add(withdrawLockupEpochs);
    }

    function unlockRewardEpoch(address _account) public view override returns (uint256) {
        return userInfo[_account].epochTimerStart.add(rewardLockupEpochs);
    }

    /* ========== MUTATIVE FUNCTIONS ========== */

    function stake(uint256 _amount) external override lock {
        IValueLiquidPair(pair).transferFrom(msg.sender, address(this), _amount);
        _stakeFor(msg.sender);
    }

    function stakeFor(address _account) external override lock {
        require(IStakePoolController(controller).isWhitelistStakingFor(msg.sender), "StakePoolEpochReward: Invalid sender");
        _stakeFor(_account);
    }

    function _stakeFor(address _account) internal {
        uint256 _amount = IValueLiquidPair(pair).balanceOf(address(this)).sub(balance);
        require(_amount > 0, "StakePoolEpochReward: Invalid balance");
        balance = balance.add(_amount);
        UserInfo storage user = userInfo[_account];
        user.epochTimerStart = epoch(); // reset timer
        user.amount = user.amount.add(_amount);
        emit Deposit(_account, _amount);
    }

    function removeStakeInternal(uint256 _amount) internal {
        UserInfo storage user = userInfo[msg.sender];
        uint256 _epoch = epoch();
        require(user.epochTimerStart.add(withdrawLockupEpochs) <= _epoch, "StakePoolEpochReward: still in withdraw lockup");
        require(user.amount >= _amount, "StakePoolEpochReward: invalid withdraw amount");
        _claimReward(false);
        balance = balance.sub(_amount);
        user.epochTimerStart = _epoch; // reset timer
        user.amount = user.amount.sub(_amount);
    }

    function withdraw(uint256 _amount) public override lock {
        removeStakeInternal(_amount);
        IValueLiquidPair(pair).transfer(msg.sender, _amount);
        emit Withdraw(msg.sender, _amount);
    }

    function exit() external {
        withdraw(userInfo[msg.sender].amount);
    }

    function _claimReward(bool _lockChecked) internal updateReward(msg.sender) {
        UserInfo storage user = userInfo[msg.sender];
        uint256 _reward = user.rewardEarned;
        if (_reward > 0) {
            if (_lockChecked) {
                uint256 _epoch = epoch();
                require(user.epochTimerStart.add(rewardLockupEpochs) <= _epoch, "StakePoolEpochReward: still in reward lockup");
                user.epochTimerStart = _epoch; // reset timer
            }
            user.rewardEarned = 0;
            // Safe reward transfer, just in case if rounding error causes pool to not have enough reward amount
            uint256 _rewardBalance = IERC20(rewardToken).balanceOf(rewardFund);
            uint256 _paidAmount = _rewardBalance > _reward ? _reward : _rewardBalance;
            IStakePoolRewardFund(rewardFund).safeTransfer(rewardToken, msg.sender, _paidAmount);
            emit PayRewardPool(0, rewardToken, msg.sender, _reward, _reward, _paidAmount);
        }
    }

    function claimReward() public override {
        _claimReward(true);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw() external override lock {
        require(IStakePoolController(controller).isAllowEmergencyWithdrawStakePool(address(this)), "StakePoolEpochReward: Not allow emergencyWithdraw");
        UserInfo storage user = userInfo[msg.sender];
        uint256 amount = user.amount;
        balance = balance.sub(amount);
        user.amount = 0;
        IValueLiquidPair(pair).transfer(msg.sender, amount);
    }

    function removeLiquidity(
        address provider,
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) public override lock returns (uint256 amountA, uint256 amountB) {
        require(IStakePoolController(controller).isWhitelistStakingFor(provider), "StakePoolEpochReward: Invalid provider");
        removeStakeInternal(liquidity);
        IValueLiquidPair(pair).approve(provider, liquidity);
        emit Withdraw(msg.sender, liquidity);
        (amountA, amountB) = IValueLiquidProvider(provider).removeLiquidity(address(pair), tokenA, tokenB, liquidity, amountAMin, amountBMin, to, deadline);
    }

    function removeLiquidityETH(
        address provider,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external override lock returns (uint256 amountToken, uint256 amountETH) {
        require(IStakePoolController(controller).isWhitelistStakingFor(provider), "StakePoolEpochReward: Invalid provider");
        removeStakeInternal(liquidity);
        IValueLiquidPair(pair).approve(provider, liquidity);
        emit Withdraw(msg.sender, liquidity);
        (amountToken, amountETH) = IValueLiquidProvider(provider).removeLiquidityETH(
            address(pair),
            token,
            liquidity,
            amountTokenMin,
            amountETHMin,
            to,
            deadline
        );
    }

    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address provider,
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external override lock returns (uint256 amountETH) {
        require(IStakePoolController(controller).isWhitelistStakingFor(provider), "StakePoolEpochReward: Invalid provider");
        removeStakeInternal(liquidity);
        IValueLiquidPair(pair).approve(provider, liquidity);
        emit Withdraw(msg.sender, liquidity);
        amountETH = IValueLiquidProvider(provider).removeLiquidityETHSupportingFeeOnTransferTokens(
            address(pair),
            token,
            liquidity,
            amountTokenMin,
            amountETHMin,
            to,
            deadline
        );
    }
}

contract StakePoolEpochRewardCreator is IStakePoolCreator {
    uint256 public override version = 4001;
    struct PoolRewardInfo {
        address epochController;
        uint256 withdrawLockupEpochs;
        uint256 rewardLockupEpochs;
    }

    function create() external override returns (address) {
        StakePoolEpochReward pool = new StakePoolEpochReward(msg.sender, version);
        return address(pool);
    }

    function initialize(
        address poolAddress,
        address pair,
        address rewardToken,
        address timelock,
        address stakePoolRewardFund,
        bytes calldata data
    ) external override {
        StakePoolEpochReward pool = StakePoolEpochReward(poolAddress);

        PoolRewardInfo memory poolRewardInfo = abi.decode(data, (PoolRewardInfo));
        pool.initialize(
            pair,
            address(stakePoolRewardFund),
            address(timelock),
            poolRewardInfo.epochController,
            rewardToken,
            poolRewardInfo.withdrawLockupEpochs,
            poolRewardInfo.rewardLockupEpochs
        );
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_controller","type":"address"},{"internalType":"uint256","name":"_version","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"blocktime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AllocateReward","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"poolId","type":"uint256"},{"indexed":true,"internalType":"address","name":"rewardToken","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"pendingReward","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rebaseAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"paidReward","type":"uint256"}],"name":"PayRewardPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"allocateReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"allowRecoverRewardToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"canClaimReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"canWithdraw","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"epoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epochController","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getLastSnapshotIndexOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"},{"internalType":"address","name":"_rewardFund","type":"address"},{"internalType":"address","name":"_timelock","type":"address"},{"internalType":"address","name":"_epochController","type":"address"},{"internalType":"address","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_withdrawLockupEpochs","type":"uint256"},{"internalType":"uint256","name":"_rewardLockupEpochs","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"latestSnapshotIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextEpochAllocatedReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextEpochLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextEpochPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"provider","type":"address"},{"internalType":"address","name":"tokenA","type":"address"},{"internalType":"address","name":"tokenB","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amountAMin","type":"uint256"},{"internalType":"uint256","name":"amountBMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"removeLiquidity","outputs":[{"internalType":"uint256","name":"amountA","type":"uint256"},{"internalType":"uint256","name":"amountB","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"provider","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"amountETHMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"removeLiquidityETH","outputs":[{"internalType":"uint256","name":"amountToken","type":"uint256"},{"internalType":"uint256","name":"amountETH","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"provider","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amountTokenMin","type":"uint256"},{"internalType":"uint256","name":"amountETHMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"removeLiquidityETHSupportingFeeOnTransferTokens","outputs":[{"internalType":"uint256","name":"amountETH","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardFund","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardLockupEpochs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_epochController","type":"address"}],"name":"setEpochController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawLockupEpochs","type":"uint256"},{"internalType":"uint256","name":"_rewardLockupEpochs","type":"uint256"}],"name":"setLockUp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"snapshotHistory","outputs":[{"internalType":"uint256","name":"time","type":"uint256"},{"internalType":"uint256","name":"rewardReceived","type":"uint256"},{"internalType":"uint256","name":"rewardPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"stakeFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"timelock","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"unlockRewardEpoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"unlockWithdrawEpoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"lastSnapshotIndex","type":"uint256"},{"internalType":"uint256","name":"rewardEarned","type":"uint256"},{"internalType":"uint256","name":"epochTimerStart","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawLockupEpochs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

28843:13092:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34963:365;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29473:33;;;:::i;29359:30::-;;;:::i;:::-;;;;;;;:::i;35509:166::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;33841:145::-;;;:::i;29566:33::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;35336:165::-;;;;;;:::i;:::-;;:::i;29515:44::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;29431:35::-;;;:::i;33994:176::-;;;:::i;37526:211::-;;;;;;:::i;:::-;;:::i;:::-;;31825:376;;;;;;:::i;:::-;;:::i;33140:375::-;;;;;;:::i;:::-;;:::i;34217:116::-;;;:::i;34839:::-;;;:::i;36278:223::-;;;;;;:::i;:::-;;:::i;28938:31::-;;;:::i;31674:143::-;;;;;;:::i;:::-;;:::i;35863:168::-;;;;;;:::i;:::-;;:::i;34482:142::-;;;;;;:::i;:::-;;:::i;33559:123::-;;;:::i;36093:177::-;;;;;;:::i;:::-;;:::i;29608:28::-;;;:::i;30951:669::-;;;;;;:::i;:::-;;:::i;40206:848::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;29739:22::-;;;:::i;38858:76::-;;;:::i;33690:143::-;;;:::i;29675:23::-;;;:::i;39005:436::-;;;:::i;39449:749::-;;;;;;:::i;:::-;;:::i;32209:923::-;;;;;;:::i;:::-;;:::i;35683:172::-;;;;;;:::i;:::-;;:::i;37745:81::-;;;:::i;41062:870::-;;;;;;:::i;:::-;;:::i;29643:25::-;;;:::i;29705:::-;;;:::i;29396:26::-;;;:::i;34963:365::-;35027:7;35047:17;35067:19;:17;:19::i;:::-;:34;;;35047:54;;35112:17;35132:27;35150:8;35132:17;:27::i;:::-;:42;;;;;35210:18;;;35187:20;35210:18;;;:8;:18;;;;;;;;35187:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35132:42;;-1:-1:-1;35187:41:0;35246:74;;:51;35292:4;35246:41;35262:24;:9;35132:42;35262:13;:24::i;:::-;35246:11;;;:15;:41::i;:::-;:45;;:51::i;:::-;:55;;:74::i;:::-;35239:81;;;;;34963:365;;;;:::o;29473:33::-;;;;:::o;29359:30::-;;;;;;:::o;35509:166::-;35574:4;35660:7;:5;:7::i;:::-;35637:18;;35598;;;;;;;:8;:18;;;;;:34;;;:58;;:38;:58::i;:::-;:69;;;35509:166;-1:-1:-1;;35509:166:0:o;33841:145::-;33944:15;;33927:51;;;;;;;;33900:7;;33944:15;;;33927:49;;:51;;;;;;;;;;;;;;33944:15;33927:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;33920:58;;33841:145;:::o;29566:33::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;29566:33:0;:::o;35336:165::-;35398:4;35486:7;:5;:7::i;:::-;35461:20;;;35422:18;;;;;;;:8;:18;;;;;:34;;;;:60;;:38;:60::i;29515:44::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;29431:35::-;;;;:::o;33994:176::-;34106:15;;34089:73;;;;;34062:7;;34106:15;;;34089:58;;:73;;34156:4;;34089:73;;;:::i;:::-;;;;;;;;;;;;;;;;;;;37526:211;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;30275:1;30263:9;:13;37593:28:::1;37613:7:::0;37593:19:::1;:28::i;:::-;37649:4;::::0;37632:52:::1;::::0;;;;37649:4:::1;::::0;;::::1;::::0;37632:31:::1;::::0;:52:::1;::::0;37664:10:::1;::::0;37676:7;;37632:52:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;37709:10;37700:29;;;37721:7;37700:29;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;30311:1:0;30299:9;:13;37526:211::o;31825:376::-;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;30275:1;30263:9;:13;30385:8:::1;::::0;::::1;;30371:10;:22;30363:66;;;;;;;;;;;;:::i;:::-;31984:19:::2;31959:21;:44;;:75;;;;;32032:2;32007:21;:27;;31959:75;31951:123;;;;;;;;;;;;:::i;:::-;32098:20;:44:::0;;;;32153:18:::2;:40:::0;30311:1;30299:9;:13;31825:376::o;33140:375::-;33242:11;;33221:4;;33242:21;;;;:11;;:21;33238:248;;;33392:19;:17;:19::i;:::-;:24;33419:6;33392:33;33373:15;:53;33369:106;;;-1:-1:-1;33454:5:0;33447:12;;33369:106;-1:-1:-1;33503:4:0;33140:375;;;:::o;34217:116::-;34296:15;:22;34269:7;;34296:29;;34323:1;34296:26;:29::i;34839:116::-;34886:7;34913:19;:17;:19::i;:::-;:34;;;34906:41;;34839:116;:::o;36278:223::-;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;30275:1;30263:9;:13;36377:10:::1;::::0;36356:66:::1;::::0;;;;36377:10:::1;::::0;;::::1;::::0;36356:54:::1;::::0;:66:::1;::::0;36411:10:::1;::::0;36356:66:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;36348:115;;;;;;;;;;;;:::i;:::-;36474:19;36484:8;36474:9;:19::i;:::-;-1:-1:-1::0;30311:1:0;30299:9;:13;36278:223::o;28938:31::-;;;;:::o;31674:143::-;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;30275:1;30263:9;:13;30385:8:::1;::::0;::::1;;30371:10;:22;30363:66;;;;;;;;;;;;:::i;:::-;31775:15:::2;:34:::0;;;::::2;;::::0;;;::::2;::::0;;;::::2;::::0;;30299:9;:13;31674:143::o;35863:168::-;36004:18;;35965;;;35938:7;35965:18;;;:8;:18;;;;;:34;;;35938:7;;35965:58;;:34;:38;:58::i;:::-;35958:65;35863:168;-1:-1:-1;;35863:168:0:o;34482:142::-;34580:18;;34553:7;34580:18;;;:8;:18;;;;;:36;;;;34482:142::o;33559:123::-;33650:15;;33633:41;;;;;;;;33606:7;;33650:15;;;33633:39;;:41;;;;;;;;;;;;;;33650:15;33633:41;;;;;;;;;;36093:177;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;30275:1;30263:9;:13;36176:4:::1;::::0;36159:71:::1;::::0;;;;36176:4:::1;::::0;;::::1;::::0;36159:35:::1;::::0;:71:::1;::::0;36195:10:::1;::::0;36215:4:::1;::::0;36222:7;;36159:71:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;36241:21;36251:10;36241:9;:21::i;29608:28::-:0;;;;;;:::o;30951:669::-;31232:12;;;;:21;31224:81;;;;;;;;;;;;:::i;:::-;31316:4;:12;;;;;;;;;;;;;;31339:10;:24;;;;;;;;;;;;;;31374:8;:20;;;;;;;;;;;;;;31405;:44;-1:-1:-1;31460:40:0;;;;-1:-1:-1;31511:34:0;;;;;;;;;;;;;-1:-1:-1;31556:26:0;;;;;;;;;;;;31593:12;:19;;;;;;;;;30951:669::o;40206:848::-;40464:19;40485:17;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;30275:1;30263:9;:13;40544:10:::1;::::0;40523:64:::1;::::0;;;;40544:10:::1;::::0;;::::1;::::0;40523:54:::1;::::0;:64:::1;::::0;40578:8;;40523:64:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40515:115;;;;;;;;;;;;:::i;:::-;40641:30;40661:9;40641:19;:30::i;:::-;40699:4;::::0;40682:51:::1;::::0;;;;40699:4:::1;::::0;;::::1;::::0;40682:30:::1;::::0;:51:::1;::::0;40713:8;;40723:9;;40682:51:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40758:10;40749:31;;;40770:9;40749:31;;;;;;:::i;:::-;;;;;;;;40890:4;::::0;40818:228:::1;::::0;;;;:49:::1;::::0;;::::1;::::0;::::1;::::0;:228:::1;::::0;40890:4;;::::1;::::0;40910:5;;40930:9;;40954:14;;40983:12;;41010:2;;41027:8;;40818:228:::1;;;:::i;:::-;;::::0;::::1;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;30311:1:::0;30299:9;:13;40791:255;;;;-1:-1:-1;40206:848:0;-1:-1:-1;;;;;;;;40206:848:0:o;29739:22::-;;;;:::o;38858:76::-;38908:18;38921:4;38908:12;:18::i;:::-;38858:76::o;33690:143::-;33792:15;;33775:50;;;;;;;;33748:7;;33792:15;;;33775:48;;:50;;;;;;;;;;;;;;33792:15;33775:50;;;;;;;;;;29675:23;;;;;;:::o;39005:436::-;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;30275:1;30263:9;:13;39097:10:::1;::::0;39076:81:::1;::::0;;;;39097:10:::1;::::0;;::::1;::::0;39076:66:::1;::::0;:81:::1;::::0;39151:4:::1;::::0;39076:81:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;39068:143;;;;;;;;;;;;:::i;:::-;39255:10;39222:21;39246:20:::0;;;:8:::1;:20;::::0;;;;39294:11;;39326:7:::1;::::0;:19:::1;::::0;39294:11;39326::::1;:19::i;:::-;39316:7;:29:::0;39370:1:::1;39356:15:::0;;39399:4:::1;::::0;39382:51:::1;::::0;;;;39399:4:::1;::::0;;::::1;::::0;39382:31:::1;::::0;:51:::1;::::0;39414:10:::1;::::0;39426:6;;39382:51:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;30311:1:0;30299:9;:13;-1:-1:-1;39005:436:0:o;39449:749::-;39722:15;39739;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;30275:1;30263:9;:13;39796:10:::1;::::0;39775:64:::1;::::0;;;;39796:10:::1;::::0;;::::1;::::0;39775:54:::1;::::0;:64:::1;::::0;39830:8;;39775:64:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;39767:115;;;;;;;;;;;;:::i;:::-;39893:30;39913:9;39893:19;:30::i;:::-;39951:4;::::0;39934:51:::1;::::0;;;;39951:4:::1;::::0;;::::1;::::0;39934:30:::1;::::0;:51:::1;::::0;39965:8;;39975:9;;39934:51:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40010:10;40001:31;;;40022:9;40001:31;;;;;;:::i;:::-;;;;;;;;40119:4;::::0;40064:126:::1;::::0;;;;:46:::1;::::0;;::::1;::::0;::::1;::::0;:126:::1;::::0;40119:4;;::::1;::::0;40126:6;;40134;;40142:9;;40153:10;;40165;;40177:2;;40181:8;;40064:126:::1;;;:::i;:::-;;::::0;::::1;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;30311:1:::0;30299:9;:13;40043:147;;;;-1:-1:-1;39449:749:0;-1:-1:-1;;;;;;;;;39449:749:0:o;32209:923::-;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;30275:1;30263:9;:13;30521:15:::1;::::0;::::1;;30507:10;:29;30499:80;;;;;;;;;;;;:::i;:::-;32322:1:::2;32312:7;:11;32304:63;;;;;;;;;;;;:::i;:::-;32403:11;::::0;32434:10:::2;::::0;32396:50:::2;::::0;;;;32378:15:::2;::::0;32403:11:::2;::::0;;::::2;::::0;32396:29:::2;::::0;:50:::2;::::0;32434:10;;::::2;::::0;32396:50:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;32489:11;::::0;32514:10:::2;::::0;32378:68;;-1:-1:-1;32457:77:0::2;::::0;32489:11:::2;::::0;;::::2;::::0;32502:10:::2;::::0;32514::::2;32526:7:::0;32457:31:::2;:77::i;:::-;32549:7;::::0;:11;32545:580:::2;;32601:11;::::0;32632:10:::2;::::0;32594:50:::2;::::0;;;;32577:14:::2;::::0;32601:11:::2;::::0;;::::2;::::0;32594:29:::2;::::0;:50:::2;::::0;32632:10;;::::2;::::0;32594:50:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;32577:67:::0;-1:-1:-1;32669:19:0::2;32577:67:::0;32680:7;32669:10:::2;:19::i;:::-;32659:29;;32747:16;32766:19;:17;:19::i;:::-;:34;;;32747:53;;32815:16;32834:44;32847:30;32869:7;;32847:17;32859:4;32847:7;:11;;:17;;;;:::i;:30::-;32834:8:::0;;:12:::2;:44::i;:::-;32815:63;;32895:28;32926:81;;;;;;;;32942:12;32926:81;;;;32972:7;32926:81;;;;32997:8;32926:81;;::::0;32895:112:::2;;33027:37;33042:12;33056:7;33027:37;;;;;;;:::i;:::-;;;;;;;;33079:15;:34:::0;;::::2;::::0;::::2;::::0;;-1:-1:-1;33079:34:0;;;;;;;::::2;::::0;;::::2;::::0;;::::2;::::0;::::2;::::0;::::2;::::0;;;;;::::2;::::0;;::::2;::::0;;;;;;-1:-1:-1;;;32545:580:0::2;-1:-1:-1::0;;30311:1:0;30299:9;:13;32209:923::o;35683:172::-;35826:20;;;35787:18;;;35760:7;35787:18;;;:8;:18;;;;;:34;;;;:60;;:38;:60::i;37745:81::-;37799:10;37790:20;;;;:8;:20;;;;;:27;37781:37;;:8;:37::i;41062:870::-;41349:17;30205:9;;30218:1;30205:14;30197:55;;;;;;;;;;;;:::i;:::-;30275:1;30263:9;:13;41408:10:::1;::::0;41387:64:::1;::::0;;;;41408:10:::1;::::0;;::::1;::::0;41387:54:::1;::::0;:64:::1;::::0;41442:8;;41387:64:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41379:115;;;;;;;;;;;;:::i;:::-;41505:30;41525:9;41505:19;:30::i;:::-;41563:4;::::0;41546:51:::1;::::0;;;;41563:4:::1;::::0;;::::1;::::0;41546:30:::1;::::0;:51:::1;::::0;41577:8;;41587:9;;41546:51:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;41622:10;41613:31;;;41634:9;41613:31;;;;;;:::i;:::-;;;;;;;;41768:4;::::0;41667:257:::1;::::0;;;;:78:::1;::::0;;::::1;::::0;::::1;::::0;:257:::1;::::0;41768:4;;::::1;::::0;41788:5;;41808:9;;41832:14;;41861:12;;41888:2;;41905:8;;41667:257:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;30311:1:::0;30299:9;:13;41655:269;41062:870;-1:-1:-1;;;;;;;;41062:870:0:o;29643:25::-;;;;;;:::o;29705:::-;;;;;;:::o;29396:26::-;;;;;;:::o;34341:133::-;34393:15;;:::i;:::-;34428;34444:21;:19;:21::i;:::-;34428:38;;;;;;;;;;;;;;;;;;34421:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34341:133;:::o;34632:160::-;34700:15;;:::i;:::-;34735;34751:32;34774:8;34751:22;:32::i;:::-;34735:49;;;;;;;;;;;;;;;;;;34728:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34632:160;;;:::o;12515:138::-;12608:5;;;12603:16;;;;12595:50;;;;;;;;;;;;:::i;12661:151::-;12719:9;12749:6;;;:30;;-1:-1:-1;;12764:5:0;;;12778:1;12773;12764:5;12773:1;12759:15;;;;;:20;12749:30;12741:63;;;;;;;;;;;;:::i;12820:150::-;12878:9;12912:1;12908;:5;12900:42;;;;;;;;;;;;:::i;:::-;12961:1;12957;:5;;;;;;;12820:150;-1:-1:-1;;;12820:150:0:o;12370:137::-;12463:5;;;12458:16;;;;12450:49;;;;;;;;;;;;:::i;36973:545::-;37072:10;37039:21;37063:20;;;:8;:20;;;;;;37111:7;:5;:7::i;:::-;37094:24;;37187:6;37137:46;37162:20;;37137:4;:20;;;:24;;:46;;;;:::i;:::-;:56;;37129:115;;;;;;;;;;;;:::i;:::-;37263:11;;:22;-1:-1:-1;37263:22:0;37255:80;;;;;;;;;;;;:::i;:::-;37346:19;37359:5;37346:12;:19::i;:::-;37386:7;;:20;;37398:7;37386:11;:20::i;:::-;37376:7;:30;37417:20;;;:29;;;37486:11;;:24;;37502:7;37486:15;:24::i;:::-;37472:38;;;-1:-1:-1;;36973:545:0:o;36509:456::-;36636:7;;36601:4;;36584:47;;;;;36566:15;;36584:60;;36636:7;;36601:4;;;;;36584:32;;:47;;36625:4;;36584:47;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:51;;:60::i;:::-;36566:78;;36673:1;36663:7;:11;36655:61;;;;;;;;;;;;:::i;:::-;36737:7;;:20;;36749:7;36737:11;:20::i;:::-;36727:7;:30;36792:18;;;36768:21;36792:18;;;:8;:18;;;;;36844:7;:5;:7::i;:::-;36821:20;;;:30;36891:11;;:24;;36907:7;36891:15;:24::i;:::-;36877:38;;36931:26;;;;;;;;;;36949:7;;36931:26;:::i;:::-;;;;;;;;36509:456;;;:::o;37834:1016::-;37897:10;30662:22;;30658:209;;30725:18;;;30701:21;30725:18;;;:8;:18;;;;;30778:16;30734:8;30778:6;:16::i;:::-;30758:17;;;:36;30834:21;:19;:21::i;:::-;30809:22;;;;:46;30658:209;37953:10:::1;37920:21;37944:20:::0;;;:8:::1;:20;::::0;;;;37993:17:::1;::::0;::::1;::::0;38025:11;;38021:822:::1;;38057:12;38053:270;;;38090:14;38107:7;:5;:7::i;:::-;38090:24;;38189:6;38141:44;38166:18;;38141:4;:20;;;:24;;:44;;;;:::i;:::-;:54;;38133:111;;;;;;;;;;;;:::i;:::-;38263:20;::::0;::::1;:29:::0;38053:270:::1;38357:1;38337:17;::::0;;::::1;:21:::0;;;38519:11;38542:10:::1;::::0;38512:41:::1;::::0;;;;38519:11:::1;::::0;;::::1;::::0;38512:29:::1;::::0;:41:::1;::::0;38542:10;::::1;::::0;38512:41:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;38487:66;;38568:19;38607:7;38590:14;:24;:51;;38627:14;38590:51;;;38617:7;38590:51;38677:10;::::0;38702:11:::1;::::0;38656:83:::1;::::0;;;;38568:73;;-1:-1:-1;38677:10:0::1;::::0;;::::1;::::0;38656:45:::1;::::0;:83:::1;::::0;38702:11:::1;::::0;38715:10:::1;::::0;38568:73;;38656:83:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;38776:11:0::1;::::0;38759:72:::1;::::0;38789:10:::1;::::0;-1:-1:-1;38759:72:0::1;38776:11:::0;;::::1;::::0;-1:-1:-1;38776:11:0::1;::::0;38759:72:::1;::::0;::::1;::::0;38801:7;;;;38819:11;;38759:72:::1;:::i;:::-;;;;;;;;38021:822;;;30877:1;;37834:1016:::0;;:::o;8494:448::-;8719:12;8733:17;8754:5;:10;;8788;8800:4;8806:2;8810:5;8765:51;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8754:63;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8718:99;;;;8836:7;:57;;;;-1:-1:-1;8848:11:0;;:16;;:44;;;8879:4;8868:24;;;;;;;;;;;;:::i;:::-;8828:106;;;;;;;;;;;;:::i;:::-;8494:448;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:198:1:-;84:20;;144:42;133:54;;123:65;;113:2;;202:1;199;192:12;217:198;;329:2;317:9;308:7;304:23;300:32;297:2;;;350:6;342;335:22;297:2;378:31;399:9;378:31;:::i;:::-;368:41;287:128;-1:-1:-1;;;287:128:1:o;420:642::-;;;;;;;;634:3;622:9;613:7;609:23;605:33;602:2;;;656:6;648;641:22;602:2;684:31;705:9;684:31;:::i;:::-;674:41;;734:40;770:2;759:9;755:18;734:40;:::i;:::-;724:50;;793:40;829:2;818:9;814:18;793:40;:::i;:::-;783:50;;852:40;888:2;877:9;873:18;852:40;:::i;:::-;842:50;;911:41;947:3;936:9;932:19;911:41;:::i;:::-;901:51;;999:3;988:9;984:19;971:33;961:43;;1051:3;1040:9;1036:19;1023:33;1013:43;;592:470;;;;;;;;;;:::o;1067:703::-;;;;;;;;;1298:3;1286:9;1277:7;1273:23;1269:33;1266:2;;;1320:6;1312;1305:22;1266:2;1348:31;1369:9;1348:31;:::i;:::-;1338:41;;1398:40;1434:2;1423:9;1419:18;1398:40;:::i;:::-;1388:50;;1457:40;1493:2;1482:9;1478:18;1457:40;:::i;:::-;1447:50;;1544:2;1533:9;1529:18;1516:32;1506:42;;1595:3;1584:9;1580:19;1567:33;1557:43;;1647:3;1636:9;1632:19;1619:33;1609:43;;1671:41;1707:3;1696:9;1692:19;1671:41;:::i;:::-;1661:51;;1759:3;1748:9;1744:19;1731:33;1721:43;;1256:514;;;;;;;;;;;:::o;1775:626::-;;;;;;;;1989:3;1977:9;1968:7;1964:23;1960:33;1957:2;;;2011:6;2003;1996:22;1957:2;2039:31;2060:9;2039:31;:::i;:::-;2029:41;;2089:40;2125:2;2114:9;2110:18;2089:40;:::i;:::-;2079:50;;2176:2;2165:9;2161:18;2148:32;2138:42;;2227:2;2216:9;2212:18;2199:32;2189:42;;2278:3;2267:9;2263:19;2250:33;2240:43;;2302:41;2338:3;2327:9;2323:19;2302:41;:::i;:::-;2292:51;;2390:3;2379:9;2375:19;2362:33;2352:43;;1947:454;;;;;;;;;;:::o;2406:297::-;;2526:2;2514:9;2505:7;2501:23;2497:32;2494:2;;;2547:6;2539;2532:22;2494:2;2584:9;2578:16;2637:5;2630:13;2623:21;2616:5;2613:32;2603:2;;2664:6;2656;2649:22;2708:190;;2820:2;2808:9;2799:7;2795:23;2791:32;2788:2;;;2841:6;2833;2826:22;2788:2;-1:-1:-1;2869:23:1;;2778:120;-1:-1:-1;2778:120:1:o;2903:194::-;;3026:2;3014:9;3005:7;3001:23;2997:32;2994:2;;;3047:6;3039;3032:22;2994:2;-1:-1:-1;3075:16:1;;2984:113;-1:-1:-1;2984:113:1:o;3102:258::-;;;3231:2;3219:9;3210:7;3206:23;3202:32;3199:2;;;3252:6;3244;3237:22;3199:2;-1:-1:-1;;3280:23:1;;;3350:2;3335:18;;;3322:32;;-1:-1:-1;3189:171:1:o;3365:255::-;;;3505:2;3493:9;3484:7;3480:23;3476:32;3473:2;;;3526:6;3518;3511:22;3473:2;-1:-1:-1;;3554:16:1;;3610:2;3595:18;;;3589:25;3554:16;;3589:25;;-1:-1:-1;3463:157:1:o;3625:430::-;;3792:6;3786:13;3817:3;3829:129;3843:6;3840:1;3837:13;3829:129;;;3941:4;3925:14;;;3921:25;;3915:32;3902:11;;;3895:53;3858:12;3829:129;;;3976:6;3973:1;3970:13;3967:2;;;4011:3;4002:6;3997:3;3993:16;3986:29;3967:2;-1:-1:-1;4033:16:1;;;;;3762:293;-1:-1:-1;;3762:293:1:o;4060:226::-;4236:42;4224:55;;;;4206:74;;4194:2;4179:18;;4161:125::o;4530:406::-;4750:42;4819:15;;;4801:34;;4871:15;;;;4866:2;4851:18;;4844:43;4918:2;4903:18;;4896:34;;;;4728:2;4713:18;;4695:241::o;4941:305::-;5153:42;5141:55;;;;5123:74;;5228:2;5213:18;;5206:34;5111:2;5096:18;;5078:168::o;5662:776::-;6015:42;6084:15;;;6066:34;;6136:15;;;6131:2;6116:18;;6109:43;6188:15;;;6183:2;6168:18;;6161:43;6235:2;6220:18;;6213:34;;;;6278:3;6263:19;;6256:35;;;;6322:3;6307:19;;6300:35;6372:15;;;6366:3;6351:19;;6344:44;6419:3;6404:19;;6397:35;;;;5992:3;5977:19;;5959:479::o;6846:695::-;7171:42;7240:15;;;7222:34;;7292:15;;;7287:2;7272:18;;7265:43;7339:2;7324:18;;7317:34;;;;7382:2;7367:18;;7360:34;;;;7425:3;7410:19;;7403:35;7475:15;;;7469:3;7454:19;;7447:44;7522:3;7507:19;;7500:35;;;;7148:3;7133:19;;7115:426::o;7848:187::-;8013:14;;8006:22;7988:41;;7976:2;7961:18;;7943:92::o;8040:345::-;8242:2;8224:21;;;8281:2;8261:18;;;8254:30;8320:23;8315:2;8300:18;;8293:51;8376:2;8361:18;;8214:171::o;8390:401::-;8592:2;8574:21;;;8631:2;8611:18;;;8604:30;8670:34;8665:2;8650:18;;8643:62;8741:7;8736:2;8721:18;;8714:35;8781:3;8766:19;;8564:227::o;8796:344::-;8998:2;8980:21;;;9037:2;9017:18;;;9010:30;9076:22;9071:2;9056:18;;9049:50;9131:2;9116:18;;8970:170::o;9145:344::-;9347:2;9329:21;;;9386:2;9366:18;;;9359:30;9425:22;9420:2;9405:18;;9398:50;9480:2;9465:18;;9319:170::o;9494:402::-;9696:2;9678:21;;;9735:2;9715:18;;;9708:30;9774:34;9769:2;9754:18;;9747:62;9845:8;9840:2;9825:18;;9818:36;9886:3;9871:19;;9668:228::o;9901:402::-;10103:2;10085:21;;;10142:2;10122:18;;;10115:30;10181:34;10176:2;10161:18;;10154:62;10252:8;10247:2;10232:18;;10225:36;10293:3;10278:19;;10075:228::o;10308:403::-;10510:2;10492:21;;;10549:2;10529:18;;;10522:30;10588:34;10583:2;10568:18;;10561:62;10659:9;10654:2;10639:18;;10632:37;10701:3;10686:19;;10482:229::o;10716:410::-;10918:2;10900:21;;;10957:2;10937:18;;;10930:30;10996:34;10991:2;10976:18;;10969:62;11067:16;11062:2;11047:18;;11040:44;11116:3;11101:19;;10890:236::o;11131:400::-;11333:2;11315:21;;;11372:2;11352:18;;;11345:30;11411:34;11406:2;11391:18;;11384:62;11482:6;11477:2;11462:18;;11455:34;11521:3;11506:19;;11305:226::o;11536:399::-;11738:2;11720:21;;;11777:2;11757:18;;;11750:30;11816:34;11811:2;11796:18;;11789:62;11887:5;11882:2;11867:18;;11860:33;11925:3;11910:19;;11710:225::o;11940:355::-;12142:2;12124:21;;;12181:2;12161:18;;;12154:30;12220:33;12215:2;12200:18;;12193:61;12286:2;12271:18;;12114:181::o;12300:413::-;12502:2;12484:21;;;12541:2;12521:18;;;12514:30;12580:34;12575:2;12560:18;;12553:62;12651:19;12646:2;12631:18;;12624:47;12703:3;12688:19;;12474:239::o;12718:408::-;12920:2;12902:21;;;12959:2;12939:18;;;12932:30;12998:34;12993:2;12978:18;;12971:62;13069:14;13064:2;13049:18;;13042:42;13116:3;13101:19;;12892:234::o;13131:411::-;13333:2;13315:21;;;13372:2;13352:18;;;13345:30;13411:34;13406:2;13391:18;;13384:62;13482:17;13477:2;13462:18;;13455:45;13532:3;13517:19;;13305:237::o;13547:409::-;13749:2;13731:21;;;13788:2;13768:18;;;13761:30;13827:34;13822:2;13807:18;;13800:62;13898:15;13893:2;13878:18;;13871:43;13946:3;13931:19;;13721:235::o;13961:348::-;14163:2;14145:21;;;14202:2;14182:18;;;14175:30;14241:26;14236:2;14221:18;;14214:54;14300:2;14285:18;;14135:174::o;14314:400::-;14516:2;14498:21;;;14555:2;14535:18;;;14528:30;14594:34;14589:2;14574:18;;14567:62;14665:6;14660:2;14645:18;;14638:34;14704:3;14689:19;;14488:226::o;14719:352::-;14921:2;14903:21;;;14960:2;14940:18;;;14933:30;14999;14994:2;14979:18;;14972:58;15062:2;15047:18;;14893:178::o;15076:177::-;15222:25;;;15210:2;15195:18;;15177:76::o;15258:248::-;15432:25;;;15488:2;15473:18;;15466:34;15420:2;15405:18;;15387:119::o;15511:319::-;15713:25;;;15769:2;15754:18;;15747:34;;;;15812:2;15797:18;;15790:34;15701:2;15686:18;;15668:162::o;15835:391::-;16066:25;;;16122:2;16107:18;;16100:34;;;;16165:2;16150:18;;16143:34;16208:2;16193:18;;16186:34;16053:3;16038:19;;16020:206::o

ipfs://15d4c8d309f093cb7799c1b70c6151c477475534f9de905011683115aec3e0c6