@dhedge/v2-sdk 1.5.4 → 1.7.1

package/src/config.ts

@@ -2,9 +2,11 @@ import {
   Dapp,
   AddressNetworkMap,
   Network,
-  AddressDappNetworkMap
+  AddressDappNetworkMap,
+  LyraNetworkMap
 } from "./types";
 import { NetworkChainIdMap } from ".";
+import { Deployment } from "@lyrafinance/lyra-js";
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 require("dotenv").config();
@@ -34,7 +36,9 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.AAVEV3]: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
     [Dapp.ONEINCH]: "0x1111111254760F7ab3F16433eea9304126DCd199",
     [Dapp.TOROS]: "0xf8C62BD5f2fEf9E1a329c197F32E77AD6866B022",
-    [Dapp.VELODROME]: "0x9c12939390052919aF3155f41Bf4160Fd3666A6f"
+    [Dapp.VELODROME]: "0x9c12939390052919aF3155f41Bf4160Fd3666A6f",
+    [Dapp.LYRA]: "0xCCE7819d65f348c64B7Beb205BA367b3fE33763B",
+    [Dapp.ARRAKIS]: "0x86d62a8ad19998e315e6242b63eb73f391d4674b"
   }
 };
 
@@ -53,9 +57,7 @@ export const stakingAddress: AddressDappNetworkMap = {
     [Dapp.AAVE]: "0x357D51124f59836DeD84c8a1730D72B749d8BC23",
     [Dapp.AAVEV3]: "0x929EC64c34a17401F460460D4B9390518E5B473e"
   },
-  [Network.OPTIMISM]: {
-    [Dapp.AAVEV3]: "0x929EC64c34a17401F460460D4B9390518E5B473e"
-  }
+  [Network.OPTIMISM]: {}
 };
 
 export const aaveAddressProvider: AddressDappNetworkMap = {
@@ -88,6 +90,10 @@ export const multiCallAddress: AddressNetworkMap = {
   [Network.OPTIMISM]: ""
 };
 
+export const lyraNetworkMap: LyraNetworkMap = {
+  [Network.OPTIMISM]: Deployment.Mainnet
+};
+
 export const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
 export const MaxUint128 = "0xffffffffffffffffffffffffffffffff";
 export const UNISWAPV3_QUOTER_ADDRESS =

package/src/entities/pool.ts

@@ -29,7 +29,11 @@ import {
   Transaction,
   FundComposition,
   AssetEnabled,
-  Network
+  Network,
+  LyraOptionMarket,
+  LyraOptionType,
+  LyraTradeType,
+  LyraPosition
 } from "../types";
 
 import { Utils } from "./utils";
@@ -51,6 +55,8 @@ import {
   getVelodromeClaimTxData,
   getVelodromeStakeTxData
 } from "../services/velodrome/staking";
+import { getLyraOptionTxData } from "../services/lyra/trade";
+import { getOptionPositions } from "../services/lyra/positions";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -1165,4 +1171,58 @@ export class Pool {
     );
     return tx;
   }
+
+  /**
+   * Trade options on lyra
+   * @param {LyraOptionMarket} market Underlying market e.g. eth
+   * @param {number} expiry Expiry timestamp
+   * @param { number} strike Strike price
+   * @param {LyraOptionType} optionType Call or put
+   * @param { LyraTradeType} tradeType By or sell
+   * @param {BigNumber | string } optionAmount Option amount
+   * @param {string } assetIn  Asset to invest
+   * @param {BigNumber | string } collateralChangeAmount Collateral amount to add when shorting options and to remove when covering shorts
+   * @param {boolean} isCoveredCall Selling covered call options
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async tradeLyraOption(
+    market: LyraOptionMarket,
+    expiry: number,
+    strike: number,
+    optionType: LyraOptionType,
+    tradeType: LyraTradeType,
+    optionAmount: BigNumber | string,
+    assetIn: string,
+    collateralChangeAmount: BigNumber | string = "0",
+    isCoveredCall = false,
+    options: any = null
+  ): Promise<any> {
+    const swapxData = await getLyraOptionTxData(
+      this,
+      market,
+      optionType,
+      expiry,
+      strike,
+      tradeType,
+      optionAmount,
+      assetIn,
+      BigNumber.from(collateralChangeAmount),
+      isCoveredCall
+    );
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.LYRA],
+      swapxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Gets Lyra option positions
+   * @returns {Promise<Position>} Transaction
+   */
+  async getLyraPositions(market: LyraOptionMarket): Promise<LyraPosition[]> {
+    return await getOptionPositions(this, market);
+  }
 }

package/src/entities/utils.ts

@@ -1,4 +1,4 @@
-import { Contract, ethers, Wallet } from "ethers";
+import { BigNumber, Contract, ethers, Wallet } from "ethers";
 import {
   Token,
   TokenAmount,
@@ -22,8 +22,18 @@ import {
   networkChainIdMap,
   stakingAddress
 } from "../config";
-import { Dapp, Network, Reserves } from "../types";
+import {
+  Dapp,
+  LyraOptionMarket,
+  LyraOptionType,
+  LyraTradeType,
+  Network,
+  Reserves
+} from "../types";
 import { Pool } from ".";
+import { getExpiries, getStrike, getStrikes } from "../services/lyra/markets";
+import { Quote, Strike } from "@lyrafinance/lyra-js";
+import { getQuote } from "../services/lyra/quote";
 
 export class Utils {
   network: Network;
@@ -328,4 +338,37 @@ export class Utils {
     const exitPoolTx = iBalancerV2Vault.encodeFunctionData("exitPool", txData);
     return exitPoolTx;
   }
+
+  async getLyraOptionExpiries(market: LyraOptionMarket): Promise<number[]> {
+    return await getExpiries(this.network, market);
+  }
+
+  async getLyraOptionStrikes(
+    market: LyraOptionMarket,
+    expiry: number
+  ): Promise<Strike[]> {
+    return await getStrikes(this.network, market, expiry);
+  }
+
+  async getLyraOptionStrike(
+    market: LyraOptionMarket,
+    expiry: number,
+    strike: number
+  ): Promise<Strike> {
+    return await getStrike(this.network, market, expiry, strike);
+  }
+
+  async getLyraOptionQuote(
+    strike: Strike,
+    type: LyraOptionType,
+    tradeType: LyraTradeType,
+    amount: BigNumber | string
+  ): Promise<Quote> {
+    return await getQuote(
+      strike,
+      type,
+      tradeType,
+      ethers.BigNumber.from(amount)
+    );
+  }
 }

package/src/services/lyra/markets.ts

@@ -0,0 +1,52 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ethers, LyraOptionMarket, Network } from "../..";
+import { lyraNetworkMap } from "../../config";
+import Lyra, { Board, Strike } from "@lyrafinance/lyra-js";
+
+export async function getBoard(
+  network: Network,
+  market: LyraOptionMarket,
+  expiry: number
+): Promise<Board> {
+  const lyra = new Lyra(lyraNetworkMap[network]);
+  const optionMarket = await lyra.market(market);
+  const filteredBoards = optionMarket
+    .liveBoards()
+    .filter(e => e.expiryTimestamp === expiry);
+  if (filteredBoards.length === 0) throw new Error("no lyra board for expiry");
+  return filteredBoards[0];
+}
+
+export async function getExpiries(
+  network: Network,
+  market: LyraOptionMarket
+): Promise<number[]> {
+  const lyra = new Lyra(lyraNetworkMap[network]);
+  const optionMarket = await lyra.market(market);
+  return optionMarket.liveBoards().map(e => e.expiryTimestamp);
+}
+
+export async function getStrikes(
+  network: Network,
+  market: LyraOptionMarket,
+  expiry: number
+): Promise<Strike[]> {
+  return (await getBoard(network, market, expiry)).strikes();
+}
+
+export async function getStrike(
+  network: Network,
+  market: LyraOptionMarket,
+  expiry: number,
+  strike: number
+): Promise<Strike> {
+  const strikes = await getStrikes(network, market, expiry);
+  const filteredStrike = strikes.filter(
+    (e: Strike) =>
+      parseFloat(ethers.utils.formatEther(e.strikePrice)) === strike
+  );
+  if (filteredStrike.length === 0)
+    throw new Error("no option found for strike price");
+
+  return filteredStrike[0];
+}

package/src/services/lyra/positions.ts

@@ -0,0 +1,19 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ethers, LyraOptionMarket, LyraPosition, Pool } from "../..";
+import Lyra from "@lyrafinance/lyra-js";
+import IOptionToken from "../../abi/IOptionToken.json";
+
+export async function getOptionPositions(
+  pool: Pool,
+  market: LyraOptionMarket
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Promise<LyraPosition[]> {
+  const lyra = new Lyra();
+  const optionMarket = await lyra.market(market);
+  const iOptionToken = new ethers.Contract(
+    optionMarket.__marketData.marketAddresses.optionToken,
+    IOptionToken.abi,
+    pool.signer
+  );
+  return await iOptionToken.getOwnerPositions(pool.address);
+}

package/src/services/lyra/quote.ts

@@ -0,0 +1,12 @@
+import { Quote, Strike } from "@lyrafinance/lyra-js";
+import { ethers } from "ethers";
+import { LyraOptionType, LyraTradeType } from "../../types";
+
+export async function getQuote(
+  strike: Strike,
+  type: LyraOptionType,
+  tradeType: LyraTradeType,
+  amount: ethers.BigNumber
+): Promise<Quote> {
+  return await strike.quote(type === "call", tradeType === "buy", amount);
+}

package/src/services/lyra/trade.ts

@@ -0,0 +1,101 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BigNumber, ethers } from "ethers";
+import { Pool } from "../..";
+import { LyraOptionMarket, LyraOptionType, LyraTradeType } from "../../types";
+import { getStrike } from "./markets";
+import IOptionMarketWrapper from "../../abi/IOptionMarketWrapper.json";
+import { getLyraTradeOptionType, isCall, isLong } from "./tradeOptionType";
+import { getOptionPositions } from "./positions";
+import { getQuote } from "./quote";
+
+export async function getLyraOptionTxData(
+  pool: Pool,
+  market: LyraOptionMarket,
+  optionType: LyraOptionType,
+  expiry: number,
+  strikePrice: number,
+  tradeType: LyraTradeType,
+  optionAmount: BigNumber | string,
+  assetIn: string,
+  collateralAmount: BigNumber,
+  isCoveredCall: boolean
+): Promise<string> {
+  const strike = await getStrike(pool.network, market, expiry, strikePrice);
+  const strikeId = strike.id;
+
+  const positions = await getOptionPositions(pool, market);
+  const filteredPosition = positions.filter(
+    e =>
+      e.strikeId.toNumber() === strikeId &&
+      isCall(e.optionType) == (optionType === "call") &&
+      e.state === 1
+  );
+  const positionId =
+    filteredPosition.length > 0 ? filteredPosition[0].positionId : 0;
+
+  let lyraOptionType = getLyraTradeOptionType(
+    optionType === "call",
+    tradeType === "buy",
+    isCoveredCall
+  );
+
+  const amountIn = BigNumber.from(optionAmount);
+  const quote = await getQuote(strike, optionType, tradeType, amountIn);
+  const netPremiun =
+    tradeType === "buy"
+      ? quote.premium.add(quote.fee)
+      : quote.premium.sub(quote.fee);
+
+  let txFunction = "openPosition";
+  let inputAmount = tradeType === "buy" ? netPremiun : collateralAmount;
+  let currentCollateral = BigNumber.from(0);
+  let setCollateral = collateralAmount;
+  if (filteredPosition.length > 0) {
+    currentCollateral = filteredPosition[0].collateral ?? BigNumber.from(0);
+    setCollateral = currentCollateral.add(collateralAmount);
+    if (
+      //sell long positions
+      (tradeType === "sell" && isLong(filteredPosition[0].optionType)) ||
+      //cover short positions
+      (tradeType === "buy" && !isLong(filteredPosition[0].optionType))
+    ) {
+      lyraOptionType = filteredPosition[0].optionType;
+      txFunction = "closePosition";
+      setCollateral = currentCollateral.sub(collateralAmount);
+      //cover short
+      if (
+        !isLong(filteredPosition[0].optionType) &&
+        !isCoveredCall &&
+        collateralAmount.gt(netPremiun)
+      ) {
+        inputAmount = netPremiun.sub(collateralAmount);
+      } else if (!isLong(filteredPosition[0].optionType) && isCoveredCall) {
+        inputAmount = netPremiun;
+      } else {
+        inputAmount = BigNumber.from(0);
+      }
+    }
+  }
+
+  const iOptionMarketWrapper = new ethers.utils.Interface(
+    IOptionMarketWrapper.abi
+  );
+
+  const tradeTx = iOptionMarketWrapper.encodeFunctionData(txFunction, [
+    [
+      strike.market().contractAddresses.optionMarket,
+      strikeId, // strike Id
+      positionId, // position Id
+      1, // iteration
+      setCollateral, // set collateral to
+      currentCollateral, // current collateral
+      lyraOptionType, // optionType
+      amountIn, // amount
+      tradeType === "sell" ? netPremiun : 0, // min cost
+      tradeType === "buy" ? netPremiun : ethers.constants.MaxUint256, // max cost
+      inputAmount,
+      assetIn // input asset
+    ]
+  ]);
+  return tradeTx;
+}

package/src/services/lyra/tradeOptionType.ts

@@ -0,0 +1,19 @@
+export function getLyraTradeOptionType(
+  isCall: boolean,
+  isLong: boolean,
+  isCoveredCall: boolean
+): number {
+  if (isCall) {
+    return isLong ? 0 : isCoveredCall ? 2 : 3;
+  } else {
+    return isLong ? 1 : 4;
+  }
+}
+
+export function isCall(optionType: number): boolean {
+  return [0, 2, 3].includes(optionType);
+}
+
+export function isLong(optionType: number): boolean {
+  return optionType === 0 || optionType === 1;
+}

package/src/test/arrakis.test.ts

@@ -1,9 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Dhedge } from "..";
+import { Dhedge, ethers } from "..";
 import { Dapp, Network } from "../types";
-import { ARRAKIS_USDC_WETH_GAUGE, TEST_POOL } from "./constants";
+import { ARRAKIS_USDC_WETH_GAUGE, TEST_POOL, USDC, WETH } from "./constants";
 import { getTxOptions } from "./txOptions";
-//import { getTxOptions } from "./txOptions";
 
 import { wallet } from "./wallet";
 
@@ -13,67 +12,81 @@ jest.setTimeout(100000);
 
 describe("pool", () => {
   beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
-    options = await getTxOptions(Network.POLYGON);
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+    options = await getTxOptions(Network.OPTIMISM);
   });
 
-  // 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("approves unlimited USDC on Arrakis", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const result = await pool.approve(
+      Dapp.ARRAKIS,
+      USDC,
+      ethers.constants.MaxInt256,
+      options
+    );
+    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 WETH on Arrakis", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const result = await pool.approve(
+      Dapp.ARRAKIS,
+      WETH,
+      ethers.constants.MaxInt256,
+      options
+    );
+    console.log(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 add liquidity and stake in an WETH/USDC Arrakis pool", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+    const uasdBalance = await pool.utils.getBalance(USDC, pool.address);
+    const lpBalance = await pool.utils.getBalance(
+      ARRAKIS_USDC_WETH_GAUGE,
+      pool.address
+    );
+    const result = await pool.increaseLiquidity(
+      Dapp.ARRAKIS,
+      ARRAKIS_USDC_WETH_GAUGE,
+      uasdBalance,
+      wethBalance,
+      options
+    );
+    result.wait(1);
+    const lpBalanceAfter = await pool.utils.getBalance(
+      ARRAKIS_USDC_WETH_GAUGE,
+      pool.address
+    );
+    expect(lpBalanceAfter.gt(lpBalance));
+  });
+
+  it("approves unlimited LP staking Token before on  Arrakis", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const result = await pool.approve(
+      Dapp.ARRAKIS,
+      ARRAKIS_USDC_WETH_GAUGE,
+      ethers.constants.MaxInt256,
+      options
+    );
+    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,
-      50.6576575755,
+      100,
       options
     );
-    console.log("result", result);
-    expect(result).not.toBe(null);
+    result.wait(1);
+    const lpBalanceAfter = await pool.utils.getBalance(
+      ARRAKIS_USDC_WETH_GAUGE,
+      pool.address
+    );
+    expect(lpBalanceAfter.eq(0));
   });
 
   // it("should claim fees an existing pool", async () => {

package/src/test/constants.ts

@@ -5,19 +5,19 @@
 // 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";
-export const AARAKIS_WNATIC_STMATIC_GAUGE =
-  "0x9928340f9E1aaAd7dF1D95E27bd9A5c715202a56";
-export const ETHBULL3X = "0x460b60565cb73845d56564384ab84bf84c13e47d";
-export const BTCBEAR2X = "0x3dbce2c8303609c17aa23b69ebe83c2f5c510ada";
+// 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";
+// export const AARAKIS_WNATIC_STMATIC_GAUGE =
+//   "0x9928340f9E1aaAd7dF1D95E27bd9A5c715202a56";
+// export const ETHBULL3X = "0x460b60565cb73845d56564384ab84bf84c13e47d";
+// export const BTCBEAR2X = "0x3dbce2c8303609c17aa23b69ebe83c2f5c510ada";
 
 //Optimism
 export const WETH = "0x4200000000000000000000000000000000000006";
@@ -28,5 +28,8 @@ export const WBTC = "0x68f180fcCe6836688e9084f035309E29Bf0A2095";
 export const OP = "4200000000000000000000000000000000000042";
 export const WSTETH = "0x1F32b1c2345538c0c6f582fCB022739c4A194Ebb";
 export const VEL = "0x3c8B650257cFb5f272f799F5e2b4e65093a11a05";
+export const SUSD = "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9";
+export const ARRAKIS_USDC_WETH_GAUGE =
+  "0xb8888ea29e2f70ad62a3b69b1a1342720612a00d";
 
-export const TEST_POOL = "TEST_POOL";
+export const TEST_POOL = "0x3d45e539df0f9fa6015106a968d732a8f6c2a40b";