@dhedge/v2-sdk 1.8.3 → 1.9.0

package/src/test/balancer.test.ts

@@ -1,218 +1,126 @@
-import { Dhedge } from "..";
-import { Network } from "../types";
-import { TEST_POOL, WMATIC } from "./constants";
-import { getTxOptions } from "./txOptions";
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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 { wallet } from "./wallet";
 
-let dhedge: Dhedge;
-let options: any;
+const network = Network.ARBITRUM;
+const USDC = CONTRACT_ADDRESS[network].USDC;
+const WETH = CONTRACT_ADDRESS[network].WETH;
+const WSTETH = CONTRACT_ADDRESS[network].WSTETH;
+const BALANCER_POOL = CONTRACT_ADDRESS[network].BALANCER_WSTETH_WETH_POOL;
+const BLANCER_GAUGE = CONTRACT_ADDRESS[network].BALANCER_WSTETH_WETH_GAUGE;
 
+let dhedge: Dhedge;
+let pool: Pool;
 jest.setTimeout(100000);
 
 describe("pool", () => {
   beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
-    options = await getTxOptions(Network.POLYGON);
+    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);
+    await pool.trade(Dapp.ONEINCH, USDC, WSTETH, "1000000", 0.5);
   });
 
-  // 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);
-  // });
+  it("approves unlimited stWETH on Balancer", async () => {
+    await pool.approve(Dapp.BALANCER, WSTETH, MAX_AMOUNT);
+    const stWETHAllowanceDelta = await allowanceDelta(
+      pool.address,
+      WSTETH,
+      routerAddress[network].balancer!,
+      pool.signer
+    );
+    await expect(stWETHAllowanceDelta.gt(0));
+  });
 
-  it("adds 5 WMATIC to a WMATIC/stMATIC balancer pool", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
-    const assets = [
-      WMATIC,
-      "0xb20fC01D21A50d2C734C4a1262B4404d41fA7BF0",
-      "0xfa68FB4628DFF1028CFEc22b4162FCcd0d45efb6"
-    ];
-    const amounts = ["29500317230801455961187", "0", "0"];
-    try {
-      result = await pool.joinBalancerPool(
-        "0xb20fc01d21a50d2c734c4a1262b4404d41fa7bf000000000000000000000075c",
-        assets,
-        amounts,
-        options
-      );
-      console.log("result", result);
-    } catch (e) {
-      console.log(e);
-    }
-    expect(result).not.toBe(null);
+  it("approves unlimited WETH on Balancer", async () => {
+    await pool.approve(Dapp.BALANCER, WETH, MAX_AMOUNT);
+    const wethAllowanceDelta = await allowanceDelta(
+      pool.address,
+      WETH,
+      routerAddress[network].balancer!,
+      pool.signer
+    );
+    await expect(wethAllowanceDelta.gt(0));
   });
 
-  // 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("should add liquidity in a Balancer pool", async () => {
+    const wstETHBalance = await pool.utils.getBalance(WSTETH, pool.address);
+    const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+    await pool.joinBalancerPool(
+      "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f000200000000000000000316", //wstETH-WETH on Arbitrum
+      [WSTETH, WETH],
+      [wstETHBalance.toString(), wethBalance.toString()]
+    );
+    const lpBalanceDelta = await balanceDelta(
+      pool.address,
+      BALANCER_POOL,
+      pool.signer
+    );
+    expect(lpBalanceDelta.gt(0));
+  });
 
-  // 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("approves unlimited LP Token on Balancer Vault", async () => {
+    await pool.approveSpender(BLANCER_GAUGE, BALANCER_POOL, MAX_AMOUNT);
+    const gaugeAllowanceDelta = await allowanceDelta(
+      pool.address,
+      BALANCER_POOL,
+      BLANCER_GAUGE,
+      pool.signer
+    );
+    await expect(gaugeAllowanceDelta.gt(0));
+  });
 
-  // 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("stakes LP tokens in Balancer vault", async () => {
+    const lpTokenBalance = await pool.utils.getBalance(
+      BALANCER_POOL,
+      pool.address
+    );
+    await pool.stakeInGauge(Dapp.BALANCER, BLANCER_GAUGE, lpTokenBalance);
+    const lpBalanceDelta = await balanceDelta(
+      pool.address,
+      BALANCER_POOL,
+      pool.signer
+    );
+    expect(lpBalanceDelta.lt(0));
+  });
 
-  // 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("unstakes LP tokens from Balancer vault", async () => {
+    const vaultTokenBalance = await pool.utils.getBalance(
+      BLANCER_GAUGE,
+      pool.address
+    );
+    await pool.unstakeFromGauge(BLANCER_GAUGE, vaultTokenBalance);
+    const lpBalanceDelta = await balanceDelta(
+      pool.address,
+      BALANCER_POOL,
+      pool.signer
+    );
+    expect(lpBalanceDelta.gt(0));
+  });
 
-  // 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.exitBalancerPool(
-  //       "0xaf5e0b5425de1f5a630a8cb5aa9d97b8141c908d000200000000000000000366",
-  //       assets,
-  //       amount,
-  //       1,
-  //       options
-  //     );
-  //     console.log("result", result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
+  it("should remove liquidity from an Balancer pool ", async () => {
+    const lpTokenBalance = await pool.utils.getBalance(
+      BALANCER_POOL,
+      pool.address
+    );
+    await pool.approve(Dapp.BALANCER, BALANCER_POOL, MAX_AMOUNT);
+    await pool.exitBalancerPool(
+      "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f000200000000000000000316",
+      [WSTETH, WETH],
+      lpTokenBalance
+    );
+    const wethBalanceDelta = await balanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].WETH,
+      pool.signer
+    );
+    expect(wethBalanceDelta.gt(0));
+  });
 });

package/src/test/constants.ts

@@ -40,7 +40,8 @@ export const KWENTA_ETH_PERP_V2 = "0x2b3bb4c683bfc5239b029131eef3b1d214478d93";
 
 export const TEST_POOL = {
   [Network.POLYGON]: "0x699fd4d6eadb216704c7e355cfa0a12f51813163",
-  [Network.OPTIMISM]: "0x12573bfdf764ab9d52aca20e2827497a66829716"
+  [Network.OPTIMISM]: "0x12573bfdf764ab9d52aca20e2827497a66829716",
+  [Network.ARBITRUM]: "0x2dc2f936c8b6619facc69355d65dd93d2f4cc2bd"
 };
 
 export const CONTRACT_ADDRESS = {
@@ -55,9 +56,15 @@ export const CONTRACT_ADDRESS = {
     USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
     SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     WETH: "0x4200000000000000000000000000000000000006",
-    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93",
-    ARRAKIS_USDC_WETH_GAUGE: "0xd3a3fbae792c4ed0aa909ec032d3f14c999b2402",
-    ARRAKIS_USDC_WETH_LP: "0xc59d8fbc3d9a92d24a923722f0244a50daa2ea33"
+    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93"
+  },
+  [Network.ARBITRUM]: {
+    USDC: "0xff970a61a04b1ca14834a43f5de4533ebddb5cc8",
+    WETH: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+    WBTC: "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f",
+    WSTETH: "0x5979d7b546e38e414f7e9822514be443a4800529",
+    BALANCER_WSTETH_WETH_POOL: "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f",
+    BALANCER_WSTETH_WETH_GAUGE: "0x251e51b25afa40f2b6b9f05aaf1bc7eaa0551771"
   }
 };
 

package/src/test/futures.test.ts

@@ -1,6 +1,7 @@
 import { Dhedge, Pool } from "..";
 import { Network } from "../types";
 import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { getDelayedOrders } from "./utils/futures";
 import { balanceDelta } from "./utils/token";
 import { wallet } from "./wallet";
 
@@ -32,11 +33,13 @@ describe("pool", () => {
   it("goes long ETH-PERP about 2x leverage", async () => {
     //size 50*2/2000 (margin * leverage  / price)
     const size = (0.05 * 1e18).toString();
-    const tx = await pool.changeFuturesPosition(perp, size);
-    expect(tx).not.toBe(null);
+    await pool.changeFuturesPosition(perp, size);
+    const orders = await getDelayedOrders(perp, pool);
+    expect(orders.length).toBeGreaterThan(0);
   });
 
   it("removes 20 sUSD margin from ETH future market", async () => {
+    await getDelayedOrders(perp, pool);
     await pool.changeFuturesMargin(perp, (-20 * 1e18).toString());
     const sUSDBalanceDelta = await balanceDelta(
       pool.address,

package/src/test/oneInch.test.ts

@@ -8,7 +8,8 @@ import { allowanceDelta, balanceDelta } from "./utils/token";
 import { wallet } from "./wallet";
 
 // const network = Network.OPTIMISM;
-const network = Network.POLYGON;
+// const network = Network.POLYGON;
+const network = Network.ARBITRUM;
 const USDC = CONTRACT_ADDRESS[network].USDC;
 const WETH = CONTRACT_ADDRESS[network].WETH;
 
@@ -33,8 +34,8 @@ describe("pool", () => {
     await expect(usdcAllowanceDelta.gt(0));
   });
 
-  it("trades 5 USDC into WETH on 1Inch", async () => {
-    await pool.trade(Dapp.ONEINCH, USDC, WETH, "5000000", 0.5);
+  it("trades 2 USDC into WETH on 1Inch", async () => {
+    await pool.trade(Dapp.ONEINCH, USDC, WETH, "2000000", 0.5);
     const wethBalanceDelta = await balanceDelta(
       pool.address,
       WETH,

package/src/test/utils/futures.ts

@@ -0,0 +1,14 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Pool, ethers } from "../..";
+import ISynthetixFuturesMarketV2 from "../../abi/ISynthetixFuturesMarketV2.json";
+export async function getDelayedOrders(
+  market: string,
+  pool: Pool
+): Promise<any> {
+  const futuresMarket = new ethers.Contract(
+    market,
+    ISynthetixFuturesMarketV2.abi,
+    pool.signer
+  );
+  return await futuresMarket.delayedOrders(pool.address);
+}

package/src/test/wallet.ts

@@ -12,7 +12,7 @@ require("dotenv").config();
 // );
 
 // const provider = new ethers.providers.JsonRpcProvider(
-//   `https://polygon-mainnet.infura.io/v3/${process.env.INFURA_PROJECT_ID}`
+//   `https://arb-mainnet.g.alchemy.com/v2/${process.env.ALCHEMY_PROJECT_ID}`
 // );
 
 // const provider = new ethers.providers.JsonRpcProvider(

package/src/types.ts

@@ -3,7 +3,8 @@ import { BigNumber } from "ethers";
 
 export enum Network {
   POLYGON = "polygon",
-  OPTIMISM = "optimism"
+  OPTIMISM = "optimism",
+  ARBITRUM = "arbitrum"
 }
 
 export enum Dapp {