@dhedge/v2-sdk 1.9.5 → 1.9.7

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/oneInch.test.ts

@@ -7,7 +7,8 @@ import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
 import {
   TestingRunParams,
   setUSDCAmount,
-  testingHelper
+  testingHelper,
+  wait
 } from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
 import { getTxOptions } from "./txOptions";
@@ -32,7 +33,7 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
       await provider.send("evm_mine", []);
       // top up USDC
       await setUSDCAmount({
-        amount: new BigNumber(100).times(1e18).toFixed(0),
+        amount: new BigNumber(2).times(1e6).toFixed(0),
         userAddress: pool.address,
         network,
         provider
@@ -50,7 +51,38 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
       await expect(usdcAllowanceDelta.gt(0));
     });
 
+    it("gets gas estimation for 2 USDC into WETH on 1Inch", async () => {
+      const gasEstimate = await pool.trade(
+        Dapp.ONEINCH,
+        USDC,
+        WETH,
+        "2000000",
+        0.5,
+        await getTxOptions(network),
+        true
+      );
+      expect(gasEstimate.gt(0));
+    });
+
+    it("gets error on gas estimation for 200 USDC into WETH on 1Inch", async () => {
+      await wait(1);
+      let gasEstimate = null;
+      try {
+        gasEstimate = await pool.trade(
+          Dapp.ONEINCH,
+          USDC,
+          WETH,
+          "200000000",
+          0.5,
+          await getTxOptions(network),
+          true
+        );
+      } catch (err) {}
+      expect(gasEstimate).toBeNull();
+    });
+
     it("trades 2 USDC into WETH on 1Inch", async () => {
+      await wait(1);
       await pool.trade(
         Dapp.ONEINCH,
         USDC,

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/src/test/utils/testingHelper.ts

@@ -90,3 +90,7 @@ export const setUSDCAmount = async ({
     slot: USDC_BALANCEOF_SLOT[network]
   });
 };
+
+export const wait = (seconds: number): Promise<void> => {
+  return new Promise(resolve => setTimeout(resolve, seconds * 1000));
+};

package/src/utils/contract.ts

@@ -3,7 +3,7 @@
 import set from "lodash/set";
 import { Interface } from "@ethersproject/abi";
 import { multiCallAddress } from "../config";
-import { ethers, Network } from "..";
+import { ethers, Network, Pool } from "..";
 
 export async function call(
   provider: ethers.Signer,
@@ -93,3 +93,19 @@ export class Multicaller {
     return obj;
   }
 }
+
+export const getPoolTxOrGasEstimate = async (
+  pool: Pool,
+  args: any[],
+  estimateGas: boolean
+): Promise<any> => {
+  if (estimateGas) {
+    return await pool.poolLogic.estimateGas.execTransaction(
+      args[0],
+      args[1],
+      args[2]
+    );
+  } else {
+    return await pool.poolLogic.execTransaction(args[0], args[1], args[2]);
+  }
+};

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;

package/dist/utils/merkle.d.ts

@@ -1,22 +0,0 @@
-/// <reference types="node" />
-import BigNumber from "bignumber.js";
-export declare class MerkleTree {
-    elements: any;
-    layers: any;
-    constructor(elements: any[]);
-    getLayers(elements: string | any[]): (string | any[])[];
-    getNextLayer(elements: any[]): any[];
-    combinedHash(first: any, second: any): any;
-    getRoot(): any;
-    getHexRoot(): string;
-    getProof(el: any): any;
-    getHexProof(_el: any): string[];
-    getPairElement(idx: number, layer: string | any[]): any;
-    bufIndexOf(el: string | any[], arr: string | any[]): number;
-    bufDedup(elements: any[]): any[];
-    bufArrToHexArr(arr: any[]): string[];
-    sortAndConcat(...args: any[]): Buffer;
-}
-export declare function loadTree(balances: {
-    [x: string]: string | BigNumber;
-}, decimals?: number): MerkleTree;

package/src/utils/index.ts

@@ -1,38 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import BigNumber from "bignumber.js";
-import { soliditySha3 } from "web3-utils";
-import { MerkleTree } from "./merkle";
-
-export function scale(
-  input: BigNumber | string,
-  decimalPlaces: number
-): BigNumber {
-  const unscaled = typeof input === "string" ? new BigNumber(input) : input;
-  const scalePow = new BigNumber(decimalPlaces.toString());
-  const scaleMul = new BigNumber(10).pow(scalePow);
-  return unscaled.times(scaleMul);
-}
-
-export function loadTree(
-  balances: { [x: string]: string | BigNumber },
-  decimals = 18
-) {
-  const elements: any[] = [];
-  Object.keys(balances).forEach(address => {
-    const balance: string = scale(balances[address], decimals).toString(10);
-    const leaf = soliditySha3(
-      { t: "address", v: address },
-      { t: "uint", v: balance }
-    );
-    // @ts-ignore
-    elements.push(leaf);
-  });
-  return new MerkleTree(elements);
-}
-
-export function bnum(val: string | number | BigNumber): BigNumber {
-  const number = typeof val === "string" ? val : val ? val.toString() : "0";
-  return new BigNumber(number);
-}