Uniswap V3 Strategy

.vscode/settings.json

@@ -1,4 +1,5 @@
 {
+    "solidity.defaultCompiler": "localNodeModule",
     "solidity.packageDefaultDependenciesContractsDirectory": "contracts/contracts",
     "solidity.packageDefaultDependenciesDirectory": "contracts/node_modules",
     "solidity.compileUsingRemoteVersion": "v0.8.7+commit.e28d00a7",

contracts/contracts/interfaces/IUniswapV3Strategy.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity ^0.8.0;
+
+import { IStrategy } from "./IStrategy.sol";
+
+interface IUniswapV3Strategy is IStrategy {
+    function token0() external view returns (address);
+
+    function token1() external view returns (address);
+
+    function reserveStrategy(address token) external view returns (address);
+
+    function closeActivePositionOnlyVault() external;
+}

contracts/contracts/interfaces/IVault.sol

@@ -76,8 +76,12 @@ interface IVault {
 
     function approveStrategy(address _addr) external;
 
+    function approveUniswapV3Strategy(address _addr) external;
+
     function removeStrategy(address _addr) external;
 
+    function isStrategySupported(address _addr) external view returns (bool);
+
     function setAssetDefaultStrategy(address _asset, address _strategy)
         external;
 
@@ -170,4 +174,9 @@ interface IVault {
     function setNetOusdMintForStrategyThreshold(uint256 _threshold) external;
 
     function netOusdMintedForStrategy() external view returns (int256);
+
+    function depositToUniswapV3Reserve(address asset, uint256 amount) external;
+
+    function withdrawFromUniswapV3Reserve(address asset, uint256 amount)
+        external;
 }

contracts/contracts/interfaces/IVaultValueChecker.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity ^0.8.0;
+
+interface IVaultValueChecker {
+    function takeSnapshot() external;
+
+    function checkDelta(
+        int256 lowValueDelta,
+        int256 highValueDelta,
+        int256 lowSupplyDelta,
+        int256 highSupplyDelta
+    ) external;
+}

contracts/contracts/interfaces/uniswap/v3/INonfungiblePositionManager.sol

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.5;
+pragma abicoder v2;
+
+/// @title Non-fungible token for positions
+/// @notice Wraps Uniswap V3 positions in a non-fungible token interface which allows for them to be transferred
+/// and authorized.
+interface INonfungiblePositionManager {
+    /// @notice Returns the position information associated with a given token ID.
+    /// @dev Throws if the token ID is not valid.
+    /// @param tokenId The ID of the token that represents the position
+    /// @return nonce The nonce for permits
+    /// @return operator The address that is approved for spending
+    /// @return token0 The address of the token0 for a specific pool
+    /// @return token1 The address of the token1 for a specific pool
+    /// @return fee The fee associated with the pool
+    /// @return tickLower The lower end of the tick range for the position
+    /// @return tickUpper The higher end of the tick range for the position
+    /// @return liquidity The liquidity of the position
+    /// @return feeGrowthInside0LastX128 The fee growth of token0 as of the last action on the individual position
+    /// @return feeGrowthInside1LastX128 The fee growth of token1 as of the last action on the individual position
+    /// @return tokensOwed0 The uncollected amount of token0 owed to the position as of the last computation
+    /// @return tokensOwed1 The uncollected amount of token1 owed to the position as of the last computation
+    function positions(uint256 tokenId)
+        external
+        view
+        returns (
+            uint96 nonce,
+            address operator,
+            address token0,
+            address token1,
+            uint24 fee,
+            int24 tickLower,
+            int24 tickUpper,
+            uint128 liquidity,
+            uint256 feeGrowthInside0LastX128,
+            uint256 feeGrowthInside1LastX128,
+            uint128 tokensOwed0,
+            uint128 tokensOwed1
+        );
+
+    struct MintParams {
+        address token0;
+        address token1;
+        uint24 fee;
+        int24 tickLower;
+        int24 tickUpper;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        address recipient;
+        uint256 deadline;
+    }
+
+    /// @notice Creates a new position wrapped in a NFT
+    /// @dev Call this when the pool does exist and is initialized. Note that if the pool is created but not initialized
+    /// a method does not exist, i.e. the pool is assumed to be initialized.
+    /// @param params The params necessary to mint a position, encoded as `MintParams` in calldata
+    /// @return tokenId The ID of the token that represents the minted position
+    /// @return liquidity The amount of liquidity for this position
+    /// @return amount0 The amount of token0
+    /// @return amount1 The amount of token1
+    function mint(MintParams calldata params)
+        external
+        payable
+        returns (
+            uint256 tokenId,
+            uint128 liquidity,
+            uint256 amount0,
+            uint256 amount1
+        );
+
+    struct IncreaseLiquidityParams {
+        uint256 tokenId;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Increases the amount of liquidity in a position, with tokens paid by the `msg.sender`
+    /// @param params tokenId The ID of the token for which liquidity is being increased,
+    /// amount0Desired The desired amount of token0 to be spent,
+    /// amount1Desired The desired amount of token1 to be spent,
+    /// amount0Min The minimum amount of token0 to spend, which serves as a slippage check,
+    /// amount1Min The minimum amount of token1 to spend, which serves as a slippage check,
+    /// deadline The time by which the transaction must be included to effect the change
+    /// @return liquidity The new liquidity amount as a result of the increase
+    /// @return amount0 The amount of token0 to acheive resulting liquidity
+    /// @return amount1 The amount of token1 to acheive resulting liquidity
+    function increaseLiquidity(IncreaseLiquidityParams calldata params)
+        external
+        payable
+        returns (
+            uint128 liquidity,
+            uint256 amount0,
+            uint256 amount1
+        );
+
+    struct DecreaseLiquidityParams {
+        uint256 tokenId;
+        uint128 liquidity;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    /// @notice Decreases the amount of liquidity in a position and accounts it to the position
+    /// @param params tokenId The ID of the token for which liquidity is being decreased,
+    /// amount The amount by which liquidity will be decreased,
+    /// amount0Min The minimum amount of token0 that should be accounted for the burned liquidity,
+    /// amount1Min The minimum amount of token1 that should be accounted for the burned liquidity,
+    /// deadline The time by which the transaction must be included to effect the change
+    /// @return amount0 The amount of token0 accounted to the position's tokens owed
+    /// @return amount1 The amount of token1 accounted to the position's tokens owed
+    function decreaseLiquidity(DecreaseLiquidityParams calldata params)
+        external
+        payable
+        returns (uint256 amount0, uint256 amount1);
+
+    struct CollectParams {
+        uint256 tokenId;
+        address recipient;
+        uint128 amount0Max;
+        uint128 amount1Max;
+    }
+
+    /// @notice Collects up to a maximum amount of fees owed to a specific position to the recipient
+    /// @param params tokenId The ID of the NFT for which tokens are being collected,
+    /// recipient The account that should receive the tokens,
+    /// amount0Max The maximum amount of token0 to collect,
+    /// amount1Max The maximum amount of token1 to collect
+    /// @return amount0 The amount of fees collected in token0
+    /// @return amount1 The amount of fees collected in token1
+    function collect(CollectParams calldata params)
+        external
+        payable
+        returns (uint256 amount0, uint256 amount1);
+
+    /// @notice Burns a token ID, which deletes it from the NFT contract. The token must have 0 liquidity and all tokens
+    /// must be collected first.
+    /// @param tokenId The ID of the token that is being burned
+    function burn(uint256 tokenId) external payable;
+}

contracts/contracts/interfaces/uniswap/v3/IUniswapV3Helper.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity ^0.8.0;
+
+import { INonfungiblePositionManager } from "./INonfungiblePositionManager.sol";
+
+interface IUniswapV3Helper {
+    function getAmountsForLiquidity(
+        uint160 sqrtRatioX96,
+        uint160 sqrtRatioAX96,
+        uint160 sqrtRatioBX96,
+        uint128 liquidity
+    ) external view returns (uint256 amount0, uint256 amount1);
+
+    function getLiquidityForAmounts(
+        uint160 sqrtRatioX96,
+        uint160 sqrtRatioAX96,
+        uint160 sqrtRatioBX96,
+        uint256 amount0,
+        uint256 amount1
+    ) external view returns (uint128 liquidity);
+
+    function getSqrtRatioAtTick(int24 tick)
+        external
+        view
+        returns (uint160 sqrtPriceX96);
+
+    function positionFees(
+        INonfungiblePositionManager positionManager,
+        address poolAddress,
+        uint256 tokenId
+    ) external view returns (uint256 amount0, uint256 amount1);
+
+    function positionTotal(
+        INonfungiblePositionManager positionManager,
+        address poolAddress,
+        uint256 tokenId,
+        uint160 sqrtRatioX96
+    ) external view returns (uint256 amount0, uint256 amount1);
+
+    function positionPrincipal(
+        INonfungiblePositionManager positionManager,
+        uint256 tokenId,
+        uint160 sqrtRatioX96
+    ) external view returns (uint256 amount0, uint256 amount1);
+}

contracts/contracts/mocks/MockStrategy.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity ^0.8.0;
+
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract MockStrategy {
+    using SafeERC20 for IERC20;
+
+    address public vaultAddress;
+    mapping(address => bool) public supportsAsset;
+    address[] internal allAssets;
+
+    modifier onlyVault() {
+        require(msg.sender == vaultAddress, "Not vault");
+        _;
+    }
+
+    constructor(address _vaultAddress, address[] memory assets) {
+        vaultAddress = _vaultAddress;
+        for (uint256 i = 0; i < assets.length; i++) {
+            address asset = assets[i];
+            supportsAsset[asset] = true;
+            allAssets.push(asset);
+        }
+    }
+
+    function deposit(address _asset, uint256 _amount) public onlyVault {
+        // Do nothing
+    }
+
+    function depositAll() public onlyVault {
+        // Do nothing
+    }
+
+    function withdraw(address _asset, uint256 _amount) public onlyVault {
+        IERC20(_asset).safeTransfer(vaultAddress, _amount);
+    }
+
+    function withdraw(
+        address _recipient,
+        address _asset,
+        uint256 _amount
+    ) external onlyVault {
+        IERC20(_asset).safeTransfer(_recipient, _amount);
+    }
+
+    function checkBalance(address _asset)
+        external
+        view
+        returns (uint256 balance)
+    {
+        balance = IERC20(_asset).balanceOf(address(this));
+    }
+
+    function withdrawAll() public onlyVault {
+        for (uint256 i = 0; i < allAssets.length; i++) {
+            IERC20 asset = IERC20(allAssets[i]);
+            asset.safeTransfer(vaultAddress, asset.balanceOf(address(this)));
+        }
+    }
+
+    function collectRewardTokens() external {
+        // Do nothing
+    }
+
+    function getRewardTokenAddresses()
+        external
+        view
+        returns (address[] memory)
+    {
+        return new address[](0);
+    }
+}

contracts/contracts/mocks/MockMintableUniswapPair.sol → contracts/contracts/mocks/uniswap/v2/MockMintableUniswapPair.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "./MintableERC20.sol";
+import "./../../MintableERC20.sol";
 import "./MockUniswapPair.sol";
 
 contract MockMintableUniswapPair is MockUniswapPair, MintableERC20 {

contracts/contracts/mocks/MockUniswapPair.sol → contracts/contracts/mocks/uniswap/v2/MockUniswapPair.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import { IUniswapV2Pair } from "../interfaces/uniswap/IUniswapV2Pair.sol";
+import { IUniswapV2Pair } from "../../../interfaces/uniswap/IUniswapV2Pair.sol";
 
 contract MockUniswapPair is IUniswapV2Pair {
     address tok0;

contracts/contracts/mocks/MockUniswapRouter.sol → contracts/contracts/mocks/uniswap/v2/MockUniswapRouter.sol

@@ -3,9 +3,9 @@ pragma solidity ^0.8.0;
 
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
-import { IUniswapV2Router } from "../interfaces/uniswap/IUniswapV2Router02.sol";
-import { Helpers } from "../utils/Helpers.sol";
-import { StableMath } from "../utils/StableMath.sol";
+import { IUniswapV2Router } from "../../../interfaces/uniswap/IUniswapV2Router02.sol";
+import { Helpers } from "../../../utils/Helpers.sol";
+import { StableMath } from "../../../utils/StableMath.sol";
 
 // import "hardhat/console.sol";
 
@@ -121,4 +121,36 @@ contract MockUniswapRouter is IUniswapV2Router {
     function WETH() external pure override returns (address) {
         return address(0);
     }
+
+    struct ExactInputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 deadline;
+        uint256 amountIn;
+        uint256 amountOutMinimum;
+        uint160 sqrtPriceLimitX96;
+    }
+
+    function exactInputSingle(ExactInputSingleParams calldata params)
+        external
+        payable
+        returns (uint256 amountOut)
+    {
+        amountOut = params.amountIn.scaleBy(
+            Helpers.getDecimals(params.tokenIn),
+            Helpers.getDecimals(params.tokenOut)
+        );
+        IERC20(params.tokenIn).transferFrom(
+            msg.sender,
+            address(this),
+            params.amountIn
+        );
+        IERC20(params.tokenOut).transfer(params.recipient, amountOut);
+        require(
+            amountOut >= params.amountOutMinimum,
+            "UniswapMock: amountOut less than amountOutMinimum"
+        );
+    }
 }