@dhedge/v2-sdk 1.9.0 → 1.9.2

package/src/test/utils/testingHelper.ts

@@ -0,0 +1,20 @@
+import { ethers } from "ethers";
+import { Network } from "../../types";
+import { getWallet } from "../wallet";
+
+export type TestingRunParams = {
+  network: Network;
+  wallet: ethers.Wallet;
+};
+
+type TestHelperParams = {
+  testingRun: (testingRunParams: TestingRunParams) => void;
+} & { network: Network };
+
+export const testingHelper = ({
+  network,
+  testingRun
+}: TestHelperParams): void => {
+  const wallet = getWallet(network);
+  testingRun({ network, wallet });
+};

package/src/test/velodromeV2.test.ts

@@ -0,0 +1,114 @@
+/* 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";
+
+const USDC_SUSD_Lp = "0x6d5BA400640226e24b50214d2bBb3D4Db8e6e15a";
+const USDC_SUSD_Gauge = "0x55a272304456355242f6690863b5c8d5c512ff71";
+const network = Network.OPTIMISM;
+const SUSD = CONTRACT_ADDRESS[network].SUSD;
+const USDC = CONTRACT_ADDRESS[network].USDC;
+
+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]);
+  });
+
+  it("approves unlimited sUSD and USDC on for Velodrome", async () => {
+    await pool.approve(Dapp.VELODROMEV2, SUSD, MAX_AMOUNT);
+    await pool.approve(Dapp.VELODROMEV2, USDC, MAX_AMOUNT);
+    const UsdcAllowanceDelta = await allowanceDelta(
+      pool.address,
+      USDC,
+      routerAddress[network].velodromeV2!,
+      pool.signer
+    );
+    await expect(UsdcAllowanceDelta.gt(0));
+  });
+
+  it("adds USDC and SUSD to a Velodrome stable pool", async () => {
+    await pool.addLiquidityVelodromeV2(
+      USDC,
+      SUSD,
+      (5 * 1e6).toString(),
+      (5 * 1e18).toString(),
+      true
+    );
+
+    const lpTokenDelta = await balanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      pool.signer
+    );
+    expect(lpTokenDelta.gt(0));
+  });
+
+  it("should stake USDC-sUSD LP in a gauge", async () => {
+    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
+    await pool.approveSpender(USDC_SUSD_Gauge, USDC_SUSD_Lp, MAX_AMOUNT);
+    await pool.stakeInGauge(Dapp.VELODROMEV2, USDC_SUSD_Gauge, balance);
+    const gaugeBalance = await balanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      pool.signer
+    );
+    expect(gaugeBalance.gt(0));
+  });
+
+  it("should claim rewards from Gauge", async () => {
+    const tx = await pool.claimFees(Dapp.VELODROMEV2, USDC_SUSD_Gauge);
+    expect(tx).not.toBe(null);
+  });
+
+  it("should unStake USDC-sUSD LP from a gauge", async () => {
+    const gaugeBalance = await dhedge.utils.getBalance(
+      USDC_SUSD_Gauge,
+      pool.address
+    );
+    await pool.unstakeFromGauge(USDC_SUSD_Gauge, gaugeBalance);
+    const lpTokenDelta = await balanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      pool.signer
+    );
+    expect(lpTokenDelta.gt(0));
+  });
+
+  it("approves unlimited wETH/stwETH LP for Velodrome", async () => {
+    await pool.approve(Dapp.VELODROMEV2, USDC_SUSD_Lp, MAX_AMOUNT);
+    const lpAllowanceDelta = await allowanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      routerAddress[network].velodrome!,
+      pool.signer
+    );
+    expect(lpAllowanceDelta.gt(0));
+  });
+
+  it("should remove all liquidity from an existing pool ", async () => {
+    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
+    await pool.removeLiquidityVelodromeV2(USDC, SUSD, balance, true);
+    const usdcBalanceDelta = await balanceDelta(
+      pool.address,
+      USDC,
+      pool.signer
+    );
+    const susdBalanceDelta = await balanceDelta(
+      pool.address,
+      SUSD,
+      pool.signer
+    );
+    expect(usdcBalanceDelta.gt(0));
+    expect(susdBalanceDelta.gt(0));
+  });
+});

package/src/test/wallet.ts

@@ -1,5 +1,5 @@
 import { ethers } from "ethers";
-
+import { Network } from "../types";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 require("dotenv").config();
 
@@ -25,3 +25,16 @@ export const wallet = new ethers.Wallet(
   process.env.PRIVATE_KEY as string,
   provider
 );
+
+export const networkPortMap = {
+  [Network.POLYGON]: 8542,
+  [Network.OPTIMISM]: 8544,
+  [Network.ARBITRUM]: 8540
+};
+
+export const getWallet = (network: Network): ethers.Wallet => {
+  const provider = new ethers.providers.JsonRpcProvider(
+    `http://127.0.0.1:${networkPortMap[network]}/`
+  );
+  return new ethers.Wallet(process.env.PRIVATE_KEY as string, provider);
+};

package/src/test/zeroEx.test.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { Dhedge, Pool } from "..";
+import { routerAddress } from "../config";
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { TestingRunParams, testingHelper } from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+
+const testZeroEx = ({ wallet, network }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] 0x trade`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+    });
+
+    it("approves unlimited USDC on 0x", async () => {
+      await pool.approve(Dapp.ZEROEX, USDC, MAX_AMOUNT);
+      const usdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network]["0x"]!,
+        pool.signer
+      );
+      await expect(usdcAllowanceDelta.gt(0));
+    });
+
+    it("trades 2 USDC into WETH on 0x", async () => {
+      await pool.trade(Dapp.ZEROEX, USDC, WETH, "2000000", 0.5);
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
+      );
+      expect(wethBalanceDelta.gt(0));
+    });
+  });
+};
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testZeroEx
+});
+
+testingHelper({
+  network: Network.POLYGON,
+  testingRun: testZeroEx
+});

package/src/types.ts

@@ -19,7 +19,9 @@ export enum Dapp {
   ARRAKIS = "arrakis",
   TOROS = "toros",
   VELODROME = "velodrome",
-  LYRA = "lyra"
+  VELODROMEV2 = "velodromeV2",
+  LYRA = "lyra",
+  ZEROEX = "0x"
 }
 
 export enum Transaction {

package/dist/services/oneInch/protocols.d.ts

@@ -1 +0,0 @@
-export declare function getOneInchProtocols(chainId: number): Promise<string>;

package/src/services/oneInch/protocols.ts

@@ -1,17 +0,0 @@
-import axios from "axios";
-
-export async function getOneInchProtocols(chainId: number): Promise<string> {
-  try {
-    const response = await axios.get(
-      `https://api.1inch.io/v5.0/${chainId}/liquidity-sources`
-    );
-    const protocols = response.data.protocols.map((e: { id: string }) => e.id);
-    const filteredProtocols = protocols.filter(
-      (e: string) => !e.includes("PMM")
-    );
-
-    return `&protocols=${filteredProtocols.join(",")}`;
-  } catch {
-    return "";
-  }
-}