@dhedge/v2-sdk 1.9.9 → 1.10.1

package/src/services/velodrome/liquidity.ts

@@ -1,16 +1,20 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { BigNumber, ethers } from "ethers";
+import { ethers } from "ethers";
 import IVelodromeRouter from "../../abi/IVeldodromeRouter.json";
+import IVelodromeCLGauge from "../../abi/IVelodromeCLGauge.json";
 import { Pool } from "../../entities";
-import { Transaction } from "../../types";
+import { Dapp, Transaction } from "../../types";
 import { getDeadline } from "../../utils/deadline";
+import { getUniswapV3Liquidity } from "../uniswap/V3Liquidity";
+import { nonfungiblePositionManagerAddress } from "../../config";
+import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
 
 export async function getVelodromeAddLiquidityTxData(
   pool: Pool,
   assetA: string,
   assetB: string,
-  amountA: BigNumber | string,
-  amountB: BigNumber | string,
+  amountA: ethers.BigNumber | string,
+  amountB: ethers.BigNumber | string,
   isStable: boolean
 ): Promise<any> {
   const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
@@ -31,7 +35,7 @@ export async function getVelodromeRemoveLiquidityTxData(
   pool: Pool,
   assetA: string,
   assetB: string,
-  amount: BigNumber | string,
+  amount: ethers.BigNumber | string,
   isStable: boolean
 ): Promise<any> {
   const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
@@ -46,3 +50,71 @@ export async function getVelodromeRemoveLiquidityTxData(
     await getDeadline(pool)
   ]);
 }
+
+export async function getVelodromeCLDecreaseStakedLiquidityTxData(
+  pool: Pool,
+  tokenId: string,
+  amount: number
+): Promise<any> {
+  const abi = new ethers.utils.Interface(IVelodromeCLGauge.abi);
+  const liquidity = (
+    await getUniswapV3Liquidity(Dapp.VELODROMECL, tokenId, pool)
+  )
+    .times(amount)
+    .div(100);
+
+  return abi.encodeFunctionData("decreaseStakedLiquidity", [
+    tokenId,
+    liquidity.toFixed(0),
+    0,
+    0,
+    await getDeadline(pool)
+  ]);
+}
+
+export async function getVelodromeCLIncreaseStakedLiquidityTxData(
+  pool: Pool,
+  tokenId: string,
+  amountA: ethers.BigNumber | string,
+  amountB: ethers.BigNumber | string
+): Promise<any> {
+  const abi = new ethers.utils.Interface(IVelodromeCLGauge.abi);
+  return abi.encodeFunctionData("increaseStakedLiquidity", [
+    tokenId,
+    amountA,
+    amountB,
+    0,
+    0,
+    await getDeadline(pool)
+  ]);
+}
+
+export async function getVelodromeCLIncreaseLiquidityTxData(
+  pool: Pool,
+  tokenId: string,
+  amountA: ethers.BigNumber | string,
+  amountB: ethers.BigNumber | string
+): Promise<any> {
+  const abi = new ethers.utils.Interface(IVelodromeCLGauge.abi);
+  return abi.encodeFunctionData("increaseStakedLiquidity", [
+    tokenId,
+    amountA,
+    amountB,
+    0,
+    0,
+    await getDeadline(pool)
+  ]);
+}
+
+export async function getVelodromeClOwner(
+  pool: Pool,
+  tokenId: string
+): Promise<string> {
+  const iNonfungiblePositionManager = new ethers.Contract(
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    nonfungiblePositionManagerAddress[pool.network][Dapp.VELODROMECL]!,
+    INonfungiblePositionManager.abi,
+    pool.signer
+  );
+  return await iNonfungiblePositionManager.ownerOf(tokenId);
+}

package/src/services/velodrome/staking.ts

@@ -2,6 +2,7 @@
 import { BigNumber, ethers } from "ethers";
 import IVelodromeGaugeV1 from "../../abi/IVelodromeGauge.json";
 import IVelodromeGaugeV2 from "../../abi/IVelodromeGaugeV2.json";
+import IVelodromeCLGauge from "../../abi/IVelodromeCLGauge.json";
 import { Pool } from "../../entities";
 import { call } from "../../utils/contract";
 const iVelodromeGaugeV1 = new ethers.utils.Interface(IVelodromeGaugeV1.abi);
@@ -42,3 +43,8 @@ export async function getVelodromeClaimTxData(
     ]);
   }
 }
+
+export async function getVelodromeCLClaimTxData(tokenId: string): Promise<any> {
+  const iVelodromeCLGauge = new ethers.utils.Interface(IVelodromeCLGauge.abi);
+  return iVelodromeCLGauge.encodeFunctionData("getReward(uint256)", [tokenId]);
+}

package/src/test/constants.ts

@@ -56,11 +56,13 @@ export const CONTRACT_ADDRESS = {
     WMATIC: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
     uniswapV3: {
       nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
-    }
+    },
+    VELODROME_CL_USDC_WETH_GAUGE: "",
+    VELO: ""
   },
 
   [Network.OPTIMISM]: {
-    USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
+    USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
     SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     SWETH: "",
     WETH: "0x4200000000000000000000000000000000000006",
@@ -69,10 +71,13 @@ export const CONTRACT_ADDRESS = {
     uniswapV3: {
       nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
     },
+
     WMATIC: "",
     //
     ARRAKIS_USDC_WETH_GAUGE: "",
-    ARRAKIS_USDC_WETH_LP: ""
+    ARRAKIS_USDC_WETH_LP: "",
+    VELODROME_CL_USDC_WETH_GAUGE: "0x8d8d1CdDD5960276A1CDE360e7b5D210C3387948",
+    VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db"
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
@@ -90,7 +95,9 @@ export const CONTRACT_ADDRESS = {
     //
     ARRAKIS_USDC_WETH_GAUGE: "",
     ARRAKIS_USDC_WETH_LP: "",
-    WMATIC: ""
+    WMATIC: "",
+    VELODROME_CL_USDC_WETH_GAUGE: "",
+    VELO: ""
   },
   [Network.BASE]: {
     USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
@@ -103,15 +110,24 @@ export const CONTRACT_ADDRESS = {
     //
     ARRAKIS_USDC_WETH_GAUGE: "",
     ARRAKIS_USDC_WETH_LP: "",
-    WMATIC: ""
+    WMATIC: "",
+    VELODROME_CL_USDC_WETH_GAUGE: "",
+    VELO: ""
   }
 };
 
 export const MAX_AMOUNT = ethers.constants.MaxUint256;
 
 export const USDC_BALANCEOF_SLOT = {
-  [Network.OPTIMISM]: 0,
+  [Network.OPTIMISM]: 9,
   [Network.ARBITRUM]: 9,
   [Network.POLYGON]: 0,
   [Network.BASE]: 9
 };
+
+export const WETH_BALANCEOF_SLOT = {
+  [Network.OPTIMISM]: 3,
+  [Network.ARBITRUM]: 51,
+  [Network.POLYGON]: 0,
+  [Network.BASE]: 0
+};

package/src/test/uniswap.test.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { FeeAmount } from "@uniswap/v3-sdk";
 import { Dhedge, ethers, Pool } from "..";
 import { routerAddress } from "../config";
 import { AssetEnabled, Dapp, Network } from "../types";
@@ -76,7 +75,7 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
         CONTRACT_ADDRESS[network].USDC,
         CONTRACT_ADDRESS[network].WETH,
         new BigNumber(5000).times(1e6).toFixed(0),
-        FeeAmount.LOW,
+        500,
         0.5
       );
 
@@ -121,15 +120,16 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
 
       try {
         result = await pool.addLiquidityUniswapV3(
+          Dapp.UNISWAPV3,
           CONTRACT_ADDRESS[network].WETH,
           CONTRACT_ADDRESS[network].USDC,
           wethBalance,
           usdcBalance,
-          2000,
-          3000,
+          3500,
+          4000,
           null,
           null,
-          FeeAmount.LOW
+          500
           // options
         );
         await result.wait(1);
@@ -155,11 +155,20 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
     });
 
     it("should increase liquidity in the existing WETH/USDC pool", async () => {
+      const usdcBalance = await dhedge.utils.getBalance(
+        CONTRACT_ADDRESS[network].USDC,
+        pool.address
+      );
+      const wethBalance = await dhedge.utils.getBalance(
+        CONTRACT_ADDRESS[network].WETH,
+        pool.address
+      );
+
       const result = await pool.increaseLiquidity(
         Dapp.UNISWAPV3,
         tokenId.toString(),
-        new BigNumber(3000).times(1e6).toFixed(0), // usdc
-        new BigNumber(1).times(1e18).toFixed(0) // eth
+        wethBalance,
+        usdcBalance // eth
       );
       // console.log("result", result);
       expect(result).not.toBe(null);
@@ -210,12 +219,12 @@ testingHelper({
   testingRun: testUniswapV3
 });
 
-testingHelper({
-  network: Network.POLYGON,
-  testingRun: testUniswapV3
-});
+// testingHelper({
+//   network: Network.POLYGON,
+//   testingRun: testUniswapV3
+// });
 
-testingHelper({
-  network: Network.ARBITRUM,
-  testingRun: testUniswapV3
-});
+// testingHelper({
+//   network: Network.ARBITRUM,
+//   testingRun: testUniswapV3
+// });

package/src/test/utils/testingHelper.ts

@@ -1,7 +1,11 @@
 import { BigNumber, ethers } from "ethers";
 import { Network } from "../../types";
 import { getWalletData } from "../wallet";
-import { CONTRACT_ADDRESS, USDC_BALANCEOF_SLOT } from "../constants";
+import {
+  CONTRACT_ADDRESS,
+  USDC_BALANCEOF_SLOT,
+  WETH_BALANCEOF_SLOT
+} from "../constants";
 
 export type TestingRunParams = {
   network: Network;
@@ -92,6 +96,26 @@ export const setUSDCAmount = async ({
   });
 };
 
+export const setWETHAmount = async ({
+  provider,
+  userAddress,
+  amount,
+  network
+}: {
+  amount: string;
+  userAddress: string;
+  provider: ethers.providers.JsonRpcProvider;
+  network: Network;
+}): Promise<void> => {
+  await setTokenAmount({
+    amount,
+    userAddress,
+    provider,
+    tokenAddress: CONTRACT_ADDRESS[network].WETH,
+    slot: WETH_BALANCEOF_SLOT[network]
+  });
+};
+
 export const wait = (seconds: number): Promise<void> => {
   return new Promise(resolve => setTimeout(resolve, seconds * 1000));
 };

package/src/test/velodromeCL.test.ts

@@ -0,0 +1,223 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import BigNumber from "bignumber.js";
+import { Dhedge, Pool, ethers } from "..";
+import { nonfungiblePositionManagerAddress } from "../config";
+import { AssetEnabled, Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setUSDCAmount,
+  setWETHAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { balanceDelta } from "./utils/token";
+import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
+
+const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
+  const VELODROME_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
+    Dapp.VELODROMECL
+  ]!;
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  const USDC_WETH_CL_GAUGE =
+    CONTRACT_ADDRESS[network].VELODROME_CL_USDC_WETH_GAUGE;
+  const VELO = CONTRACT_ADDRESS[network].VELO;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  let velodromePositionManager: ethers.Contract;
+  let tokenId: string;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] veldorome CL  tests`, () => {
+    beforeAll(async () => {
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+      await setUSDCAmount({
+        amount: new BigNumber(10000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+      await setWETHAmount({
+        amount: new BigNumber(3).times(1e18).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+
+      const newAssets: AssetEnabled[] = [
+        { asset: USDC, isDeposit: true },
+        { asset: WETH, isDeposit: true },
+        {
+          asset: VELODROME_POSITION_MANGER,
+          isDeposit: false
+        }
+      ];
+      await pool.changeAssets(newAssets);
+
+      velodromePositionManager = new ethers.Contract(
+        VELODROME_POSITION_MANGER,
+        INonfungiblePositionManager.abi,
+        pool.signer
+      );
+    });
+
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    // describe("Liquidity", () => {
+    //   it("approves unlimited USDC and WETH on for Velodrome CL", async () => {
+    //     await pool.approveSpender(VELODROME_POSITION_MANGER, USDC, MAX_AMOUNT);
+    //     await pool.approveSpender(VELODROME_POSITION_MANGER, WETH, MAX_AMOUNT);
+    //     const UsdcAllowanceDelta = await allowanceDelta(
+    //       pool.address,
+    //       USDC,
+    //       VELODROME_POSITION_MANGER,
+    //       pool.signer
+    //     );
+    //     await expect(UsdcAllowanceDelta.gt(0));
+    //   });
+
+    //   it("adds USDC and WETH to a Velodrome CL (mint position)", async () => {
+    //     const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+    //     const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+    //     await pool.addLiquidityUniswapV3(
+    //       Dapp.VELODROMECL,
+    //       USDC,
+    //       WETH,
+    //       usdcBalance.div(2),
+    //       wethBalance.div(2),
+    //       null,
+    //       null,
+    //       193700,
+    //       193900,
+    //       100
+    //     );
+
+    //     tokenId = (
+    //       await velodromePositionManager.tokenOfOwnerByIndex(pool.address, 0)
+    //     ).toString();
+    //     expect(tokenId).not.toBe(null);
+    //   });
+
+    //   it("increases liquidity in a CL position", async () => {
+    //     const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+    //     const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+    //     const positionBefore = await velodromePositionManager.positions(
+    //       tokenId
+    //     );
+    //     await pool.increaseLiquidity(
+    //       Dapp.VELODROMECL,
+    //       tokenId,
+    //       usdcBalance.div(2),
+    //       wethBalance.div(2)
+    //     );
+    //     const positionAfter = await velodromePositionManager.positions(tokenId);
+    //     expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+    //   });
+
+    //   it("decreases liquidity from a CL position", async () => {
+    //     const positionBefore = await velodromePositionManager.positions(
+    //       tokenId
+    //     );
+    //     await pool.decreaseLiquidity(Dapp.VELODROMECL, tokenId, 50);
+    //     const positionAfter = await velodromePositionManager.positions(tokenId);
+    //     expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+    //   });
+
+    //   it("collects fess of a CL position", async () => {
+    //     await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+    //     await provider.send("evm_mine", []);
+    //     await pool.claimFees(Dapp.VELODROMECL, tokenId);
+    //     expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
+    //   });
+    // });
+    describe("Liquidity staking", () => {
+      it("stakes a CL position in gauge", async () => {
+        await pool.approveSpender(VELODROME_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(VELODROME_POSITION_MANGER, WETH, MAX_AMOUNT);
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.VELODROMECL,
+          USDC,
+          WETH,
+          usdcBalance.div(2),
+          wethBalance.div(2),
+          null,
+          null,
+          193700,
+          193900,
+          100
+        );
+
+        tokenId = (
+          await velodromePositionManager.tokenOfOwnerByIndex(pool.address, 0)
+        ).toString();
+        await pool.approveSpenderNFT(
+          USDC_WETH_CL_GAUGE,
+          VELODROME_POSITION_MANGER,
+          tokenId
+        );
+        await pool.stakeInGauge(Dapp.VELODROMECL, USDC_WETH_CL_GAUGE, tokenId);
+        expect(await velodromePositionManager.ownerOf(tokenId)).toBe(
+          USDC_WETH_CL_GAUGE
+        );
+      });
+
+      it("decreases liquidity from a staked CL position", async () => {
+        const positionBefore = await velodromePositionManager.positions(
+          tokenId
+        );
+        await pool.decreaseLiquidity(Dapp.VELODROMECL, tokenId, 50);
+        const positionAfter = await velodromePositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+      });
+
+      it("increases liquidity in a staked CL position", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+        const positionBefore = await velodromePositionManager.positions(
+          tokenId
+        );
+        await pool.approveSpender(USDC_WETH_CL_GAUGE, USDC, MAX_AMOUNT);
+        await pool.approveSpender(USDC_WETH_CL_GAUGE, WETH, MAX_AMOUNT);
+        await pool.increaseLiquidity(
+          Dapp.VELODROMECL,
+          tokenId,
+          usdcBalance.div(2),
+          wethBalance.div(2)
+        );
+        const positionAfter = await velodromePositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+      });
+
+      it("collects fess of a staked CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.claimFees(Dapp.VELODROMECL, tokenId);
+        expect((await balanceDelta(pool.address, VELO, pool.signer)).gt(0));
+      });
+
+      it("unstakes a CL position from a gauge", async () => {
+        await pool.unstakeFromGauge(USDC_WETH_CL_GAUGE, tokenId);
+        expect(
+          (await velodromePositionManager.ownerOf(tokenId)).toLowerCase()
+        ).toBe(pool.address.toLowerCase());
+      });
+    });
+  });
+};
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testVelodromeCL
+});

package/src/types.ts

@@ -21,6 +21,7 @@ export enum Dapp {
   TOROS = "toros",
   VELODROME = "velodrome",
   VELODROMEV2 = "velodromeV2",
+  VELODROMECL = "velodromeCL",
   LYRA = "lyra",
   ZEROEX = "0x",
   RAMSES = "ramses",

package/dist/services/uniswap/types.d.ts

@@ -1,3 +0,0 @@
-import { FeeAmount } from "@uniswap/v3-sdk";
-import { ethers } from "ethers";
-export declare type UniswapV3MintParams = [string, string, FeeAmount, number, number, ethers.BigNumber | string, ethers.BigNumber | string, ethers.BigNumber | string, ethers.BigNumber | string, string, number];

package/src/services/uniswap/types.ts

@@ -1,16 +0,0 @@
-import { FeeAmount } from "@uniswap/v3-sdk";
-import { ethers } from "ethers";
-
-export type UniswapV3MintParams = [
-  string,
-  string,
-  FeeAmount,
-  number,
-  number,
-  ethers.BigNumber | string,
-  ethers.BigNumber | string,
-  ethers.BigNumber | string,
-  ethers.BigNumber | string,
-  string,
-  number
-];