@dhedge/v2-sdk 1.9.6 → 1.9.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",

package/src/config.ts

@@ -47,7 +47,7 @@ export const routerAddress: AddressDappNetworkMap = {
   },
   [Network.ARBITRUM]: {
     [Dapp.ONEINCH]: "0x1111111254EEB25477B68fb85Ed929f73A960582",
-    [Dapp.UNISWAPV3]: "0xe592427a0aece92de3edee1f18e0157c05861564",
+    [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
     [Dapp.AAVEV3]: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
     [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8",
     [Dapp.RAMSES]: "0xaaa87963efeb6f7e0a2711f397663105acb1805e"

package/src/entities/pool.ts

@@ -119,14 +119,19 @@ export class Pool {
    * @param {string} nasset Address of deposit asset
    * @param {BigNumber | string} amount Amount to be approved
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   async approveDeposit(
     asset: string,
     amount: BigNumber | string,
-    options: any = null
+    options: any = null,
+    estimateGas = false
   ): Promise<any> {
     const iERC20 = new ethers.Contract(asset, IERC20.abi, this.signer);
+    if (estimateGas) {
+      return await iERC20.estimateGas.approve(this.address, amount, options);
+    }
     const tx = await iERC20.approve(this.address, amount, options);
     return tx;
   }
@@ -136,13 +141,18 @@ export class Pool {
    * @param {string} asset Address of asset
    * @param {BigNumber | string} amount Amount to be deposited
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   async deposit(
     asset: string,
     amount: string | BigNumber,
-    options: any = null
+    options: any = null,
+    estimateGas = false
   ): Promise<any> {
+    if (estimateGas) {
+      return await this.poolLogic.estimateGas.deposit(asset, amount, options);
+    }
     const tx = await this.poolLogic.deposit(asset, amount, options);
     return tx;
   }
@@ -151,12 +161,20 @@ export class Pool {
    * Withdraw  assets from a pool
    * @param fundTokenAmount Amount of pool tokens to be withdrawn
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   async withdraw(
     fundTokenAmount: string | BigNumber,
-    options: any = null
+    options: any = null,
+    estimateGas = false
   ): Promise<any> {
+    if (estimateGas) {
+      return await this.poolLogic.estimateGas.withdraw(
+        fundTokenAmount,
+        options
+      );
+    }
     const tx = await this.poolLogic.withdraw(fundTokenAmount, options);
     return tx;
   }
@@ -742,11 +760,13 @@ export class Pool {
    * Change enabled pool assets
    * @param {AssetEnabled[]} assets New pool assets
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
   public async changeAssets(
     assets: AssetEnabled[],
-    options: any = null
+    options: any = null,
+    estimateGas = false
   ): Promise<any> {
     const currentAssetsEnabled = await this.getComposition();
     const currentAssets = currentAssetsEnabled.map(e =>
@@ -755,6 +775,14 @@ export class Pool {
     const newAssets = assets.map(e => e.asset.toLocaleLowerCase());
     const removedAssets = currentAssets.filter(e => !newAssets.includes(e));
     const changedAssets = assets.map(e => [e.asset, e.isDeposit]);
+
+    if (estimateGas) {
+      return await this.managerLogic.estimateGas.changeAssets(
+        changedAssets,
+        removedAssets,
+        options
+      );
+    }
     const tx = await this.managerLogic.changeAssets(
       changedAssets,
       removedAssets,
@@ -767,9 +795,17 @@ export class Pool {
    * Set a new trader with trading permissions
    * @param {string} trader Address trader account
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
-  async setTrader(trader: string, options: any = null): Promise<any> {
+  async setTrader(
+    trader: string,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    if (estimateGas) {
+      return await this.managerLogic.estimateGas.setTrader(trader, options);
+    }
     const tx = await this.managerLogic.setTrader(trader, options);
     return tx;
   }
@@ -1526,9 +1562,13 @@ export class Pool {
   /**
    * mintManagerFee
    * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
    * @returns {Promise<any>} Transaction
    */
-  async mintManagerFee(options: any = null): Promise<any> {
+  async mintManagerFee(options: any = null, estimateGas = false): Promise<any> {
+    if (estimateGas) {
+      return await this.poolLogic.estimateGas.mintManagerFee(options);
+    }
     const tx = await this.poolLogic.mintManagerFee(options);
     return tx;
   }

package/src/test/arrakis.test.ts

@@ -1,95 +1,139 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import BigNumber from "bignumber.js";
 import { Dhedge, Pool } from "..";
 import { routerAddress } from "../config";
-import { Dapp, Network } from "../types";
+import { AssetEnabled, Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  setUSDCAmount,
+  testingHelper,
+  wait
+} from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
 
-import { wallet } from "./wallet";
-
 //const network = Network.OPTIMISM;
 const network = Network.POLYGON;
 const USDC = CONTRACT_ADDRESS[network].USDC;
 const WETH = CONTRACT_ADDRESS[network].WETH;
-
-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]);
-    await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
-    await pool.trade(Dapp.ONEINCH, USDC, WETH, "1000000", 0.5);
-  });
+const testArrakis = ({ wallet, network, provider }: TestingRunParams) => {
+  let dhedge: Dhedge;
+  let pool: Pool;
 
-  it("approves unlimited USDC on Arrakis", async () => {
-    await pool.approve(Dapp.ARRAKIS, USDC, MAX_AMOUNT);
-    const usdcAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network].arrakis!,
-      pool.signer
-    );
-    await expect(usdcAllowanceDelta.gt(0));
-  });
+  describe("pool", () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
 
-  it("approves unlimited WETH on Arrakis", async () => {
-    await pool.approve(Dapp.ARRAKIS, WETH, MAX_AMOUNT);
-    const wethAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network].arrakis!,
-      pool.signer
-    );
-    await expect(wethAllowanceDelta.gt(0));
-  });
+      // top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+      await setUSDCAmount({
+        amount: new BigNumber(10000000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
 
-  it("should add liquidity and stake in an WETH/USDC Arrakis pool", async () => {
-    const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
-    const wethBalance = await pool.utils.getBalance(WETH, pool.address);
-    await pool.increaseLiquidity(
-      Dapp.ARRAKIS,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
-      usdcBalance,
-      wethBalance
-    );
-    const lpBalanceDelta = await balanceDelta(
-      pool.address,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_LP,
-      pool.signer
-    );
-    expect(lpBalanceDelta.gt(0));
-  });
+      const newAssets: AssetEnabled[] = [
+        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
+        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: true },
+        {
+          asset: CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+          isDeposit: false
+        },
+        {
+          asset: CONTRACT_ADDRESS[network].WMATIC, // reward token
+          isDeposit: false
+        },
+        {
+          asset: CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
+          isDeposit: false
+        }
+      ];
+      await pool.changeAssets(newAssets);
+      await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
+      await pool.trade(Dapp.ONEINCH, USDC, WETH, "10000000", 0.5, null, false);
+    });
 
-  it("approves unlimited LP staking Token before on Arrakis", async () => {
-    await pool.approve(
-      Dapp.ARRAKIS,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
-      MAX_AMOUNT
-    );
-    const gaugeAllowanceDelta = await allowanceDelta(
-      pool.address,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
-      routerAddress[network].arrakis!,
-      pool.signer
-    );
-    await expect(gaugeAllowanceDelta.gt(0));
-  });
+    it("approves unlimited USDC on Arrakis", async () => {
+      await pool.approve(Dapp.ARRAKIS, USDC, MAX_AMOUNT);
+      const usdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network].arrakis!,
+        pool.signer
+      );
+      await expect(usdcAllowanceDelta.gt(0));
+      await wait(5);
+    });
+
+    it("approves unlimited WETH on Arrakis", async () => {
+      await pool.approve(Dapp.ARRAKIS, WETH, MAX_AMOUNT);
+      const wethAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network].arrakis!,
+        pool.signer
+      );
+      await expect(wethAllowanceDelta.gt(0));
+    });
+
+    it("should add liquidity and stake in an WETH/USDC Arrakis pool", async () => {
+      const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+      const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+      await pool.increaseLiquidity(
+        Dapp.ARRAKIS,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+        usdcBalance,
+        wethBalance
+      );
+      const lpBalanceDelta = await balanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_LP,
+        pool.signer
+      );
+      expect(lpBalanceDelta.gt(0));
+    });
 
-  it("should remove liquidity from an existing pool ", async () => {
-    await pool.decreaseLiquidity(
-      Dapp.ARRAKIS,
-      CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
-      100
-    );
-    const wethBalanceDelta = await balanceDelta(
-      pool.address,
-      CONTRACT_ADDRESS[network].WETH,
-      pool.signer
-    );
-    expect(wethBalanceDelta.gt(0));
+    it("approves unlimited LP staking Token before on Arrakis", async () => {
+      await pool.approve(
+        Dapp.ARRAKIS,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+        MAX_AMOUNT
+      );
+      const gaugeAllowanceDelta = await allowanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+        routerAddress[network].arrakis!,
+        pool.signer
+      );
+      await expect(gaugeAllowanceDelta.gt(0));
+    });
+
+    it("should remove liquidity from an existing pool ", async () => {
+      await pool.decreaseLiquidity(
+        Dapp.ARRAKIS,
+        CONTRACT_ADDRESS[network].ARRAKIS_USDC_WETH_GAUGE,
+        100
+      );
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].WETH,
+        pool.signer
+      );
+      expect(wethBalanceDelta.gt(0));
+    });
   });
+};
+
+testingHelper({
+  network: Network.POLYGON,
+  testingRun: testArrakis
 });

package/src/test/constants.ts

@@ -52,15 +52,27 @@ export const CONTRACT_ADDRESS = {
     WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
     WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
     ARRAKIS_USDC_WETH_GAUGE: "0x33d1ad9Cd88A509397CD924C2d7613C285602C20",
-    ARRAKIS_USDC_WETH_LP: "0xa173340f1e942c2845bcbce8ebd411022e18eb13"
+    ARRAKIS_USDC_WETH_LP: "0xa173340f1e942c2845bcbce8ebd411022e18eb13",
+    WMATIC: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+    uniswapV3: {
+      nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+    }
   },
+
   [Network.OPTIMISM]: {
     USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
     SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     SWETH: "",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
-    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93"
+    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93",
+    uniswapV3: {
+      nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+    },
+    WMATIC: "",
+    //
+    ARRAKIS_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_LP: ""
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
@@ -69,13 +81,29 @@ export const CONTRACT_ADDRESS = {
     WBTC: "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f",
     WSTETH: "0x5979d7b546e38e414f7e9822514be443a4800529",
     BALANCER_WSTETH_WETH_POOL: "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f",
-    BALANCER_WSTETH_WETH_GAUGE: "0x251e51b25afa40f2b6b9f05aaf1bc7eaa0551771"
+    BALANCER_WSTETH_WETH_GAUGE: "0x251e51b25afa40f2b6b9f05aaf1bc7eaa0551771",
+
+    uniswapV3: {
+      nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+    },
+
+    //
+    ARRAKIS_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_LP: "",
+    WMATIC: ""
   },
   [Network.BASE]: {
     USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "",
-    SWETH: ""
+    SWETH: "",
+    uniswapV3: {
+      nonfungiblePositionManager: ""
+    },
+    //
+    ARRAKIS_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_LP: "",
+    WMATIC: ""
   }
 };
 

package/src/test/uniswap.test.ts

@@ -2,7 +2,7 @@
 import { FeeAmount } from "@uniswap/v3-sdk";
 import { Dhedge, ethers, Pool } from "..";
 import { routerAddress } from "../config";
-import { Dapp, Network } from "../types";
+import { AssetEnabled, Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
 import { allowanceDelta, balanceDelta } from "./utils/token";
 import {
@@ -11,12 +11,15 @@ import {
   TestingRunParams
 } from "./utils/testingHelper";
 import BigNumber from "bignumber.js";
+import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
 
 const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
   let dhedge: Dhedge;
   let pool: Pool;
+  let nonfungiblePositionManager: ethers.Contract;
+  let tokenId: ethers.BigNumber;
 
-  jest.setTimeout(100000);
+  jest.setTimeout(600000);
   describe(`testUniswapV3 on ${network}`, () => {
     beforeAll(async () => {
       dhedge = new Dhedge(wallet, network);
@@ -29,11 +32,27 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
       ]);
       await provider.send("evm_mine", []);
       await setUSDCAmount({
-        amount: new BigNumber(100).times(1e18).toFixed(0),
+        amount: new BigNumber(1000000).times(1e6).toFixed(0),
         userAddress: pool.address,
         network,
         provider
       });
+
+      const newAssets: AssetEnabled[] = [
+        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
+        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: true },
+        {
+          asset: CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
+          isDeposit: false
+        }
+      ];
+      await pool.changeAssets(newAssets);
+
+      nonfungiblePositionManager = new ethers.Contract(
+        CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
+        INonfungiblePositionManager.abi,
+        pool.signer
+      );
     });
 
     it("approves unlimited USDC on for trading on UniswapV3", async () => {
@@ -52,11 +71,11 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
       expect(UsdcAllowanceDelta.gte(0));
     });
 
-    it("should swap 5 USDC into WETH on UniswapV3", async () => {
+    it("should swap 5000 USDC into WETH on UniswapV3", async () => {
       await pool.tradeUniswapV3(
         CONTRACT_ADDRESS[network].USDC,
         CONTRACT_ADDRESS[network].WETH,
-        "5000000",
+        new BigNumber(5000).times(1e6).toFixed(0),
         FeeAmount.LOW,
         0.5
       );
@@ -69,78 +88,88 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
       expect(wethAllowanceDelta.gt(0));
     });
 
-    // it("approves unlimited WETH on for UniswapV3 LP", async () => {
-    //   await pool.approveUniswapV3Liquidity(
-    //     CONTRACT_ADDRESS[network].USDC,
-    //     ethers.constants.MaxInt256
-    //   );
-    //   const UsdcAllowanceDelta = await allowanceDelta(
-    //     pool.address,
-    //     CONTRACT_ADDRESS[network].USDC,
-    //     pool.address,
-    //     pool.signer
-    //   );
+    it("approves unlimited WETH on for UniswapV3 LP", async () => {
+      await pool.approveUniswapV3Liquidity(
+        CONTRACT_ADDRESS[network].USDC,
+        ethers.constants.MaxInt256
+      );
+      await pool.approveUniswapV3Liquidity(
+        CONTRACT_ADDRESS[network].WETH,
+        ethers.constants.MaxInt256
+      );
+      const UsdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        CONTRACT_ADDRESS[network].USDC,
+        pool.address,
+        pool.signer
+      );
 
-    //   expect(result).not.toBe(null);
-    // });
+      expect(UsdcAllowanceDelta).not.toBe(null);
+    });
 
-    // it("adds WETH and WBTC to a new V3 pool", async () => {
-    //   let result;
-    //   const pool = await dhedge.loadPool(TEST_POOL);
-    //   const usdcBalance = await dhedge.utils.getBalance(USDC, pool.address);
-    //   const wethBalance = await dhedge.utils.getBalance(WETH, pool.address);
+    it("adds WETH and USDC to a new V3 pool", async () => {
+      let result = null;
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      const usdcBalance = await dhedge.utils.getBalance(
+        CONTRACT_ADDRESS[network].USDC,
+        pool.address
+      );
+      const wethBalance = await dhedge.utils.getBalance(
+        CONTRACT_ADDRESS[network].WETH,
+        pool.address
+      );
 
-    //   try {
-    //     result = await pool.addLiquidityUniswapV3(
-    //       USDC,
-    //       WETH,
-    //       usdcBalance,
-    //       wethBalance,
-    //       0.0003,
-    //       0.0004,
-    //       null,
-    //       null,
-    //       FeeAmount.LOW,
-    //       options
-    //     );
-    //     console.log(result);
-    //   } catch (e) {
-    //     console.log(e);
-    //   }
-    //   expect(result).not.toBe(null);
-    // });
+      try {
+        result = await pool.addLiquidityUniswapV3(
+          CONTRACT_ADDRESS[network].WETH,
+          CONTRACT_ADDRESS[network].USDC,
+          wethBalance,
+          usdcBalance,
+          2000,
+          3000,
+          null,
+          null,
+          FeeAmount.LOW
+          // options
+        );
+        await result.wait(1);
+
+        tokenId = await nonfungiblePositionManager.tokenOfOwnerByIndex(
+          pool.address,
+          0
+        );
+      } catch (e) {
+        console.log("e", e);
+      }
+      expect(result).not.toBe(null);
+    });
 
-    // it("should remove liquidity from an existing pool ", async () => {
-    //   const pool = await dhedge.loadPool(TEST_POOL);
-    //   const result = await pool.decreaseLiquidity(
-    //     Dapp.UNISWAPV3,
-    //     "110507",
-    //     100,
-    //     options
-    //   );
-    //   console.log("result", result);
-    //   expect(result).not.toBe(null);
-    // });
+    it("should remove liquidity from an existing pool ", async () => {
+      const result = await pool.decreaseLiquidity(
+        Dapp.UNISWAPV3,
+        tokenId.toString(),
+        50 // precent
+      );
+      // console.log("result", result);
+      expect(result).not.toBe(null);
+    });
 
-    // it("should increase liquidity in an existing pool WETH/WBTC pool", async () => {
-    //   const pool = await dhedge.loadPool(TEST_POOL);
-    //   const result = await pool.increaseLiquidity(
-    //     Dapp.UNISWAPV3,
-    //     "110507",
-    //     "244838",
-    //     "258300000000000",
-    //     options
-    //   );
-    //   console.log("result", result);
-    //   expect(result).not.toBe(null);
-    // });
+    it("should increase liquidity in the existing WETH/USDC pool", async () => {
+      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
+      );
+      // console.log("result", result);
+      expect(result).not.toBe(null);
+    });
 
-    // it("should claim fees an existing pool", async () => {
-    //   const pool = await dhedge.loadPool(TEST_POOL);
-    //   const result = await pool.claimFeesUniswapV3("54929", options);
-    //   console.log("result", result);
-    //   expect(result).not.toBe(null);
-    // });
+    it("should claim fees an existing pool", async () => {
+      const result = await pool.claimFees(Dapp.UNISWAPV3, tokenId.toString());
+      // console.log("result", result);
+      expect(result).not.toBe(null);
+    });
 
     // it("approves unlimited USDC to swap on UniswapV3", async () => {
     //   let result;
@@ -187,6 +216,6 @@ testingHelper({
 });
 
 testingHelper({
-  network: Network.BASE,
+  network: Network.ARBITRUM,
   testingRun: testUniswapV3
 });

package/dist/utils/index.d.ts

@@ -1,7 +0,0 @@
-import BigNumber from "bignumber.js";
-import { MerkleTree } from "./merkle";
-export declare function scale(input: BigNumber | string, decimalPlaces: number): BigNumber;
-export declare function loadTree(balances: {
-    [x: string]: string | BigNumber;
-}, decimals?: number): MerkleTree;
-export declare function bnum(val: string | number | BigNumber): BigNumber;