@dhedge/v2-sdk 2.1.7 → 2.2.0

package/src/test/velodrome.test.ts

@@ -4,111 +4,145 @@ import { Dhedge, Pool } from "..";
 import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
+  setChainlinkTimeout,
+  testingHelper
+} from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
 
-import { wallet } from "./wallet";
-
 const USDC_SUSD_Lp = "0xd16232ad60188b68076a235c65d692090caba155";
 const USDC_SUSD_Gauge = "0xb03f52d2db3e758dd49982defd6aeefea9454e80";
-const network = Network.OPTIMISM;
-const SUSD = CONTRACT_ADDRESS[network].SUSD;
-const USDC = CONTRACT_ADDRESS[network].USDC;
 
-let dhedge: Dhedge;
-let pool: Pool;
-jest.setTimeout(100000);
+const testVelodrome = ({ wallet, network, provider }: TestingRunParams) => {
+  const SUSD = CONTRACT_ADDRESS[network].SUSD;
+  const USDC = CONTRACT_ADDRESS[network].USDC;
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-  });
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
 
-  it("approves unlimited sUSD and USDC on for Velodrome", async () => {
-    await pool.approve(Dapp.VELODROME, SUSD, MAX_AMOUNT);
-    await pool.approve(Dapp.VELODROME, USDC, MAX_AMOUNT);
-    const UsdcAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network].velodrome!,
-      pool.signer
-    );
-    await expect(UsdcAllowanceDelta.gt(0));
-  });
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
 
-  it("adds USDC and SUSD to a Velodrome stable pool", async () => {
-    await pool.addLiquidityVelodrome(
-      USDC,
-      SUSD,
-      (5 * 1e6).toString(),
-      (5 * 1e18).toString(),
-      true
-    );
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
 
-    const lpTokenDelta = await balanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      pool.signer
-    );
-    expect(lpTokenDelta.gt(0));
-  });
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          await pool.managerLogic.connect(signer).changeAssets(
+            [
+              [USDC, true],
+              [SUSD, true],
+              [USDC_SUSD_Lp, false]
+            ],
+            []
+          );
+        }
+      );
+    });
 
-  it("should stake USDC-sUSD LP in a gauge", async () => {
-    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
-    await pool.approveSpender(USDC_SUSD_Gauge, USDC_SUSD_Lp, MAX_AMOUNT);
-    await pool.stakeInGauge(Dapp.VELODROME, USDC_SUSD_Gauge, balance);
-    const gaugeBalance = await balanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      pool.signer
-    );
-    expect(gaugeBalance.gt(0));
-  });
+    it("approves unlimited sUSD and USDC on for Velodrome", async () => {
+      await pool.approve(Dapp.VELODROME, SUSD, MAX_AMOUNT);
+      await pool.approve(Dapp.VELODROME, USDC, MAX_AMOUNT);
+      const UsdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network].velodrome!,
+        pool.signer
+      );
+      expect(UsdcAllowanceDelta.gt(0)).toBe(true);
+    });
 
-  it("should claim rewards from Gauge", async () => {
-    const tx = await pool.claimFees(Dapp.VELODROME, USDC_SUSD_Gauge);
-    expect(tx).not.toBe(null);
-  });
+    it("adds USDC and SUSD to a Velodrome stable pool", async () => {
+      await pool.addLiquidityVelodrome(
+        USDC,
+        SUSD,
+        (5 * 1e6).toString(),
+        (5 * 1e18).toString(),
+        true
+      );
 
-  it("should unStake USDC-sUSD LP from a gauge", async () => {
-    const gaugeBalance = await dhedge.utils.getBalance(
-      USDC_SUSD_Gauge,
-      pool.address
-    );
-    await pool.unstakeFromGauge(USDC_SUSD_Gauge, gaugeBalance);
-    const lpTokenDelta = await balanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      pool.signer
-    );
-    expect(lpTokenDelta.gt(0));
-  });
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        USDC_SUSD_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0)).toBe(true);
+    });
 
-  it("approves unlimited wETH/stwETH LP for Velodrome", async () => {
-    await pool.approve(Dapp.VELODROME, USDC_SUSD_Lp, MAX_AMOUNT);
-    const lpAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      routerAddress[network].velodrome!,
-      pool.signer
-    );
-    expect(lpAllowanceDelta.gt(0));
-  });
+    it("should stake USDC-sUSD LP in a gauge", async () => {
+      const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
+      await pool.approveSpender(USDC_SUSD_Gauge, USDC_SUSD_Lp, MAX_AMOUNT);
+      await pool.stakeInGauge(Dapp.VELODROME, USDC_SUSD_Gauge, balance);
+      const gaugeBalance = await balanceDelta(
+        pool.address,
+        USDC_SUSD_Lp,
+        pool.signer
+      );
+      expect(gaugeBalance.gt(0)).toBe(true);
+    });
+
+    it("should claim rewards from Gauge", async () => {
+      const tx = await pool.claimFees(Dapp.VELODROME, USDC_SUSD_Gauge);
+      expect(tx).not.toBe(null);
+    });
 
-  it("should remove all liquidity from an existing pool ", async () => {
-    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
-    await pool.removeLiquidityVelodrome(USDC, SUSD, balance, true);
-    const usdcBalanceDelta = await balanceDelta(
-      pool.address,
-      USDC,
-      pool.signer
-    );
-    const susdBalanceDelta = await balanceDelta(
-      pool.address,
-      SUSD,
-      pool.signer
-    );
-    expect(usdcBalanceDelta.gt(0));
-    expect(susdBalanceDelta.gt(0));
+    it("should unStake USDC-sUSD LP from a gauge", async () => {
+      const gaugeBalance = await dhedge.utils.getBalance(
+        USDC_SUSD_Gauge,
+        pool.address
+      );
+      await pool.unstakeFromGauge(USDC_SUSD_Gauge, gaugeBalance);
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        USDC_SUSD_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0)).toBe(true);
+    });
+
+    it("approves unlimited USDC-sUSD LP for Velodrome", async () => {
+      await pool.approve(Dapp.VELODROME, USDC_SUSD_Lp, MAX_AMOUNT);
+      const lpAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC_SUSD_Lp,
+        routerAddress[network].velodrome!,
+        pool.signer
+      );
+      expect(lpAllowanceDelta.gt(0)).toBe(true);
+    });
+
+    it("should remove all liquidity from an existing pool ", async () => {
+      const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
+      await pool.removeLiquidityVelodrome(USDC, SUSD, balance, true);
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      const susdBalanceDelta = await balanceDelta(
+        pool.address,
+        SUSD,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.gt(0)).toBe(true);
+      expect(susdBalanceDelta.gt(0)).toBe(true);
+    });
   });
+};
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testVelodrome
 });

package/src/test/velodromeCL.test.ts

@@ -1,22 +1,24 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 import BigNumber from "bignumber.js";
 import { Dhedge, Pool, ethers } from "..";
 
 import { nonfungiblePositionManagerAddress } from "../config";
-import { AssetEnabled, Dapp, Network } from "../types";
+import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
 import {
   TestingRunParams,
   beforeAfterReset,
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
   setChainlinkTimeout,
   setUSDCAmount,
   setWETHAmount,
   testingHelper
 } from "./utils/testingHelper";
-import { allowanceDelta, balanceDelta } from "./utils/token";
+import { balanceDelta } from "./utils/token";
 import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
 
 const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   const VELODROME_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
     Dapp.VELODROMECL
   ]!;
@@ -33,18 +35,33 @@ const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
   let tokenId: string;
   jest.setTimeout(100000);
 
-  describe(`[${network}] veldorome CL  tests`, () => {
+  describe(`[${network}] velodrome CL tests`, () => {
     beforeAll(async () => {
-      // top up ETH (gas)
       await provider.send("hardhat_setBalance", [
         wallet.address,
-        "0x100000000000000"
+        "0x10000000000000000"
       ]);
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
 
-      // setChainlinkTimeout
       await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
+
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          await pool.managerLogic.connect(signer).changeAssets(
+            [
+              [USDC, true],
+              [WETH, true],
+              [VELODROME_POSITION_MANGER, false],
+              [VELO, false]
+            ],
+            []
+          );
+        }
+      );
 
       await setUSDCAmount({
         amount: new BigNumber(10000).times(1e6).toFixed(0),
@@ -59,20 +76,6 @@ const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
         provider
       });
 
-      const newAssets: AssetEnabled[] = [
-        { asset: USDC, isDeposit: true },
-        { asset: WETH, isDeposit: true },
-        {
-          asset: VELODROME_POSITION_MANGER,
-          isDeposit: false
-        },
-        {
-          asset: VELO,
-          isDeposit: false
-        }
-      ];
-      await pool.changeAssets(newAssets);
-
       velodromePositionManager = new ethers.Contract(
         VELODROME_POSITION_MANGER,
         INonfungiblePositionManager.abi,
@@ -86,13 +89,16 @@ const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
       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,
+        const iERC20 = new ethers.Contract(
           USDC,
-          VELODROME_POSITION_MANGER,
+          ["function allowance(address,address) view returns (uint256)"],
           pool.signer
         );
-        await expect(UsdcAllowanceDelta.gt(0));
+        const usdcAllowance = await iERC20.allowance(
+          pool.address,
+          VELODROME_POSITION_MANGER
+        );
+        expect(usdcAllowance.gt(0)).toBe(true);
       });
 
       it("adds USDC and WETH to a Velodrome CL (mint position)", async () => {
@@ -114,7 +120,7 @@ const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
         tokenId = (
           await velodromePositionManager.tokenOfOwnerByIndex(pool.address, 0)
         ).toString();
-        expect(tokenId).not.toBe(null);
+        expect(tokenId).toBeDefined();
       });
 
       it("increases liquidity in a CL position", async () => {
@@ -130,7 +136,7 @@ const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
           wethBalance.div(2)
         );
         const positionAfter = await velodromePositionManager.positions(tokenId);
-        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity)).toBe(true);
       });
 
       it("decreases liquidity from a CL position", async () => {
@@ -139,14 +145,17 @@ const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
         );
         await pool.decreaseLiquidity(Dapp.VELODROMECL, tokenId, 50);
         const positionAfter = await velodromePositionManager.positions(tokenId);
-        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity)).toBe(true);
       });
 
       it("collects fess of a CL position", async () => {
-        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 3 days
         await provider.send("evm_mine", []);
         await pool.claimFees(Dapp.VELODROMECL, tokenId);
-        expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
+        // Fork has no trading activity during evm_increaseTime so no fees accrue — assert gte(0) to verify the call succeeds
+        expect(
+          (await balanceDelta(pool.address, USDC, pool.signer)).gte(0)
+        ).toBe(true);
       });
     });
     describe("Liquidity staking", () => {
@@ -186,7 +195,10 @@ const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
         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));
+        // Fork has no gauge emissions during evm_increaseTime so no VELO rewards — assert gte(0) to verify the call succeeds
+        expect(
+          (await balanceDelta(pool.address, VELO, pool.signer)).gte(0)
+        ).toBe(true);
       });
 
       it("unstakes a CL position from a gauge", async () => {

package/src/test/velodromeV2.test.ts

@@ -1,114 +1,172 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import BigNumber from "bignumber.js";
+import { ethers } from "ethers";
 import { Dhedge, Pool } from "..";
 import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
-import { allowanceDelta, balanceDelta } from "./utils/token";
+import {
+  TestingRunParams,
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
+  setChainlinkTimeout,
+  setUSDCAmount,
+  setWETHAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { balanceDelta } from "./utils/token";
 
-import { wallet } from "./wallet";
+// Velodrome V2 VARIABLE USDC/WETH pool (native USDC)
+const USDC_WETH_Lp = "0xF4F2657AE744354bAcA871E56775e5083F7276Ab";
+const USDC_WETH_Gauge = "0xBde5E1592AEb3D8396b90c4B4ba274E5Ae31e552";
 
-const USDC_SUSD_Lp = "0x6d5BA400640226e24b50214d2bBb3D4Db8e6e15a";
-const USDC_SUSD_Gauge = "0x55a272304456355242f6690863b5c8d5c512ff71";
-const network = Network.OPTIMISM;
-const SUSD = CONTRACT_ADDRESS[network].SUSD;
-const USDC = CONTRACT_ADDRESS[network].USDC;
+const testVelodromeV2 = ({ wallet, network, provider }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
 
-let dhedge: Dhedge;
-let pool: Pool;
-jest.setTimeout(100000);
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-  });
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
 
-  it("approves unlimited sUSD and USDC on for Velodrome", async () => {
-    await pool.approve(Dapp.VELODROMEV2, SUSD, MAX_AMOUNT);
-    await pool.approve(Dapp.VELODROMEV2, USDC, MAX_AMOUNT);
-    const UsdcAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network].velodromeV2!,
-      pool.signer
-    );
-    await expect(UsdcAllowanceDelta.gt(0));
-  });
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
 
-  it("adds USDC and SUSD to a Velodrome stable pool", async () => {
-    await pool.addLiquidityVelodromeV2(
-      USDC,
-      SUSD,
-      (5 * 1e6).toString(),
-      (5 * 1e18).toString(),
-      true
-    );
-
-    const lpTokenDelta = await balanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      pool.signer
-    );
-    expect(lpTokenDelta.gt(0));
-  });
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          await pool.managerLogic.connect(signer).changeAssets(
+            [
+              [USDC, true],
+              [WETH, true],
+              [USDC_WETH_Lp, false]
+            ],
+            []
+          );
+        }
+      );
 
-  it("should stake USDC-sUSD LP in a gauge", async () => {
-    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
-    await pool.approveSpender(USDC_SUSD_Gauge, USDC_SUSD_Lp, MAX_AMOUNT);
-    await pool.stakeInGauge(Dapp.VELODROMEV2, USDC_SUSD_Gauge, balance);
-    const gaugeBalance = await balanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      pool.signer
-    );
-    expect(gaugeBalance.gt(0));
-  });
+      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
+      });
+    });
 
-  it("should claim rewards from Gauge", async () => {
-    const tx = await pool.claimFees(Dapp.VELODROMEV2, USDC_SUSD_Gauge);
-    expect(tx).not.toBe(null);
-  });
+    it("approves unlimited WETH and USDC on for Velodrome", async () => {
+      await pool.approve(Dapp.VELODROMEV2, WETH, MAX_AMOUNT);
+      await pool.approve(Dapp.VELODROMEV2, USDC, MAX_AMOUNT);
+      const iERC20 = new ethers.Contract(
+        USDC,
+        ["function allowance(address,address) view returns (uint256)"],
+        pool.signer
+      );
+      const usdcAllowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network].velodromeV2!
+      );
+      expect(usdcAllowance.gt(0)).toBe(true);
+    });
 
-  it("should unStake USDC-sUSD LP from a gauge", async () => {
-    const gaugeBalance = await dhedge.utils.getBalance(
-      USDC_SUSD_Gauge,
-      pool.address
-    );
-    await pool.unstakeFromGauge(USDC_SUSD_Gauge, gaugeBalance);
-    const lpTokenDelta = await balanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      pool.signer
-    );
-    expect(lpTokenDelta.gt(0));
-  });
+    it("adds USDC and WETH to a Velodrome volatile pool", async () => {
+      await pool.addLiquidityVelodromeV2(
+        USDC,
+        WETH,
+        new BigNumber(100).times(1e6).toFixed(0),
+        new BigNumber(0.05).times(1e18).toFixed(0),
+        false
+      );
 
-  it("approves unlimited wETH/stwETH LP for Velodrome", async () => {
-    await pool.approve(Dapp.VELODROMEV2, USDC_SUSD_Lp, MAX_AMOUNT);
-    const lpAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      routerAddress[network].velodrome!,
-      pool.signer
-    );
-    expect(lpAllowanceDelta.gt(0));
-  });
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        USDC_WETH_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0)).toBe(true);
+    });
+
+    it("should stake USDC-WETH LP in a gauge", async () => {
+      const balance = await dhedge.utils.getBalance(USDC_WETH_Lp, pool.address);
+      await pool.approveSpender(USDC_WETH_Gauge, USDC_WETH_Lp, MAX_AMOUNT);
+      await pool.stakeInGauge(Dapp.VELODROMEV2, USDC_WETH_Gauge, balance);
+      const gaugeBalance = await balanceDelta(
+        pool.address,
+        USDC_WETH_Lp,
+        pool.signer
+      );
+      expect(gaugeBalance.lt(0)).toBe(true);
+    });
+
+    it("should claim rewards from Gauge", async () => {
+      const tx = await pool.claimFees(Dapp.VELODROMEV2, USDC_WETH_Gauge);
+      expect(tx).not.toBe(null);
+    });
 
-  it("should remove all liquidity from an existing pool ", async () => {
-    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
-    await pool.removeLiquidityVelodromeV2(USDC, SUSD, balance, true);
-    const usdcBalanceDelta = await balanceDelta(
-      pool.address,
-      USDC,
-      pool.signer
-    );
-    const susdBalanceDelta = await balanceDelta(
-      pool.address,
-      SUSD,
-      pool.signer
-    );
-    expect(usdcBalanceDelta.gt(0));
-    expect(susdBalanceDelta.gt(0));
+    it("should unStake USDC-WETH LP from a gauge", async () => {
+      const gaugeBalance = await dhedge.utils.getBalance(
+        USDC_WETH_Gauge,
+        pool.address
+      );
+      await pool.unstakeFromGauge(USDC_WETH_Gauge, gaugeBalance);
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        USDC_WETH_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0)).toBe(true);
+    });
+
+    it("approves unlimited USDC-WETH LP for Velodrome", async () => {
+      await pool.approve(Dapp.VELODROMEV2, USDC_WETH_Lp, MAX_AMOUNT);
+      const iERC20 = new ethers.Contract(
+        USDC_WETH_Lp,
+        ["function allowance(address,address) view returns (uint256)"],
+        pool.signer
+      );
+      const lpAllowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network].velodromeV2!
+      );
+      expect(lpAllowance.gt(0)).toBe(true);
+    });
+
+    it("should remove all liquidity from an existing pool ", async () => {
+      const balance = await dhedge.utils.getBalance(USDC_WETH_Lp, pool.address);
+      await pool.removeLiquidityVelodromeV2(USDC, WETH, balance, false);
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.gt(0)).toBe(true);
+      expect(wethBalanceDelta.gt(0)).toBe(true);
+    });
   });
+};
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testVelodromeV2
 });