@harvest-finance/harvest-strategy-polygon 0.0.1-security → 1.0.0

package/contracts/base/interface/pearl/IPair.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.6.12;
+
+interface IPair {
+    function initialize(address _token0, address _token1, bool _stable) external;
+
+    function metadata() external view returns (uint256 dec0, uint256 dec1, uint256 r0, uint256 r1, bool st, address t0, address t1);
+
+    function claimFees() external returns (uint256, uint256);
+
+    function tokens() external view returns (address, address);
+
+    function token0() external view returns (address);
+
+    function token1() external view returns (address);
+
+    function transferFrom(address src, address dst, uint256 amount) external returns (bool);
+
+    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
+
+    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
+
+    function burn(address to) external returns (uint256 amount0, uint256 amount1);
+
+    function mint(address to) external returns (uint256 liquidity);
+
+    function getReserves() external view returns (uint256 _reserve0, uint256 _reserve1, uint256 _blockTimestampLast);
+
+    function getAmountOut(uint256, address) external view returns (uint256);
+
+    function name() external view returns (string memory);
+
+    function symbol() external view returns (string memory);
+
+    function totalSupply() external view returns (uint256);
+
+    function decimals() external view returns (uint8);
+
+    function claimable0(address _user) external view returns (uint256);
+
+    function claimable1(address _user) external view returns (uint256);
+
+    function stable() external view returns (bool);
+}

package/contracts/base/interface/pearl/IRouter.sol

@@ -0,0 +1,305 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+interface IRouter {
+    struct Route {
+        address from;
+        address to;
+        bool stable;
+    }
+
+    /// @dev Struct containing information necessary to zap in and out of pools
+    /// @param tokenA           .
+    /// @param tokenB           .
+    /// @param stable           Stable or volatile pool
+    /// @param amountOutMinA    Minimum amount expected from swap leg of zap via routesA
+    /// @param amountOutMinB    Minimum amount expected from swap leg of zap via routesB
+    /// @param amountAMin       Minimum amount of tokenA expected from liquidity leg of zap
+    /// @param amountBMin       Minimum amount of tokenB expected from liquidity leg of zap
+    struct Zap {
+        address tokenA;
+        address tokenB;
+        bool stable;
+        uint256 amountOutMinA;
+        uint256 amountOutMinB;
+        uint256 amountAMin;
+        uint256 amountBMin;
+    }
+
+    /// @notice Sort two tokens by which address value is less than the other
+    /// @param tokenA   Address of token to sort
+    /// @param tokenB   Address of token to sort
+    /// @return token0  Lower address value between tokenA and tokenB
+    /// @return token1  Higher address value between tokenA and tokenB
+    function sortTokens(address tokenA, address tokenB) external pure returns (address token0, address token1);
+
+    /// @notice Calculate the address of a pool by its' factory.
+    ///         Used by all Router functions containing a `Route[]` or `_factory` argument.
+    ///         Reverts if _factory is not approved by the FactoryRegistry
+    /// @dev Returns a randomly generated address for a nonexistent pool
+    /// @param tokenA   Address of token to query
+    /// @param tokenB   Address of token to query
+    /// @param stable   True if pool is stable, false if volatile
+    function poolFor(
+        address tokenA,
+        address tokenB,
+        bool stable
+    ) external view returns (address pool);
+
+    /// @notice Fetch and sort the reserves for a pool
+    /// @param tokenA       .
+    /// @param tokenB       .
+    /// @param stable       True if pool is stable, false if volatile
+    /// @return reserveA    Amount of reserves of the sorted token A
+    /// @return reserveB    Amount of reserves of the sorted token B
+    function getReserves(
+        address tokenA,
+        address tokenB,
+        bool stable
+    ) external view returns (uint256 reserveA, uint256 reserveB);
+
+    /// @notice Perform chained getAmountOut calculations on any number of pools
+    function getAmountsOut(uint256 amountIn, Route[] memory routes) external view returns (uint256[] memory amounts);
+
+    // **** ADD LIQUIDITY ****
+
+    /// @notice Quote the amount deposited into a Pool
+    /// @param tokenA           .
+    /// @param tokenB           .
+    /// @param stable           True if pool is stable, false if volatile
+    /// @param amountADesired   Amount of tokenA desired to deposit
+    /// @param amountBDesired   Amount of tokenB desired to deposit
+    /// @return amountA         Amount of tokenA to actually deposit
+    /// @return amountB         Amount of tokenB to actually deposit
+    /// @return liquidity       Amount of liquidity token returned from deposit
+    function quoteAddLiquidity(
+        address tokenA,
+        address tokenB,
+        bool stable,
+        uint256 amountADesired,
+        uint256 amountBDesired
+    ) external view returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+
+    /// @notice Quote the amount of liquidity removed from a Pool
+    /// @param tokenA       .
+    /// @param tokenB       .
+    /// @param stable       True if pool is stable, false if volatile
+    /// @param liquidity    Amount of liquidity to remove
+    /// @return amountA     Amount of tokenA received
+    /// @return amountB     Amount of tokenB received
+    function quoteRemoveLiquidity(
+        address tokenA,
+        address tokenB,
+        bool stable,
+        uint256 liquidity
+    ) external view returns (uint256 amountA, uint256 amountB);
+
+    /// @notice Add liquidity of two tokens to a Pool
+    /// @param tokenA           .
+    /// @param tokenB           .
+    /// @param stable           True if pool is stable, false if volatile
+    /// @param amountADesired   Amount of tokenA desired to deposit
+    /// @param amountBDesired   Amount of tokenB desired to deposit
+    /// @param amountAMin       Minimum amount of tokenA to deposit
+    /// @param amountBMin       Minimum amount of tokenB to deposit
+    /// @param to               Recipient of liquidity token
+    /// @param deadline         Deadline to receive liquidity
+    /// @return amountA         Amount of tokenA to actually deposit
+    /// @return amountB         Amount of tokenB to actually deposit
+    /// @return liquidity       Amount of liquidity token returned from deposit
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        bool stable,
+        uint256 amountADesired,
+        uint256 amountBDesired,
+        uint256 amountAMin,
+        uint256 amountBMin,
+        address to,
+        uint256 deadline
+    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
+
+    /// @notice Add liquidity of a token and WETH (transferred as ETH) to a Pool
+    /// @param token                .
+    /// @param stable               True if pool is stable, false if volatile
+    /// @param amountTokenDesired   Amount of token desired to deposit
+    /// @param amountTokenMin       Minimum amount of token to deposit
+    /// @param amountETHMin         Minimum amount of ETH to deposit
+    /// @param to                   Recipient of liquidity token
+    /// @param deadline             Deadline to add liquidity
+    /// @return amountToken         Amount of token to actually deposit
+    /// @return amountETH           Amount of tokenETH to actually deposit
+    /// @return liquidity           Amount of liquidity token returned from deposit
+    function addLiquidityETH(
+        address token,
+        bool stable,
+        uint256 amountTokenDesired,
+        uint256 amountTokenMin,
+        uint256 amountETHMin,
+        address to,
+        uint256 deadline
+    ) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
+
+    // **** REMOVE LIQUIDITY ****
+
+    /// @notice Remove liquidity of two tokens from a Pool
+    /// @param tokenA       .
+    /// @param tokenB       .
+    /// @param stable       True if pool is stable, false if volatile
+    /// @param liquidity    Amount of liquidity to remove
+    /// @param amountAMin   Minimum amount of tokenA to receive
+    /// @param amountBMin   Minimum amount of tokenB to receive
+    /// @param to           Recipient of tokens received
+    /// @param deadline     Deadline to remove liquidity
+    /// @return amountA     Amount of tokenA received
+    /// @return amountB     Amount of tokenB received
+    function removeLiquidity(
+        address tokenA,
+        address tokenB,
+        bool stable,
+        uint256 liquidity,
+        uint256 amountAMin,
+        uint256 amountBMin,
+        address to,
+        uint256 deadline
+    ) external returns (uint256 amountA, uint256 amountB);
+
+    /// @notice Remove liquidity of a token and WETH (returned as ETH) from a Pool
+    /// @param token            .
+    /// @param stable           True if pool is stable, false if volatile
+    /// @param liquidity        Amount of liquidity to remove
+    /// @param amountTokenMin   Minimum amount of token to receive
+    /// @param amountETHMin     Minimum amount of ETH to receive
+    /// @param to               Recipient of liquidity token
+    /// @param deadline         Deadline to receive liquidity
+    /// @return amountToken     Amount of token received
+    /// @return amountETH       Amount of ETH received
+    function removeLiquidityETH(
+        address token,
+        bool stable,
+        uint256 liquidity,
+        uint256 amountTokenMin,
+        uint256 amountETHMin,
+        address to,
+        uint256 deadline
+    ) external returns (uint256 amountToken, uint256 amountETH);
+
+    /// @notice Remove liquidity of a fee-on-transfer token and WETH (returned as ETH) from a Pool
+    /// @param token            .
+    /// @param stable           True if pool is stable, false if volatile
+    /// @param liquidity        Amount of liquidity to remove
+    /// @param amountTokenMin   Minimum amount of token to receive
+    /// @param amountETHMin     Minimum amount of ETH to receive
+    /// @param to               Recipient of liquidity token
+    /// @param deadline         Deadline to receive liquidity
+    /// @return amountETH       Amount of ETH received
+    function removeLiquidityETHSupportingFeeOnTransferTokens(
+        address token,
+        bool stable,
+        uint256 liquidity,
+        uint256 amountTokenMin,
+        uint256 amountETHMin,
+        address to,
+        uint256 deadline
+    ) external returns (uint256 amountETH);
+
+    // **** SWAP ****
+
+    /// @notice Swap one token for another
+    /// @param amountIn     Amount of token in
+    /// @param amountOutMin Minimum amount of desired token received
+    /// @param routes       Array of trade routes used in the swap
+    /// @param to           Recipient of the tokens received
+    /// @param deadline     Deadline to receive tokens
+    /// @return amounts     Array of amounts returned per route
+    function swapExactTokensForTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        Route[] calldata routes,
+        address to,
+        uint256 deadline
+    ) external returns (uint256[] memory amounts);
+
+    /// @notice Swap ETH for a token
+    /// @param amountOutMin Minimum amount of desired token received
+    /// @param routes       Array of trade routes used in the swap
+    /// @param to           Recipient of the tokens received
+    /// @param deadline     Deadline to receive tokens
+    /// @return amounts     Array of amounts returned per route
+    function swapExactETHForTokens(
+        uint256 amountOutMin,
+        Route[] calldata routes,
+        address to,
+        uint256 deadline
+    ) external payable returns (uint256[] memory amounts);
+
+    /// @notice Swap a token for WETH (returned as ETH)
+    /// @param amountIn     Amount of token in
+    /// @param amountOutMin Minimum amount of desired ETH
+    /// @param routes       Array of trade routes used in the swap
+    /// @param to           Recipient of the tokens received
+    /// @param deadline     Deadline to receive tokens
+    /// @return amounts     Array of amounts returned per route
+    function swapExactTokensForETH(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        Route[] calldata routes,
+        address to,
+        uint256 deadline
+    ) external returns (uint256[] memory amounts);
+
+    /// @notice Swap one token for another without slippage protection
+    /// @return amounts     Array of amounts to swap  per route
+    /// @param routes       Array of trade routes used in the swap
+    /// @param to           Recipient of the tokens received
+    /// @param deadline     Deadline to receive tokens
+    function UNSAFE_swapExactTokensForTokens(
+        uint256[] memory amounts,
+        Route[] calldata routes,
+        address to,
+        uint256 deadline
+    ) external returns (uint256[] memory);
+
+    // **** SWAP (supporting fee-on-transfer tokens) ****
+
+    /// @notice Swap one token for another supporting fee-on-transfer tokens
+    /// @param amountIn     Amount of token in
+    /// @param amountOutMin Minimum amount of desired token received
+    /// @param routes       Array of trade routes used in the swap
+    /// @param to           Recipient of the tokens received
+    /// @param deadline     Deadline to receive tokens
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        Route[] calldata routes,
+        address to,
+        uint256 deadline
+    ) external;
+
+    /// @notice Swap ETH for a token supporting fee-on-transfer tokens
+    /// @param amountOutMin Minimum amount of desired token received
+    /// @param routes       Array of trade routes used in the swap
+    /// @param to           Recipient of the tokens received
+    /// @param deadline     Deadline to receive tokens
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(
+        uint256 amountOutMin,
+        Route[] calldata routes,
+        address to,
+        uint256 deadline
+    ) external payable;
+
+    /// @notice Swap a token for WETH (returned as ETH) supporting fee-on-transfer tokens
+    /// @param amountIn     Amount of token in
+    /// @param amountOutMin Minimum amount of desired ETH
+    /// @param routes       Array of trade routes used in the swap
+    /// @param to           Recipient of the tokens received
+    /// @param deadline     Deadline to receive tokens
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        Route[] calldata routes,
+        address to,
+        uint256 deadline
+    ) external;
+}

package/contracts/base/interface/quickswap/IDragonLair.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.12;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IDragonLair {
+
+  function quick() external view returns (IERC20);
+
+  // Enter the lair. Pay some QUICK. Earn some dragon QUICK.
+  function enter(uint256 _quickAmount) external;
+
+  // Leave the lair. Claim back your QUICK.
+  function leave(uint256 _dQuickAmount) external;
+
+  // returns the total amount of QUICK an address has in the contract including fees earned
+  function QUICKBalance(address _account) external view returns (uint256 quickAmount_);
+
+  //returns how much QUICK someone gets for depositing dQUICK
+  function dQUICKForQUICK(uint256 _dQuickAmount) external view returns (uint256 quickAmount_);
+
+  //returns how much dQUICK someone gets for depositing QUICK
+  function QUICKForDQUICK(uint256 _quickAmount) external view returns (uint256 dQuickAmount_);
+}

package/contracts/base/interface/quickswap/IMasterChef.sol

@@ -0,0 +1,13 @@
+//SPDX-License-Identifier: Unlicense
+
+pragma solidity 0.6.12;
+
+interface IMasterChef {
+    function deposit(uint256 _pid, uint256 _amount, address _to) external;
+    function withdraw(uint256 _pid, uint256 _amount, address _to) external;
+    function emergencyWithdraw(uint256 _pid, address _to) external;
+    function userInfo(uint256 _pid, address _user) external view returns (uint256, uint256);
+    function lpToken(uint256 _pid) external view returns(address);
+    function poolInfo(uint256 _pid) external view returns (uint256, uint256, uint256);
+    function harvest(uint256 _pid, address _to) external;
+}

package/contracts/base/interface/uniswap/IUniswapV2Factory.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.0;
+
+interface IUniswapV2Factory {
+  event PairCreated(address indexed token0, address indexed token1, address pair, uint);
+
+  function getPair(address tokenA, address tokenB) external view returns (address pair);
+  function allPairs(uint) external view returns (address pair);
+  function allPairsLength() external view returns (uint);
+
+  function feeTo() external view returns (address);
+  function feeToSetter() external view returns (address);
+
+  function createPair(address tokenA, address tokenB) external returns (address pair);
+}

package/contracts/base/interface/uniswap/IUniswapV2Migrator.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.0;
+
+interface IUniswapV2Migrator {
+    function migrate(address token, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external;
+}

package/contracts/base/interface/uniswap/IUniswapV2Pair.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+/**
+ *Submitted for verification at Etherscan.io on 2020-05-05
+*/
+
+// File: contracts/interfaces/IUniswapV2Pair.sol
+
+pragma solidity >=0.5.0;
+
+interface IUniswapV2Pair {
+    event Approval(address indexed owner, address indexed spender, uint value);
+    event Transfer(address indexed from, address indexed to, uint value);
+
+    function name() external pure returns (string memory);
+    function symbol() external pure returns (string memory);
+    function decimals() external pure returns (uint8);
+    function totalSupply() external view returns (uint);
+    function balanceOf(address owner) external view returns (uint);
+    function allowance(address owner, address spender) external view returns (uint);
+
+    function approve(address spender, uint value) external returns (bool);
+    function transfer(address to, uint value) external returns (bool);
+    function transferFrom(address from, address to, uint value) external returns (bool);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+    function nonces(address owner) external view returns (uint);
+
+    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
+
+    event Mint(address indexed sender, uint amount0, uint amount1);
+    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
+    event Swap(
+        address indexed sender,
+        uint amount0In,
+        uint amount1In,
+        uint amount0Out,
+        uint amount1Out,
+        address indexed to
+    );
+    event Sync(uint112 reserve0, uint112 reserve1);
+
+    function MINIMUM_LIQUIDITY() external pure returns (uint);
+    function factory() external view returns (address);
+    function token0() external view returns (address);
+    function token1() external view returns (address);
+    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
+    function price0CumulativeLast() external view returns (uint);
+    function price1CumulativeLast() external view returns (uint);
+    function kLast() external view returns (uint);
+
+    function mint(address to) external returns (uint liquidity);
+    function burn(address to) external returns (uint amount0, uint amount1);
+    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
+    function skim(address to) external;
+    function sync() external;
+
+    function initialize(address, address) external;
+}

package/contracts/base/interface/uniswap/IUniswapV2Router01.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.0;
+
+interface IUniswapV2Router01 {
+    function factory() external pure returns (address);
+    function WETH() external pure returns (address);
+
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        uint amountADesired,
+        uint amountBDesired,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountA, uint amountB, uint liquidity);
+    function addLiquidityETH(
+        address token,
+        uint amountTokenDesired,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
+    function removeLiquidity(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountA, uint amountB);
+    function removeLiquidityETH(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountToken, uint amountETH);
+    function removeLiquidityWithPermit(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external returns (uint amountA, uint amountB);
+    function removeLiquidityETHWithPermit(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external returns (uint amountToken, uint amountETH);
+    function swapExactTokensForTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external returns (uint[] memory amounts);
+    function swapTokensForExactTokens(
+        uint amountOut,
+        uint amountInMax,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external returns (uint[] memory amounts);
+    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        payable
+        returns (uint[] memory amounts);
+    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
+        external
+        returns (uint[] memory amounts);
+    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        returns (uint[] memory amounts);
+    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
+        external
+        payable
+        returns (uint[] memory amounts);
+
+    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
+    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
+    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
+    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
+    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
+}