@dhedge/v2-sdk 1.5.4 → 1.7.0

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,8 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.AAVEV3]: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
     [Dapp.ONEINCH]: "0x1111111254760F7ab3F16433eea9304126DCd199",
     [Dapp.TOROS]: "0xf8C62BD5f2fEf9E1a329c197F32E77AD6866B022",
-    [Dapp.VELODROME]: "0x9c12939390052919aF3155f41Bf4160Fd3666A6f"
+    [Dapp.VELODROME]: "0x9c12939390052919aF3155f41Bf4160Fd3666A6f",
+    [Dapp.LYRA]: "0xCCE7819d65f348c64B7Beb205BA367b3fE33763B"
   }
 };
 
@@ -53,9 +56,7 @@ export const stakingAddress: AddressDappNetworkMap = {
     [Dapp.AAVE]: "0x357D51124f59836DeD84c8a1730D72B749d8BC23",
     [Dapp.AAVEV3]: "0x929EC64c34a17401F460460D4B9390518E5B473e"
   },
-  [Network.OPTIMISM]: {
-    [Dapp.AAVEV3]: "0x929EC64c34a17401F460460D4B9390518E5B473e"
-  }
+  [Network.OPTIMISM]: {}
 };
 
 export const aaveAddressProvider: AddressDappNetworkMap = {
@@ -88,6 +89,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/constants.ts

@@ -28,5 +28,6 @@ export const WBTC = "0x68f180fcCe6836688e9084f035309E29Bf0A2095";
 export const OP = "4200000000000000000000000000000000000042";
 export const WSTETH = "0x1F32b1c2345538c0c6f582fCB022739c4A194Ebb";
 export const VEL = "0x3c8B650257cFb5f272f799F5e2b4e65093a11a05";
+export const SUSD = "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9";
 
 export const TEST_POOL = "TEST_POOL";

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

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Dhedge, ethers } from "..";
 import { Dapp, Network } from "../types";
-import { TEST_POOL, WETH, WSTETH } from "./constants";
+import { TEST_POOL, VEL, WETH, WSTETH } from "./constants";
 import { getTxOptions } from "./txOptions";
 
 import { wallet } from "./wallet";

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 {
@@ -16,7 +17,8 @@ export enum Dapp {
   AAVEV3 = "aavev3",
   ARRAKIS = "arrakis",
   TOROS = "toros",
-  VELODROME = "velodrome"
+  VELODROME = "velodrome",
+  LYRA = "lyra"
 }
 
 export enum Transaction {
@@ -69,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;
+};