@dhedge/v2-sdk 1.3.0 → 1.4.2

package/src/test/arrakis.test.ts

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+import { ARRAKIS_USDC_WETH_GAUGE, TEST_POOL } from "./constants";
+import { getTxOptions } from "./txOptions";
+//import { getTxOptions } from "./txOptions";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+let options: any;
+jest.setTimeout(100000);
+
+describe("pool", () => {
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+    options = await getTxOptions();
+  });
+
+  // it("approves unlimited WETH on  Arrakis", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.ARRAKIS,
+  //       USDC,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("should add liquidity and stake in an WETH/USDC Arrakis pool", async () => {
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const result = await pool.increaseLiquidity(
+  //     Dapp.ARRAKIS,
+  //     "0x33d1ad9Cd88A509397CD924C2d7613C285602C20",
+  //     "776000",
+  //     "470000000000000",
+  //     options
+  //   );
+  //   console.log("result", result);
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("approves unlimited LP staking Token before on  Arrakis", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.ARRAKIS,
+  //       ARRAKIS_USDC_WETH_GAUGE,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(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.ARRAKIS,
+      ARRAKIS_USDC_WETH_GAUGE,
+      100,
+      options
+    );
+    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.claimFees(
+  //     Dapp.ARRAKIS,
+  //     ARRAKIS_USDC_WETH_GAUGE,
+  //     options
+  //   );
+  //   console.log("result", result);
+  //   expect(result).not.toBe(null);
+  // });
+});

package/src/test/balancer.test.ts

@@ -1,21 +1,19 @@
-import { Dhedge, ethers } from "..";
+import { Dhedge } from "..";
 import { Network } from "../types";
-import { TEST_POOL } from "./constants";
+import { STMATIC, TEST_POOL, WMATIC } from "./constants";
+import { getTxOptions } from "./txOptions";
 
 import { wallet } from "./wallet";
 
 let dhedge: Dhedge;
+let options: any;
 
 jest.setTimeout(100000);
 
-const options = {
-  gasLimit: 2000000,
-  gasPrice: ethers.utils.parseUnits("1000", "gwei")
-};
-
 describe("pool", () => {
-  beforeAll(() => {
+  beforeAll(async () => {
     dhedge = new Dhedge(wallet, Network.POLYGON);
+    options = await getTxOptions();
   });
 
   // it("approves unlimited USDC on Balancer", async () => {
@@ -95,11 +93,118 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  it("claims balancer rewards", async () => {
+  // it("claims balancer rewards", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.harvestBalancerRewards(options);
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  //   it("adds 5 WMATIC to a WMATIC/stMATIC balancer pool", async () => {
+  //     let result;
+  //     const pool = await dhedge.loadPool(TEST_POOL);
+  //     const assets = [WMATIC, STMATIC];
+  //     const amounts = ["5000000000000000000", "0"];
+  //     try {
+  //       result = await pool.joinBalancerPool(
+  //         "0xaf5e0b5425de1f5a630a8cb5aa9d97b8141c908d000200000000000000000366",
+  //         assets,
+  //         amounts,
+  //         options
+  //       );
+  //       console.log("result", result);
+  //     } catch (e) {
+  //       console.log(e);
+  //     }
+  //     expect(result).not.toBe(null);
+  //   });
+
+  // it("allows unlimited WMATIC-stMATIC LP on gauge", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approveSpender(
+  //       "0x9928340f9E1aaAd7dF1D95E27bd9A5c715202a56",
+  //       WMATIC_STMATIC_LP,
+  //       ethers.constants.MaxUint256,
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("stakes WMATIC-stMATIC LP in gauge", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.stakeInGauge(
+  //       "0x9928340f9E1aaAd7dF1D95E27bd9A5c715202a56",
+  //       "4978534455005333156",
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("claim fess pf staked WMATIC-stMATIC LP in gauge", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.claimFees(
+  //       Dapp.BALANCER,
+  //       "0x9928340f9E1aaAd7dF1D95E27bd9A5c715202a56",
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("unstakes WMATIC-stMATIC LP from gauge", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.unstakeFromGauge(
+  //       "0x9928340f9E1aaAd7dF1D95E27bd9A5c715202a56",
+  //       "4978534455005333156",
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("exits from WMATIC-stMATIC LP into WMATIC", async () => {
     let result;
     const pool = await dhedge.loadPool(TEST_POOL);
+    const assets = [WMATIC, STMATIC];
+    const amount = await dhedge.utils.getBalance(
+      "0xaF5E0B5425dE1F5a630A8cB5AA9D97B8141C908D",
+      pool.address
+    );
     try {
-      result = await pool.harvestBalancerRewards(options);
+      result = await pool.exitBalancerPool(
+        "0xaf5e0b5425de1f5a630a8cb5aa9d97b8141c908d000200000000000000000366",
+        assets,
+        amount,
+        1,
+        options
+      );
       console.log("result", result);
     } catch (e) {
       console.log(e);

package/src/test/constants.ts

@@ -1,17 +1,23 @@
-//export const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
-//Optimism
-export const USDC = "0x7F5c764cBc14f9669B88837ca1490cCa17c31607";
-export const USDT = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
-export const DAI = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
-export const TUSD = "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756";
-//export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+//Polygon
+// export const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+// export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+// export const USDT = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
+// export const DAI = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
+// export const TUSD = "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756";
+// export const WBTC = "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6";
+// export const SUSHI = "0x0b3f868e0be5597d5db7feb59e1cadbb0fdda50a";
+// export const WMATIC = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
+// export const BAL = "0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3";
+// export const AMUSDC = "0x1a13f4ca1d028320a707d99520abfefca3998b7f";
+// export const VDEBTWETH = "0xede17e9d79fc6f9ff9250d9eefbdb88cc18038b5";
+// export const ARRAKIS_USDC_WETH_GAUGE =
+//   "0x33d1ad9Cd88A509397CD924C2d7613C285602C20";
+// export const STMATIC = "0x3A58a54C066FdC0f2D55FC9C89F0415C92eBf3C4";
+// export const WMATIC_STMATIC_LP = "0xaF5E0B5425dE1F5a630A8cB5AA9D97B8141C908D";
+
 //Optimism
 export const WETH = "0x4200000000000000000000000000000000000006";
-export const WBTC = "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6";
-export const SUSHI = "0x0b3f868e0be5597d5db7feb59e1cadbb0fdda50a";
-export const WMATIC = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
-export const BAL = "0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3";
-export const AMUSDC = "0x1a13f4ca1d028320a707d99520abfefca3998b7f";
-export const VDEBTWETH = "0xede17e9d79fc6f9ff9250d9eefbdb88cc18038b5";
+export const USDC = "0x7F5c764cBc14f9669B88837ca1490cCa17c31607";
+export const DAI = "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
 
-export const TEST_POOL = "0xf36f550907872faaa02477f791df3ce33fe38854";
+export const TEST_POOL = "TEST_POOL_ADDRESS";

package/src/test/oneInch.test.ts

@@ -1,6 +1,6 @@
-import { Dhedge, ethers } from "..";
+import { Dhedge } from "..";
 import { Dapp, Network } from "../types";
-import { TEST_POOL, USDC, WETH } from "./constants";
+import { DAI, TEST_POOL, USDC } from "./constants";
 
 import { wallet } from "./wallet";
 
@@ -8,25 +8,24 @@ let dhedge: Dhedge;
 
 jest.setTimeout(100000);
 
-const options = {
-  gasLimit: 5000000,
-  gasPrice: ethers.utils.parseUnits("35", "gwei")
-};
+// const options = {
+//   gasLimit: 5000000,
+//   gasPrice: ethers.utils.parseUnits("35", "gwei")
+// };
 
 describe("pool", () => {
   beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
   });
 
-  // it("approves unlimited USDC on 1Inch", async () => {
+  // it("approves unlimited DAI on 1Inch", async () => {
   //   let result;
   //   const pool = await dhedge.loadPool(TEST_POOL);
   //   try {
   //     result = await pool.approve(
   //       Dapp.ONEINCH,
-  //       USDC,
-  //       ethers.constants.MaxInt256,
-  //       options
+  //       DAI,
+  //       ethers.constants.MaxInt256
   //     );
   //     console.log(result);
   //   } catch (e) {
@@ -35,18 +34,12 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  it("trades 1 USDC into WETH on 1Inch", async () => {
+  it("trades 1 entire DAI balance into USDC on 1Inch", async () => {
     let result;
     const pool = await dhedge.loadPool(TEST_POOL);
     try {
-      result = await pool.trade(
-        Dapp.ONEINCH,
-        USDC,
-        WETH,
-        "1000000",
-        0.5,
-        options
-      );
+      const balance = await dhedge.utils.getBalance(DAI, pool.address);
+      result = await pool.trade(Dapp.ONEINCH, DAI, USDC, balance, 0.5);
       console.log("1inch trade", result);
     } catch (e) {
       console.log(e);

package/src/test/pool.test.ts

@@ -15,7 +15,7 @@ jest.setTimeout(100000);
 
 describe("pool", () => {
   beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+    dhedge = new Dhedge(wallet, Network.POLYGON);
   });
 
   it("checks fund composition", async () => {

package/src/test/txOptions.ts

@@ -1,15 +1,21 @@
 import axios from "axios";
 import BigNumber from "bignumber.js";
+import { Network } from "../types";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const getTxOptions = async (): Promise<any> => {
-  const result = await axios("https://gasstation-mainnet.matic.network/v2");
-
-  return {
-    gasLimit: "3000000",
-    maxPriorityFeePerGas: new BigNumber(result.data.fast.maxPriorityFee)
-      .shiftedBy(9)
-      .toFixed(0),
-    maxFeePerGas: new BigNumber(result.data.fast.maxFee).shiftedBy(9).toFixed(0)
-  };
+export const getTxOptions = async (network: Network): Promise<any> => {
+  if (network === Network.POLYGON) {
+    const result = await axios("https://gasstation-mainnet.matic.network/v2");
+    return {
+      gasLimit: "3000000",
+      maxPriorityFeePerGas: new BigNumber(result.data.fast.maxPriorityFee)
+        .shiftedBy(9)
+        .toFixed(0),
+      maxFeePerGas: new BigNumber(result.data.fast.maxFee)
+        .shiftedBy(9)
+        .toFixed(0),
+    };
+  } else {
+    return { gasLimit: "3000000" };
+  }
 };

package/src/test/uniswap.test.ts

@@ -1,9 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { FeeAmount } from "@uniswap/v3-sdk";
 import { Dhedge } from "..";
-import { Network } from "../types";
-import { TEST_POOL, USDC, WETH } from "./constants";
-//import { getTxOptions } from "./txOptions";
+import { Dapp, Network } from "../types";
+import { TEST_POOL } from "./constants";
+import { getTxOptions } from "./txOptions";
 
 import { wallet } from "./wallet";
 
@@ -13,9 +12,9 @@ jest.setTimeout(100000);
 
 describe("pool", () => {
   beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
-    //options = await getTxOptions();
-    options = { gasLimit: "3000000" };
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+    options = await getTxOptions();
+    //options = { gasLimit: "3000000" };
   });
 
   // it("approves unlimited WETH on for UniswapV3 LP", async () => {
@@ -60,19 +59,25 @@ describe("pool", () => {
   //   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.removeLiquidityUniswapV3("84405", 100, options);
-  //   console.log("result", result);
-  //   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 increase liquidity in an existing pool WETH/WBTC pool", async () => {
   //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   const result = await pool.increaseLiquidityUniswapV3(
-  //     "54929",
-  //     "1317",
-  //     "143980000000000",
+  //   const result = await pool.increaseLiquidity(
+  //     Dapp.UNISWAPV3,
+  //     "110507",
+  //     "244838",
+  //     "258300000000000",
   //     options
   //   );
   //   console.log("result", result);
@@ -86,13 +91,6 @@ describe("pool", () => {
   //   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("approves unlimited USDC to swap on UniswapV3", async () => {
   //   let result;
   //   const pool = await dhedge.loadPool(TEST_POOL);
@@ -110,18 +108,18 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  it("should swap USDC into WETH on UniswapV3 pool", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
-    const result = await pool.tradeUniswapV3(
-      USDC,
-      WETH,
-      "1000000",
-      FeeAmount.LOW,
-      1,
-      options
-    );
+  // it("should swap USDC into WETH on UniswapV3 pool", async () => {
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const result = await pool.tradeUniswapV3(
+  //     USDC,
+  //     WETH,
+  //     "1000000",
+  //     FeeAmount.LOW,
+  //     1,
+  //     options
+  //   );
 
-    console.log(result);
-    expect(result).not.toBe(null);
-  });
+  //   console.log(result);
+  //   expect(result).not.toBe(null);
+  // });
 });

package/src/test/wallet.ts

@@ -3,14 +3,14 @@ import { ethers } from "ethers";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 require("dotenv").config();
 
-const provider = new ethers.providers.JsonRpcProvider(
-  `https://opt-mainnet.g.alchemy.com/v2/${process.env.ALCHEMY_PROJECT_ID}`
-);
-
 // const provider = new ethers.providers.JsonRpcProvider(
-//   `https://polygon-mainnet.infura.io/v3/${process.env.INFURA_PROJECT_ID}`
+//   `https://opt-mainnet.g.alchemy.com/v2/${process.env.ALCHEMY_PROJECT_ID}`
 // );
 
+const provider = new ethers.providers.JsonRpcProvider(
+  `https://polygon-mainnet.infura.io/v3/${process.env.INFURA_PROJECT_ID}`
+);
+
 export const wallet = new ethers.Wallet(
   process.env.PRIVATE_KEY as string,
   provider

package/src/types.ts

@@ -12,7 +12,9 @@ export enum Dapp {
   QUICKSWAP = "quickswap",
   BALANCER = "balancer",
   UNISWAPV3 = "uniswapV3",
-  SYNTHETIX = "synthetix"
+  SYNTHETIX = "synthetix",
+  AAVEV3 = "aavev3",
+  ARRAKIS = "arrakis"
 }
 
 export enum Transaction {
@@ -32,19 +34,15 @@ export enum Transaction {
   WITHDRAW = "withdraw",
   MINT = "mint",
   BURN = "burn",
-  SWAP_SYNTHS = "exchangeWithTracking"
+  SWAP_SYNTHS = "exchangeWithTracking",
+  ADD_LIQUIDITY_STAKE = "addLiquidityAndStake",
+  REMOVE_LIQUIDITY_UNSTAKE = "removeLiquidityAndUnstake"
 }
 
 export type AddressNetworkMap = Readonly<Record<Network, string>>;
 
 export type AddressDappMap = {
-  [Dapp.SUSHISWAP]?: string;
-  [Dapp.AAVE]?: string;
-  [Dapp.ONEINCH]?: string;
-  [Dapp.QUICKSWAP]?: string;
-  [Dapp.BALANCER]?: string;
-  [Dapp.UNISWAPV3]?: string;
-  [Dapp.SYNTHETIX]?: string;
+  [key in Dapp]?: string;
 };
 
 export type AddressDappNetworkMap = Readonly<Record<Network, AddressDappMap>>;