@dhedge/v2-sdk 1.5.3 → 1.7.0

package/src/test/lyra.test.ts

@@ -0,0 +1,163 @@
+import { Dhedge } from "..";
+import { Network } from "../types";
+import { utils } from "ethers";
+import { SUSD, TEST_POOL } from "./constants";
+import { getTxOptions } from "./txOptions";
+import { wallet } from "./wallet";
+
+jest.setTimeout(100000);
+
+describe("pool", () => {
+  let dhedge: Dhedge;
+  const options = getTxOptions(Network.OPTIMISM);
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+  });
+
+  it("buys 0.1 1400 calls with expiry October 28th", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.tradeLyraOption(
+        "eth",
+        1666944000,
+        1400,
+        "call",
+        "buy",
+        utils.parseEther("0.1"),
+        SUSD
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    result.wait(1);
+    const positions = await pool.getLyraPositions("eth");
+    expect(positions.length > 0);
+  });
+
+  it("adds 0.05 1400 calls with expiry October 28th", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.tradeLyraOption(
+        "eth",
+        1666944000,
+        1400,
+        "call",
+        "buy",
+        utils.parseEther("0.05"),
+        SUSD,
+        "0",
+        false,
+        options
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    result.wait(1);
+    const positions = await pool.getLyraPositions("eth");
+    expect(utils.formatEther(positions[0].amount)).toBe("0.15");
+  });
+
+  it("sells 0.1 1300 Covered Call with expiry October 28th", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.tradeLyraOption(
+        "eth",
+        1666944000,
+        1300,
+        "call",
+        "sell",
+        utils.parseEther("0.1"),
+        SUSD,
+        utils.parseEther("0.1"),
+        true,
+        options
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    result.wait(1);
+    const positions = await pool.getLyraPositions("eth");
+    const cCall = positions.find(e => e.optionType === 2);
+    expect(cCall).not.toBe(undefined);
+  });
+
+  it("adds 0.05 1300 Covered Call with expiry October 28th", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.tradeLyraOption(
+        "eth",
+        1666944000,
+        1300,
+        "call",
+        "sell",
+        utils.parseEther("0.05"),
+        SUSD,
+        utils.parseEther("0.05"),
+        true,
+        options
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    result.wait(1);
+    const positions = await pool.getLyraPositions("eth");
+    const cCall = positions.find(e => e.optionType === 2);
+    expect(cCall);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    expect(utils.formatEther(cCall!.amount)).toBe("0.15");
+  });
+
+  it("closes all 0.15 1300 Covered Call with expiry October 28th", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.tradeLyraOption(
+        "eth",
+        1666944000,
+        1300,
+        "call",
+        "buy",
+        utils.parseEther("0.15"),
+        SUSD,
+        utils.parseEther("0.15"),
+        true,
+        options
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    result.wait(1);
+    const positions = await pool.getLyraPositions("eth");
+    const cCall = positions.find(e => e.optionType === 2 && e.state === 1);
+    expect(cCall).toBe(undefined);
+  });
+
+  it("closes all 0.15 1400 Calls with expiry October 28th", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.tradeLyraOption(
+        "eth",
+        1666944000,
+        1400,
+        "call",
+        "sell",
+        utils.parseEther("0.15"),
+        SUSD,
+        "0",
+        false,
+        options
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    result.wait(1);
+    const positions = await pool.getLyraPositions("eth");
+    const call = positions.find(e => e.optionType === 0 && e.state === 1);
+    expect(call).toBe(undefined);
+  });
+});

package/src/test/pool.test.ts

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

package/src/test/toros.test.ts

@@ -25,7 +25,7 @@ describe("pool", () => {
     let result;
     const pool = await dhedge.loadPool(ETHBULL3X);
     try {
-      const depositAsset = await getPoolDepositAsset(pool, ETHBULL3X);
+      const depositAsset = await getPoolDepositAsset(pool, ETHBULL3X, USDC);
       if (!depositAsset) throw new Error("no deposit assets");
 
       result = await getEasySwapperDepositQuote(

package/src/test/txOptions.ts

@@ -13,7 +13,7 @@ export const getTxOptions = async (network: Network): Promise<any> => {
         .toFixed(0),
       maxFeePerGas: new BigNumber(result.data.fast.maxFee)
         .shiftedBy(9)
-        .toFixed(0),
+        .toFixed(0)
     };
   } else {
     return { gasLimit: "3000000" };

package/src/test/uniswap.test.ts

@@ -13,7 +13,7 @@ jest.setTimeout(100000);
 describe("pool", () => {
   beforeAll(async () => {
     dhedge = new Dhedge(wallet, Network.POLYGON);
-    options = await getTxOptions();
+    options = await getTxOptions(Network.POLYGON);
     //options = { gasLimit: "3000000" };
   });
 

package/src/test/velodrome.test.ts

@@ -0,0 +1,141 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Dhedge, ethers } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, VEL, WETH, WSTETH } from "./constants";
+import { getTxOptions } from "./txOptions";
+
+import { wallet } from "./wallet";
+
+const wETHwstETHLp = "0xBf205335De602ac38244F112d712ab04CB59A498";
+const wETHwstETHGauge = "0x131Ae347E654248671Afc885F0767cB605C065d7";
+
+let dhedge: Dhedge;
+let options: any;
+jest.setTimeout(100000);
+
+describe("pool", () => {
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+    options = await getTxOptions(Network.OPTIMISM);
+  });
+
+  it("approves unlimited WETH on for Velodrome", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.approve(
+        Dapp.VELODROME,
+        WSTETH,
+        ethers.constants.MaxInt256,
+        options
+      );
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  it("adds WETH and wstETH to a Velodrome stable pool", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const wethBalance = await dhedge.utils.getBalance(WETH, pool.address);
+    const stwethBalance = await dhedge.utils.getBalance(WSTETH, pool.address);
+
+    const result = await pool.addLiquidityVelodrome(
+      WETH,
+      WSTETH,
+      wethBalance,
+      stwethBalance,
+      true,
+      options
+    );
+
+    result.wait(1);
+    const lpBalance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
+    expect(lpBalance.gt(0));
+  });
+
+  it("should stake wETH/wStETH LP in a gauge", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const balance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
+    const result = await pool.stakeInGauge(
+      Dapp.VELODROME,
+      wETHwstETHGauge,
+      balance,
+      options
+    );
+    result.wait(1);
+    const gaugeBalance = await dhedge.utils.getBalance(
+      wETHwstETHGauge,
+      pool.address
+    );
+    expect(gaugeBalance.gt(0));
+  });
+
+  it("should claim rewards from Gauge", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const result = await pool.claimFees(
+      Dapp.VELODROME,
+      wETHwstETHGauge,
+      options
+    );
+    result.wait(1);
+    const velBalance = await dhedge.utils.getBalance(VEL, pool.address);
+    expect(velBalance.gt(0));
+  });
+
+  it("should unStake wETH/wStETH LP from a gauge", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const gaugeBalance = await dhedge.utils.getBalance(
+      wETHwstETHGauge,
+      pool.address
+    );
+    const result = await pool.unstakeFromGauge(
+      wETHwstETHGauge,
+      gaugeBalance,
+      options
+    );
+    result.wait(1);
+    const lpBalance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
+    expect(lpBalance.gt(0));
+    const gaugeBalanceAfter = await dhedge.utils.getBalance(
+      wETHwstETHGauge,
+      pool.address
+    );
+    expect(gaugeBalanceAfter.eq(0));
+  });
+
+  it("approves unlimited wETH/stwETH LP for Velodrome", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.approve(
+        Dapp.VELODROME,
+        wETHwstETHLp,
+        ethers.constants.MaxInt256,
+        options
+      );
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  it("should remove all liquidity from an existing pool ", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const balance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
+    const result = await pool.removeLiquidityVelodrome(
+      WETH,
+      WSTETH,
+      balance,
+      options
+    );
+    result.wait(1);
+    const balanceAfter = await dhedge.utils.getBalance(
+      wETHwstETHLp,
+      pool.address
+    );
+    expect(balanceAfter.eq(0));
+  });
+});

package/src/test/wallet.ts

@@ -7,6 +7,14 @@ 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://opt-kovan.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}`
+// );
+
 // const provider = new ethers.providers.JsonRpcProvider(
 //   `https://polygon-mainnet.infura.io/v3/${process.env.INFURA_PROJECT_ID}`
 // );

package/src/types.ts

@@ -1,3 +1,4 @@
+import { Deployment } from "@lyrafinance/lyra-js";
 import { BigNumber } from "ethers";
 
 export enum Network {
@@ -15,7 +16,9 @@ export enum Dapp {
   SYNTHETIX = "synthetix",
   AAVEV3 = "aavev3",
   ARRAKIS = "arrakis",
-  TOROS = "toros"
+  TOROS = "toros",
+  VELODROME = "velodrome",
+  LYRA = "lyra"
 }
 
 export enum Transaction {
@@ -68,3 +71,20 @@ export type Reserves = {
 };
 
 export type NetworkChainIdMap = Readonly<Record<Network, number>>;
+
+export type LyraOptionMarket = "eth";
+export type AddressMarketMap = {
+  [key in LyraOptionMarket]: string;
+};
+
+export type LyraTradeType = "buy" | "sell";
+export type LyraOptionType = "call" | "put";
+export type LyraNetworkMap = { [key in Network]?: Deployment };
+export type LyraPosition = {
+  positionId: BigNumber;
+  strikeId: BigNumber;
+  optionType: number;
+  amount: BigNumber;
+  collateral: BigNumber;
+  state: number;
+};

package/src/test/sushi.test.ts

@@ -1,173 +0,0 @@
-import { Dhedge } from "..";
-import { Dapp, Network } from "../types";
-
-import { wallet } from "./wallet";
-
-import { BAL, TEST_POOL, USDT } from "./constants";
-
-const myPool = "0x3e5f7e9e7dc3bc3086ccebd5eb59a0a4a29d881b";
-// const weth = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
-// //const usdt = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
-// //const dai = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
-// const usdc = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
-// const wbtc = "0x1bfd67037b42cf73acf2047067bd4f2c47d9bfd6";
-//const sushi = "0x0b3F868E0BE5597D5DB7fEB59E1CADBb0fdDa50a";
-// const wmatic = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
-// const lpUsdcWeth = "0x34965ba0ac2451A34a0471F04CCa3F990b8dea27";
-//const lpUsdcDai = "0xCD578F016888B57F1b1e3f887f392F0159E26747";
-//const amusdc = "0x1a13F4Ca1d028320A707D99520AbFefca3998b7F";
-//const lpUsdcUsdt = "0x4b1f1e2435a9c96f7330faea190ef6a7c8d70001";
-// 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("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";
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.setTrader(newTrader);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   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);
-  // });
-
-});