@dhedge/v2-sdk 1.0.0 → 1.2.0

package/src/services/claim-balancer/types.ts

@@ -0,0 +1,66 @@
+export interface Claim {
+  id: string;
+  amount: string;
+}
+
+export type Snapshot = Record<number, string>;
+
+export type TokenClaimInfo = {
+  label: string;
+  distributor: string;
+  token: string;
+  decimals: number;
+  manifest: string;
+  weekStart: number;
+};
+
+export type MultiTokenPendingClaims = {
+  claims: Claim[];
+  reports: Report;
+  tokenClaimInfo: TokenClaimInfo;
+  availableToClaim: string;
+};
+
+export type ClaimStatus = boolean;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Report = Record<string, any>;
+
+export type MultiTokenCurrentRewardsEstimateResponse = {
+  success: boolean;
+  result: {
+    current_timestamp: string;
+    "liquidity-providers": Array<{
+      snapshot_timestamp: string;
+      address: string;
+      token_address: string;
+      chain_id: number;
+      current_estimate: string;
+      velocity: string;
+      week: number;
+    }>;
+  };
+};
+
+export type MultiTokenCurrentRewardsEstimate = {
+  rewards: string;
+  velocity: string;
+  token: string;
+};
+
+export type ClaimProofTuple = [number, string, string, number, string[]]; // claimId, claimAmount, distributor, tokenIndex, proof
+
+export type ComputeClaimProofPayload = {
+  report: Report;
+  account: string;
+  claim: Claim;
+  distributor: string;
+  tokenIndex: number;
+  decimals: number;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ClaimWorkerMessage<P = any> = {
+  type: "computeClaimProof";
+  payload: P;
+};

package/src/test/aave.test.ts

@@ -0,0 +1,73 @@
+import { Dhedge, ethers } from "..";
+import { Network } from "../types";
+import { AMUSDC, TEST_POOL, VDEBTWETH } from "./constants";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+
+jest.setTimeout(100000);
+
+const options = {
+  gasLimit: 5000000,
+  gasPrice: ethers.utils.parseUnits("100", "gwei")
+};
+
+describe("pool", () => {
+  beforeAll(() => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+  });
+
+  // it("withdraws 1 USDC from Aave lending pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.withdrawDeposit(
+  //       Dapp.AAVE,
+  //       weth,
+  //       "86567951006165",
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("borrows 0.0001 WETH from Aave lending pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.borrow(Dapp.AAVE, weth, "100000000000000");
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("reapys 0.0001 WETH to Aave lending pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.repay(Dapp.AAVE, weth, "100000000000000", options);
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("claims rewards from Aave", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.harvestAaveRewards([AMUSDC, VDEBTWETH], options);
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/balancer.test.ts

@@ -0,0 +1,109 @@
+import { Dhedge, ethers } from "..";
+import { Network } from "../types";
+import { TEST_POOL } from "./constants";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+
+jest.setTimeout(100000);
+
+const options = {
+  gasLimit: 2000000,
+  gasPrice: ethers.utils.parseUnits("1000", "gwei")
+};
+
+describe("pool", () => {
+  beforeAll(() => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+  });
+
+  // it("approves unlimited USDC on Balancer", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.BALANCER,
+  //       USDC,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("trades 2 USDC into SUSHI on Balancer", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.trade(
+  //       Dapp.BALANCER,
+  //       usdc,
+  //       sushi,
+  //       "2000000",
+  //       0.5,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("adds 1 USDC to a USDC/TUSD/DAI/USDT balancer pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const assets = [USDC, TUSD, DAI, USDT];
+  //   const amounts = ["1000000", "0", "0", "0"];
+  //   try {
+  //     result = await pool.joinBalancerPool(
+  //       "0x0d34e5dd4d8f043557145598e4e2dc286b35fd4f000000000000000000000068",
+  //       assets,
+  //       amounts,
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("exits entire balance of WBTC/USDC/WETH balancer pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   const assets = [wbtc, usdc, weth];
+  //   const amount = await dhedge.utils.getBalance(
+  //     "0x03cd191f589d12b0582a99808cf19851e468e6b5",
+  //     pool.address
+  //   );
+  //   try {
+  //     result = await pool.exitBalancerPool(
+  //       "0x03cd191f589d12b0582a99808cf19851e468e6b500010000000000000000000a",
+  //       assets,
+  //       amount,
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  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);
+  });
+});

package/src/test/constants.ts

@@ -0,0 +1,13 @@
+export const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+export const USDT = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
+export const DAI = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
+export const TUSD = "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756";
+export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+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 TEST_POOL = "0x3deeba9ca29e2dd98d32eed8dd559dac55014615";

package/src/test/dhedge.test.ts

@@ -4,11 +4,15 @@ import { Network } from "../types";
 
 import { wallet } from "./wallet";
 
-const myPool = "0xbae28251b2a4e621aa7e20538c06dee010bc06de";
-// const usdc = "0x9D4Dc547d9c1822aEd5b6e19025894d1B7A54036";
-// const weth = "0x21d867E9089d07570c682B9186697E2E326CEc8a";
+const myPool = "0x279ac4c05154fd72a636fce1bc25c50966141fd0";
+// const usdc = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+// const weth = "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619";
 
-jest.setTimeout(100000);
+// const options = {
+//   gasPrice: ethers.utils.parseUnits("40", "gwei")
+// };
+
+jest.setTimeout(900000);
 
 let dhedge: Dhedge;
 
@@ -28,10 +32,18 @@ describe("dhedge", () => {
   });
 
   // it("create a pool", async () => {
-  //   const pool = await dhedge.createPool("Batman", "Gotham Pool", "DHHH", [
-  //     [usdc, true],
-  //     [weth, true]
-  //   ]);
+  //   const pool = await dhedge.createPool(
+  //     "Batman",
+  //     "Gotham Pool",
+  //     "DHHH",
+  //     [
+  //       [usdc, true],
+  //       [weth, true]
+  //     ],
+  //     25,
+  //     options
+  //   );
+  //   console.log(pool.address);
   //   expect(pool.poolLogic.address).toBe(pool.address);
   // });
 });

package/src/test/oneInch.test.ts

@@ -0,0 +1,56 @@
+import { Dhedge, ethers } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, USDC, WETH } from "./constants";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+
+jest.setTimeout(100000);
+
+const options = {
+  gasLimit: 5000000,
+  gasPrice: ethers.utils.parseUnits("35", "gwei")
+};
+
+describe("pool", () => {
+  beforeAll(() => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+  });
+
+  // it("approves unlimited USDC on 1Inch", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.ONEINCH,
+  //       USDC,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("trades 1 USDC into WETH 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
+      );
+      console.log("1inch trade", result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/pool.test.ts

@@ -1,69 +1,34 @@
 import { Dhedge } from "..";
 import { Network } from "../types";
+import { TEST_POOL } from "./constants";
 
 import { wallet } from "./wallet";
 
-const myPool = "0xbae28251b2a4e621aa7e20538c06dee010bc06de";
-
-// const weth = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
-//const usdt = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
-//const dai = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
-//const usdc = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
-// const sushi = "0x0b3F868E0BE5597D5DB7fEB59E1CADBb0fdDa50a";
-// const wmatic = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
-// const lpUsdcWeth = "0x34965ba0ac2451A34a0471F04CCa3F990b8dea27";
-//const lpUsdcDai = "0xCD578F016888B57F1b1e3f887f392F0159E26747";
-// const tradeAmountUsdc = "1000000";
-// const liquidityAmountUsdt = "1000000";
-// const lpUsdcWETHAmount = "10951027354";
-// const depositAmountUsdc = "100000";
-
 let dhedge: Dhedge;
 
 jest.setTimeout(100000);
 
+// const options = {
+//   gasLimit: 5000000,
+//   gasPrice: ethers.utils.parseUnits("35", "gwei")
+// };
+
 describe("pool", () => {
   beforeAll(() => {
     dhedge = new Dhedge(wallet, Network.POLYGON);
   });
 
   it("checks fund composition", async () => {
-    const pool = await dhedge.loadPool(myPool);
+    const pool = await dhedge.loadPool(TEST_POOL);
     const result = await pool.getComposition();
+    console.log(result);
     expect(result.length).toBeGreaterThan(0);
   });
 
   // it("withdraws 1.00002975 fund tokens", async () => {
-  //   const pool = await dhedge.loadPool(myPool)
+  //   const pool = await dhedge.loadPool(myPool);
   //   const result = await pool.withdraw("1000029750000000000");
   //   expect(result).toBeGreaterThan(0);
-  // })
-
-  // it("approves unlimited SUSHI on sushiswap", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.approve(
-  //       Dapp.SUSHISWAP,
-  //       sushi,
-  //       ethers.constants.MaxInt256
-  //     );
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("trades 0.5 USDC into USDT on sushiswap", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.trade(Dapp.SUSHISWAP, usdc, usdt, "500000", "497382");
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
   // });
 
   // it("approve USDC balance of User for Deposit", async () => {
@@ -95,9 +60,8 @@ describe("pool", () => {
   //     { asset: usdc, isDeposit: true },
   //     { asset: weth, isDeposit: true },
   //     { asset: usdt, isDeposit: true },
-  //     { asset: lpUsdcWeth, isDeposit: false },
-  //     { asset: sushi, isDeposit: false },
-  //     { asset: wmatic, isDeposit: false }
+  //     { asset: amusdc, isDeposit: false },
+  //     { asset: lpUsdcUsdt, isDeposit: false }
   //   ];
   //   try {
   //     result = await pool.changeAssets(newAssets);
@@ -124,114 +88,6 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  // it("adds Liquidity into a WETH/USDT pool on sushi", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const liquidityAmountWETH = await dhedge.utils.getLpAmount(
-  //     Dapp.SUSHISWAP,
-  //     usdt,
-  //     weth,
-  //     liquidityAmountUsdt
-  //   );
-  //   try {
-  //     result = await pool.addLiquidity(
-  //       Dapp.SUSHISWAP,
-  //       usdt,
-  //       weth,
-  //       liquidityAmountUsdt,
-  //       liquidityAmountWETH
-  //     );
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("approves unlimited LP USDC/WETH on sushiswap for staking", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.approveStaking(
-  //       Dapp.SUSHISWAP,
-  //       lpUsdcDai,
-  //       ethers.constants.MaxUint256
-  //     );
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("deposit 0.1 USDC into Pool", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.deposit(usdc, depositAmountUsdc);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("adds LpUSDCWETH to enabled assets", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const newAssets: AssetEnabled[] = [
-  //     { asset: usdc, isDeposit: true },
-  //     { asset: weth, isDeposit: true },
-  //     { asset: usdt, isDeposit: true },
-  //     { asset: lpUsdcWeth, isDeposit: false }
-  //   ];
-  //   try {
-  //     result = await pool.changeAssets(newAssets);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("unStakes USDC/DAI LP on sushi", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const balance = "11013356749811";
-  //   try {
-  //     result = await pool.unStake(Dapp.SUSHISWAP, lpUsdcDai, balance);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("trades entire sushi balance into usdc", async () => {
-  //   let result: FundComposition[] = [];
-  //   let tx;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.getComposition();
-  //     const sushiBalance = result.find(e => e.asset === sushi)?.balance;
-  //     if (sushiBalance) {
-  //       tx = await pool.trade(Dapp.SUSHISWAP, sushi, usdc, sushiBalance);
-  //       console.log(tx);
-  //     }
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result.length).toBeGreaterThan(0);
-  // });
-
-  // it("harvests USDC/DAI LP Farm on sushi", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.harvestRewards(Dapp.SUSHISWAP, lpUsdcdai);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
   // it("sets a trader account", async () => {
   //   let result;
   //   const newTrader = "0xC52D9a9D9b05a01887871216fF02bA4235e8503d";
@@ -244,17 +100,4 @@ describe("pool", () => {
   //   }
   //   expect(result).not.toBe(null);
   // });
-
-  // it("removes liquidity from  USDC/DAI LP on sushi", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const balance = "11013356749811";
-  //   try {
-  //     result = await pool.removeLiquidity(Dapp.SUSHISWAP, usdc, dai, balance);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
 });