@dhedge/v2-sdk 1.9.9 → 1.10.1

package/src/entities/pool.ts

@@ -3,13 +3,14 @@
 import { Contract, ethers, Wallet, BigNumber } from "ethers";
 
 import IERC20 from "../abi/IERC20.json";
+
+import IERC721 from "../abi/IERC721.json";
 import IMiniChefV2 from "../abi/IMiniChefV2.json";
 import ILendingPool from "../abi/ILendingPool.json";
 import ISynthetix from "../abi/ISynthetix.json";
 import IUniswapV2Router from "../abi/IUniswapV2Router.json";
 import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
 import IAaveIncentivesController from "../abi/IAaveIncentivesController.json";
-import IArrakisV1RouterStaking from "../abi/IArrakisV1RouterStaking.json";
 import ILiquidityGaugeV4 from "../abi/ILiquidityGaugeV4.json";
 import IBalancerRewardsGauge from "../abi/IBalancerRewardsGauge.json";
 
@@ -34,19 +35,23 @@ import {
 
 import { Utils } from "./utils";
 import {
-  getUniswapV3Liquidity,
-  getUniswapV3MintParams
+  getDecreaseLiquidityTxData,
+  getIncreaseLiquidityTxData,
+  getUniswapV3MintTxData
 } from "../services/uniswap/V3Liquidity";
-import { FeeAmount } from "@uniswap/v3-sdk";
 import { getUniswapV3SwapTxData } from "../services/uniswap/V3Trade";
 import { getEasySwapperTxData } from "../services/toros/easySwapper";
 import { getAaveV3ClaimTxData } from "../services/aave/incentives";
 import {
   getVelodromeAddLiquidityTxData,
+  getVelodromeCLDecreaseStakedLiquidityTxData,
+  getVelodromeCLIncreaseStakedLiquidityTxData,
+  getVelodromeClOwner,
   getVelodromeRemoveLiquidityTxData
 } from "../services/velodrome/liquidity";
 import {
   getVelodromeClaimTxData,
+  getVelodromeCLClaimTxData,
   getVelodromeStakeTxData
 } from "../services/velodrome/staking";
 import { getLyraOptionTxData } from "../services/lyra/trade";
@@ -261,7 +266,7 @@ export class Pool {
   ): Promise<any> {
     const iERC20 = new ethers.utils.Interface(IERC20.abi);
     const approveTxData = iERC20.encodeFunctionData("approve", [
-      nonfungiblePositionManagerAddress[this.network],
+      nonfungiblePositionManagerAddress[this.network][Dapp.UNISWAPV3],
       amount
     ]);
     const tx = await getPoolTxOrGasEstimate(
@@ -301,6 +306,35 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Approve NFT for provided spender address
+   * @param {string} spender Spender address
+   * @param {string} asset Address of asset
+   * @param {string} tokenId NFT id
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async approveSpenderNFT(
+    spender: string,
+    asset: string,
+    tokenId: string,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const iERC721 = new ethers.utils.Interface(IERC721.abi);
+    const approveTxData = iERC721.encodeFunctionData("approve", [
+      spender,
+      tokenId
+    ]);
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [asset, approveTxData, options],
+      estimateGas
+    );
+    return tx;
+  }
+
   /**
    * Trade an asset into another asset
    * @param {Dapp} dapp Platform like Sushiswap or Uniswap
@@ -509,7 +543,7 @@ export class Pool {
    * Stake liquidity pool tokens in gauge contract
    * @param {Dapp} dapp Platform like Balancer or Velodrome
    * @param {string} gauge Gauge contract address
-   * @param {BigNumber | string} amount Amount of liquidity pool tokens
+   * @param {BigNumber | string} amount Amount of liquidity pool tokens or token ID for Velodrome CL
    * @param {any} options Transaction options
    * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
@@ -537,6 +571,7 @@ export class Pool {
         break;
       case Dapp.VELODROMEV2:
       case Dapp.AERODROME:
+      case Dapp.VELODROMECL:
         stakeTxData = getVelodromeStakeTxData(amount, true);
         break;
       default:
@@ -584,7 +619,7 @@ export class Pool {
   /**
    * Unstake liquidity pool tokens from Velodrome or Balancer gauge
    * @param {string} gauge Gauge contract address
-   * @param {BigNumber | string} amount Amount of liquidity pool tokens
+   * @param {BigNumber | string} amount Amount of liquidity pool tokens or CL token ID
    * @param {any} options Transaction options
    * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
@@ -946,6 +981,7 @@ export class Pool {
 
   /**
    * Create UniswapV3 liquidity pool
+   * @param {dapp} Platform either UniswapV3 or VelodromeCL
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amountA Amount first asset
@@ -954,12 +990,13 @@ export class Pool {
    * @param { number } maxPrice Upper price range (assetB per assetA)
    * @param { number } minTick Lower tick range
    * @param { number } maxTick Upper tick range
-   * @param { FeeAmount } feeAmount Fee tier (Low 0.05%, Medium 0.3%, High 1%)
+   * @param { number } feeAmountOrTickSpacing Fee tier UniswapV3 or tick spacing VelodromeCL
    * @param {any} options Transaction options
    * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   async addLiquidityUniswapV3(
+    dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
     assetA: string,
     assetB: string,
     amountA: BigNumber | string,
@@ -968,7 +1005,7 @@ export class Pool {
     maxPrice: number | null,
     minTick: number | null,
     maxTick: number | null,
-    feeAmount: FeeAmount,
+    feeAmountOrTickSpacing: number,
     options: any = null,
     estimateGas = false
   ): Promise<any> {
@@ -977,12 +1014,11 @@ export class Pool {
       (minTick === null || maxTick === null)
     )
       throw new Error("Need to provide price or tick range");
+    if ((minPrice || maxPrice) && dapp === Dapp.VELODROMECL)
+      throw new Error("no price conversion for Velodrome CL");
 
-    const iNonfungiblePositionManager = new ethers.utils.Interface(
-      INonfungiblePositionManager.abi
-    );
-
-    const mintTxParams = await getUniswapV3MintParams(
+    const mintTxData = await getUniswapV3MintTxData(
+      dapp,
       this,
       assetA,
       assetB,
@@ -992,15 +1028,16 @@ export class Pool {
       maxPrice,
       minTick,
       maxTick,
-      feeAmount
-    );
-    const mintTxData = iNonfungiblePositionManager.encodeFunctionData(
-      Transaction.MINT,
-      [mintTxParams]
+      feeAmountOrTickSpacing
     );
+
     const tx = await getPoolTxOrGasEstimate(
       this,
-      [nonfungiblePositionManagerAddress[this.network], mintTxData, options],
+      [
+        nonfungiblePositionManagerAddress[this.network][dapp],
+        mintTxData,
+        options
+      ],
       estimateGas
     );
     return tx;
@@ -1022,46 +1059,37 @@ export class Pool {
     options: any = null,
     estimateGas = false
   ): Promise<any> {
-    let txData;
     let dappAddress;
-    if (dapp === Dapp.UNISWAPV3) {
-      dappAddress = nonfungiblePositionManagerAddress[this.network];
-      const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
-      const liquidity = (await getUniswapV3Liquidity(tokenId, this))
-        .mul(Math.round(amount * 1e4))
-        .div(1e6);
-      const decreaseLiquidityTxData = abi.encodeFunctionData(
-        Transaction.DECREASE_LIQUIDITY,
-        [[tokenId, liquidity, 0, 0, await getDeadline(this)]]
-      );
-      const collectTxData = abi.encodeFunctionData(Transaction.COLLECT, [
-        [tokenId, this.address, MaxUint128, MaxUint128]
-      ]);
-
-      const multicallParams = [decreaseLiquidityTxData, collectTxData];
-
-      if (amount === 100) {
-        const burnTxData = abi.encodeFunctionData(Transaction.BURN, [tokenId]);
-        multicallParams.push(burnTxData);
-      }
-      txData = abi.encodeFunctionData(Transaction.MULTI_CALL, [
-        multicallParams
-      ]);
-    } else if (dapp === Dapp.ARRAKIS) {
-      dappAddress = routerAddress[this.network][dapp];
-      const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
-      const liquidity = (await this.utils.getBalance(tokenId, this.address))
-        .mul(Math.round(amount * 1e4))
-        .div(1e6);
-      txData = abi.encodeFunctionData(Transaction.REMOVE_LIQUIDITY_UNSTAKE, [
-        tokenId,
-        liquidity,
-        0,
-        0,
-        this.address
-      ]);
+    let isStaked = false;
+    let txData;
+    switch (dapp) {
+      case Dapp.UNISWAPV3:
+        dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
+        break;
+      case Dapp.VELODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+        if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
+          dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
+        } else {
+          //staked in gauge
+          dappAddress = tokenIdOwner;
+          isStaked = true;
+        }
+        break;
+      case Dapp.ARRAKIS:
+        dappAddress = routerAddress[this.network][dapp];
+        break;
+      default:
+        throw new Error("dapp not supported");
+    }
+    if (!isStaked) {
+      txData = await getDecreaseLiquidityTxData(this, dapp, tokenId, amount);
     } else {
-      throw new Error("dapp not supported");
+      txData = await getVelodromeCLDecreaseStakedLiquidityTxData(
+        this,
+        tokenId,
+        amount
+      );
     }
     const tx = await getPoolTxOrGasEstimate(
       this,
@@ -1072,7 +1100,7 @@ export class Pool {
   }
 
   /**
-   * Increase liquidity of an UniswapV3 or Arrakis liquidity pool
+   * Increase liquidity of an UniswapV, VelodromeCL or Arrakis liquidity pool
    * @param {Dapp} dapp Platform either UniswapV3 or Arrakis
    * @param {string} tokenId Token Id of UniswapV3 position
    * @param {BigNumber | string} amountA Amount first asset
@@ -1089,28 +1117,44 @@ export class Pool {
     options: any = null,
     estimateGas = false
   ): Promise<any> {
-    let txData;
     let dappAddress;
-    if (dapp === Dapp.UNISWAPV3) {
-      dappAddress = nonfungiblePositionManagerAddress[this.network];
-      const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
-      txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
-        [tokenId, amountA, amountB, 0, 0, await getDeadline(this)]
-      ]);
-    } else if (dapp === Dapp.ARRAKIS) {
-      dappAddress = routerAddress[this.network][dapp];
-      const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
-      txData = abi.encodeFunctionData(Transaction.ADD_LIQUIDITY_STAKE, [
+    let isStaked = false;
+    let txData;
+    switch (dapp) {
+      case Dapp.UNISWAPV3:
+        dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
+        break;
+      case Dapp.VELODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+        if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
+          dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
+        } else {
+          //staked in gauge
+          dappAddress = tokenIdOwner;
+          isStaked = true;
+        }
+        break;
+      case Dapp.ARRAKIS:
+        dappAddress = routerAddress[this.network][dapp];
+        break;
+      default:
+        throw new Error("dapp not supported");
+    }
+    if (!isStaked) {
+      txData = await getIncreaseLiquidityTxData(
+        this,
+        dapp,
         tokenId,
         amountA,
-        amountB,
-        0,
-        0,
-        0,
-        this.address
-      ]);
+        amountB
+      );
     } else {
-      throw new Error("dapp not supported");
+      txData = await getVelodromeCLIncreaseStakedLiquidityTxData(
+        this,
+        tokenId,
+        amountA,
+        amountB
+      );
     }
     const tx = await getPoolTxOrGasEstimate(
       this,
@@ -1136,12 +1180,12 @@ export class Pool {
   ): Promise<any> {
     let txData;
     let contractAddress;
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
     switch (dapp) {
       case Dapp.UNISWAPV3:
-        contractAddress = nonfungiblePositionManagerAddress[this.network];
-        const iNonfungiblePositionManager = new ethers.utils.Interface(
-          INonfungiblePositionManager.abi
-        );
+        contractAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         txData = iNonfungiblePositionManager.encodeFunctionData(
           Transaction.COLLECT,
           [[tokenId, this.address, MaxUint128, MaxUint128]]
@@ -1163,6 +1207,21 @@ export class Pool {
         contractAddress = tokenId;
         txData = getVelodromeClaimTxData(this, tokenId, true);
         break;
+      case Dapp.VELODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+        if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
+          contractAddress =
+            nonfungiblePositionManagerAddress[this.network][dapp];
+          txData = iNonfungiblePositionManager.encodeFunctionData(
+            Transaction.COLLECT,
+            [[tokenId, this.address, MaxUint128, MaxUint128]]
+          );
+        } else {
+          //staked in gauge
+          contractAddress = tokenIdOwner;
+          txData = getVelodromeCLClaimTxData(tokenId);
+        }
+        break;
       default:
         throw new Error("dapp not supported");
     }
@@ -1190,7 +1249,7 @@ export class Pool {
     assetFrom: string,
     assetTo: string,
     amountIn: BigNumber | string,
-    feeAmount: FeeAmount,
+    feeAmount: number,
     slippage = 0.5,
     options: any = null,
     estimateGas = false

package/src/services/lyra/trade.ts

@@ -27,7 +27,7 @@ export async function getLyraOptionTxData(
   const filteredPosition = positions.filter(
     e =>
       e.strikeId.toNumber() === strikeId &&
-      isCall(e.optionType) == (optionType === "call") &&
+      isCall(e.optionType) === (optionType === "call") &&
       e.state === 1
   );
   const positionId =

package/src/services/uniswap/V3Liquidity.ts

@@ -1,4 +1,6 @@
-import { Price, Token } from "@uniswap/sdk-core";
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Token, Price } from "@uniswap/sdk-core";
 import {
   encodeSqrtRatioX96,
   FeeAmount,
@@ -9,14 +11,17 @@ import {
 } from "@uniswap/v3-sdk";
 import { ethers } from "ethers";
 import JSBI from "jsbi";
-import { Pool } from "../..";
+import { Dapp, Pool, Transaction } from "../..";
 import {
+  MaxUint128,
   networkChainIdMap,
   nonfungiblePositionManagerAddress
 } from "../../config";
-import { UniswapV3MintParams } from "./types";
 import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
+import IVeldodromePositionManager from "../../abi/IVelodromeNonfungiblePositionManager.json";
+import IArrakisV1RouterStaking from "../../abi/IArrakisV1RouterStaking.json";
 import { getDeadline } from "../../utils/deadline";
+import BigNumber from "bignumber.js";
 
 export function tryParsePrice(
   baseToken: Token,
@@ -42,7 +47,7 @@ export function tryParsePrice(
 export function tryParseTick(
   baseToken: Token,
   quoteToken: Token,
-  feeAmount: FeeAmount,
+  feeAmount: number,
   value: string
 ): number {
   const price = tryParsePrice(baseToken, quoteToken, value);
@@ -61,10 +66,11 @@ export function tryParseTick(
     tick = priceToClosestTick(price);
   }
 
-  return nearestUsableTick(tick, TICK_SPACINGS[feeAmount]);
+  return nearestUsableTick(tick, TICK_SPACINGS[feeAmount as FeeAmount]);
 }
 
-export async function getUniswapV3MintParams(
+export async function getUniswapV3MintTxData(
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
   pool: Pool,
   assetA: string,
   assetB: string,
@@ -74,8 +80,8 @@ export async function getUniswapV3MintParams(
   maxPrice: number | null,
   minTick: number | null,
   maxTick: number | null,
-  feeAmount: FeeAmount
-): Promise<UniswapV3MintParams> {
+  feeAmountOrTickSpacing: number
+): Promise<any> {
   let tickLower = 0;
   let tickUpper = 0;
   const chainId = networkChainIdMap[pool.network];
@@ -88,14 +94,33 @@ export async function getUniswapV3MintParams(
     ? [tokenA, tokenB]
     : [tokenB, tokenA];
   const invertPrice = !tokenA.equals(token0);
-
   if (minPrice && maxPrice) {
     tickLower = invertPrice
-      ? tryParseTick(token1, token0, feeAmount, maxPrice.toString())
-      : tryParseTick(token0, token1, feeAmount, minPrice.toString());
+      ? tryParseTick(
+          token1,
+          token0,
+          feeAmountOrTickSpacing,
+          maxPrice.toString()
+        )
+      : tryParseTick(
+          token0,
+          token1,
+          feeAmountOrTickSpacing,
+          minPrice.toString()
+        );
     tickUpper = invertPrice
-      ? tryParseTick(token1, token0, feeAmount, minPrice.toString())
-      : tryParseTick(token0, token1, feeAmount, maxPrice.toString());
+      ? tryParseTick(
+          token1,
+          token0,
+          feeAmountOrTickSpacing,
+          minPrice.toString()
+        )
+      : tryParseTick(
+          token0,
+          token1,
+          feeAmountOrTickSpacing,
+          maxPrice.toString()
+        );
   } else if (minTick && maxTick) {
     tickLower = minTick;
     tickUpper = maxTick;
@@ -104,10 +129,10 @@ export async function getUniswapV3MintParams(
     ? [amountB, amountA]
     : [amountA, amountB];
 
-  return [
+  const mintParams = [
     token0.address,
     token1.address,
-    feeAmount,
+    feeAmountOrTickSpacing,
     tickLower,
     tickUpper,
     amount0,
@@ -117,17 +142,115 @@ export async function getUniswapV3MintParams(
     pool.address,
     await getDeadline(pool)
   ];
+
+  let iNonfungiblePositionManager = new ethers.utils.Interface(
+    INonfungiblePositionManager.abi
+  );
+
+  if (dapp === Dapp.VELODROMECL) {
+    iNonfungiblePositionManager = new ethers.utils.Interface(
+      IVeldodromePositionManager.abi
+    );
+    mintParams.push(0);
+  }
+
+  return iNonfungiblePositionManager.encodeFunctionData(Transaction.MINT, [
+    mintParams
+  ]);
+
+  return;
 }
 
 export async function getUniswapV3Liquidity(
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
   tokenId: string,
   pool: Pool
-): Promise<ethers.BigNumber> {
+): Promise<BigNumber> {
   const iNonfungiblePositionManager = new ethers.Contract(
-    nonfungiblePositionManagerAddress[pool.network],
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    nonfungiblePositionManagerAddress[pool.network][dapp]!,
     INonfungiblePositionManager.abi,
     pool.signer
   );
   const result = await iNonfungiblePositionManager.positions(tokenId);
-  return result.liquidity;
+  return new BigNumber(result.liquidity.toString());
+}
+
+export async function getIncreaseLiquidityTxData(
+  pool: Pool,
+  dapp: Dapp,
+  tokenId: string,
+  amountA: ethers.BigNumber | string,
+  amountB: ethers.BigNumber | string
+): Promise<any> {
+  let txData;
+  if (dapp === Dapp.UNISWAPV3 || dapp === Dapp.VELODROMECL) {
+    const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
+    txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
+      [tokenId, amountA, amountB, 0, 0, await getDeadline(pool)]
+    ]);
+  } else if (dapp === Dapp.ARRAKIS) {
+    const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
+    txData = abi.encodeFunctionData(Transaction.ADD_LIQUIDITY_STAKE, [
+      tokenId,
+      amountA,
+      amountB,
+      0,
+      0,
+      0,
+      pool.address
+    ]);
+  } else {
+    throw new Error("dapp not supported");
+  }
+
+  return txData;
+}
+
+export async function getDecreaseLiquidityTxData(
+  pool: Pool,
+  dapp: Dapp,
+  tokenId: string,
+  amount = 100
+): Promise<any> {
+  let txData;
+  if (dapp === Dapp.UNISWAPV3 || dapp === Dapp.VELODROMECL) {
+    const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
+    const liquidity = (await getUniswapV3Liquidity(dapp, tokenId, pool))
+      .times(amount)
+      .div(100);
+
+    const decreaseLiquidityTxData = abi.encodeFunctionData(
+      Transaction.DECREASE_LIQUIDITY,
+      [[tokenId, liquidity.toFixed(0), 0, 0, await getDeadline(pool)]]
+    );
+    const collectTxData = abi.encodeFunctionData(Transaction.COLLECT, [
+      [tokenId, pool.address, MaxUint128, MaxUint128]
+    ]);
+
+    const multicallParams = [decreaseLiquidityTxData, collectTxData];
+
+    if (amount === 100) {
+      const burnTxData = abi.encodeFunctionData(Transaction.BURN, [tokenId]);
+      multicallParams.push(burnTxData);
+    }
+    txData = abi.encodeFunctionData(Transaction.MULTI_CALL, [multicallParams]);
+  } else if (dapp === Dapp.ARRAKIS) {
+    const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
+    const liquidity = new BigNumber(
+      (await pool.utils.getBalance(tokenId, pool.address)).toString()
+    )
+      .times(amount)
+      .div(100);
+    txData = abi.encodeFunctionData(Transaction.REMOVE_LIQUIDITY_UNSTAKE, [
+      tokenId,
+      liquidity,
+      0,
+      0,
+      pool.address
+    ]);
+  } else {
+    throw new Error("dapp not supported");
+  }
+  return txData;
 }

package/src/services/uniswap/V3Trade.ts

@@ -1,4 +1,3 @@
-import { FeeAmount } from "@uniswap/v3-sdk";
 import { ethers } from "ethers";
 import { Pool } from "../..";
 
@@ -12,7 +11,7 @@ export async function getUniswapV3SwapTxData(
   assetB: string,
   amountIn: string | ethers.BigNumber,
   slippage: number,
-  feeAmount: FeeAmount
+  feeAmount: number
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): Promise<any> {
   const quoterContract = new ethers.Contract(