@dhedge/v2-sdk 1.5.3 → 1.7.0

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";
@@ -43,6 +47,16 @@ import { getUniswapV3SwapTxData } from "../services/uniswap/V3Trade";
 import { getEasySwapperTxData } from "../services/toros/easySwapper";
 import { getOneInchProtocols } from "../services/oneInch/protocols";
 import { getAaveV3ClaimTxData } from "../services/aave/incentives";
+import {
+  getVelodromeAddLiquidityTxData,
+  getVelodromeRemoveLiquidityTxData
+} from "../services/velodrome/liquidity";
+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;
@@ -430,20 +444,34 @@ export class Pool {
 
   /**
    * Stake liquidity pool tokens in gauge contract
+   * @param {Dapp} dapp Platform like Balancer or Velodrome
    * @param {string} gauge Gauge contract address
    * @param {BigNumber | string} amount Amount of liquidity pool tokens
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
   async stakeInGauge(
+    dapp: Dapp,
     gauge: string,
     amount: BigNumber | string,
     options: any = null
   ): Promise<any> {
-    const rewardsGauge = new ethers.utils.Interface(IBalancerRewardsGauge.abi);
-    const stakeTxData = rewardsGauge.encodeFunctionData("deposit(uint256)", [
-      amount
-    ]);
+    let stakeTxData;
+    switch (dapp) {
+      case Dapp.BALANCER:
+        const rewardsGauge = new ethers.utils.Interface(
+          IBalancerRewardsGauge.abi
+        );
+        stakeTxData = rewardsGauge.encodeFunctionData("deposit(uint256)", [
+          amount
+        ]);
+        break;
+      case Dapp.VELODROME:
+        stakeTxData = getVelodromeStakeTxData(amount);
+        break;
+      default:
+        throw new Error("dapp not supported");
+    }
     const tx = await this.poolLogic.execTransaction(
       gauge,
       stakeTxData,
@@ -1020,21 +1048,29 @@ export class Pool {
   ): Promise<any> {
     let txData;
     let contractAddress;
-    if (dapp === Dapp.UNISWAPV3) {
-      contractAddress = nonfungiblePositionManagerAddress[this.network];
-      const iNonfungiblePositionManager = new ethers.utils.Interface(
-        INonfungiblePositionManager.abi
-      );
-      txData = iNonfungiblePositionManager.encodeFunctionData(
-        Transaction.COLLECT,
-        [[tokenId, this.address, MaxUint128, MaxUint128]]
-      );
-    } else if (dapp === Dapp.ARRAKIS || dapp === Dapp.BALANCER) {
-      contractAddress = tokenId;
-      const abi = new ethers.utils.Interface(ILiquidityGaugeV4.abi);
-      txData = abi.encodeFunctionData("claim_rewards()", []);
-    } else {
-      throw new Error("dapp not supported");
+    switch (dapp) {
+      case Dapp.UNISWAPV3:
+        contractAddress = nonfungiblePositionManagerAddress[this.network];
+        const iNonfungiblePositionManager = new ethers.utils.Interface(
+          INonfungiblePositionManager.abi
+        );
+        txData = iNonfungiblePositionManager.encodeFunctionData(
+          Transaction.COLLECT,
+          [[tokenId, this.address, MaxUint128, MaxUint128]]
+        );
+        break;
+      case Dapp.ARRAKIS:
+      case Dapp.BALANCER:
+        contractAddress = tokenId;
+        const abi = new ethers.utils.Interface(ILiquidityGaugeV4.abi);
+        txData = abi.encodeFunctionData("claim_rewards()", []);
+        break;
+      case Dapp.VELODROME:
+        contractAddress = tokenId;
+        txData = getVelodromeClaimTxData(this, tokenId);
+        break;
+      default:
+        throw new Error("dapp not supported");
     }
     const tx = await this.poolLogic.execTransaction(
       contractAddress,
@@ -1078,4 +1114,115 @@ export class Pool {
     );
     return tx;
   }
+
+  /**
+   * Add liquidity to Velodrome pool
+   * @param {string} assetA First asset
+   * @param {string} assetB Second asset
+   * @param {BigNumber | string} amountA Amount first asset
+   * @param {BigNumber | string} amountB Amount second asset
+   * @param { boolean } isStable Is stable pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async addLiquidityVelodrome(
+    assetA: string,
+    assetB: string,
+    amountA: BigNumber | string,
+    amountB: BigNumber | string,
+    isStable: boolean,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.VELODROME],
+      getVelodromeAddLiquidityTxData(
+        this,
+        assetA,
+        assetB,
+        amountA,
+        amountB,
+        isStable
+      ),
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Remove liquidity from Velodrome pool
+   * @param {string} assetA First asset
+   * @param {string} assetB Second asset
+   * @param {BigNumber | string} amount Amount of LP tokens
+   * @param { boolean } isStable Is stable pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async removeLiquidityVelodrome(
+    assetA: string,
+    assetB: string,
+    amount: BigNumber | string,
+    isStable: boolean,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.VELODROME],
+      getVelodromeRemoveLiquidityTxData(this, assetA, assetB, amount, isStable),
+      options
+    );
+    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/services/velodrome/liquidity.ts

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BigNumber, ethers } from "ethers";
+import IVelodromeRouter from "../../abi/IVeldodromeRouter.json";
+import { deadline } from "../../config";
+import { Pool } from "../../entities";
+import { Transaction } from "../../types";
+
+export function getVelodromeAddLiquidityTxData(
+  pool: Pool,
+  assetA: string,
+  assetB: string,
+  amountA: BigNumber | string,
+  amountB: BigNumber | string,
+  isStable: boolean
+): any {
+  const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
+  return iVelodromeRouter.encodeFunctionData(Transaction.ADD_LIQUIDITY, [
+    assetA,
+    assetB,
+    isStable,
+    amountA,
+    amountB,
+    "0",
+    "0",
+    pool.address,
+    deadline
+  ]);
+}
+
+export function getVelodromeRemoveLiquidityTxData(
+  pool: Pool,
+  assetA: string,
+  assetB: string,
+  amount: BigNumber | string,
+  isStable: boolean
+): any {
+  const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
+  return iVelodromeRouter.encodeFunctionData(Transaction.REMOVE_LIQUIDITY, [
+    assetA,
+    assetB,
+    isStable,
+    amount,
+    "0",
+    "0",
+    pool.address,
+    deadline
+  ]);
+}

package/src/services/velodrome/staking.ts

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BigNumber, ethers } from "ethers";
+import IVelodromeGauge from "../../abi/IVelodromeGauge.json";
+import { Pool } from "../../entities";
+import { Transaction } from "../../types";
+import { call } from "../../utils/contract";
+const iVelodromeGauge = new ethers.utils.Interface(IVelodromeGauge.abi);
+
+export function getVelodromeStakeTxData(amount: BigNumber | string): any {
+  return iVelodromeGauge.encodeFunctionData(Transaction.DEPOSIT, [amount, "0"]);
+}
+
+export async function getVelodromeClaimTxData(
+  pool: Pool,
+  gauge: string
+): Promise<any> {
+  const rewardAssetCount = await call(pool.signer, IVelodromeGauge.abi, [
+    gauge,
+    "rewardsListLength",
+    []
+  ]);
+  const rewardAssets = await Promise.all(
+    Array.from(Array(rewardAssetCount.toNumber()).keys()).map(e =>
+      call(pool.signer, IVelodromeGauge.abi, [gauge, "rewards", [e]])
+    )
+  );
+  return iVelodromeGauge.encodeFunctionData("getReward", [
+    pool.address,
+    rewardAssets
+  ]);
+}

package/src/test/constants.ts

@@ -26,5 +26,8 @@ export const DAI = "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
 export const USDy = "0x1ec50880101022c11530a069690f5446d1464592";
 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";