@dhedge/v2-sdk 1.9.8 → 1.10.0

package/src/services/flatmoney/stableLp.ts

@@ -0,0 +1,135 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import BigNumber from "bignumber.js";
+import { Pool, ethers } from "../..";
+import DelayedOrderAbi from "../../abi/flatmoney/DelayedOrder.json";
+import { flatMoneyContractAddresses } from "../../config";
+import { getPoolTxOrGasEstimate } from "../../utils/contract";
+import { getStableDepositQuote, getStableWithdrawQuote } from "./stableModule";
+import { getKeeperFee } from "./keeperFee";
+
+export function getAnnounceStableDepositTxData(
+  depositAmount: ethers.BigNumber | string,
+  minAmountOut: ethers.BigNumber | string,
+  keeperFee: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    DelayedOrderAbi
+  ).encodeFunctionData("announceStableDeposit", [
+    depositAmount,
+    minAmountOut,
+    keeperFee
+  ]);
+}
+
+export function getAnnounceStableWithdrawTxData(
+  withdrawAmount: ethers.BigNumber | string,
+  minAmountOut: ethers.BigNumber | string,
+  keeperFee: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    DelayedOrderAbi
+  ).encodeFunctionData("announceStableWithdraw", [
+    withdrawAmount,
+    minAmountOut,
+    keeperFee
+  ]);
+}
+
+export function getCancelExistingOrderTxData(account: string): string {
+  return new ethers.utils.Interface(
+    DelayedOrderAbi
+  ).encodeFunctionData("cancelExistingOrder", [account]);
+}
+
+export async function mintUnitViaFlatMoney(
+  pool: Pool,
+  depositAmount: ethers.BigNumber | string,
+  slippage: number, // 0.5 means 0.5%
+  maxKeeperFeeInUsd: number | null,
+  options: any = null,
+  estimateGas = false
+): Promise<any> {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error("mintUnitViaFlatMoney: network not supported");
+  }
+
+  const keeperfee = await getKeeperFee(pool, maxKeeperFeeInUsd); // in RETH
+
+  const adjustedDepositAmount = new BigNumber(depositAmount.toString()).minus(
+    keeperfee.toString() // keeper fee deducted from amountIn
+  );
+
+  const amountOut = await getStableDepositQuote(
+    pool,
+    adjustedDepositAmount.toFixed(0)
+  );
+  const minAmountOut = new BigNumber(amountOut.toString())
+    .times(1 - slippage / 100)
+    .toFixed(0);
+
+  const mintUnitTxData = await getAnnounceStableDepositTxData(
+    adjustedDepositAmount.toFixed(0),
+    minAmountOut,
+    keeperfee
+  );
+
+  const tx = await getPoolTxOrGasEstimate(
+    pool,
+    [flatMoneyContracts.DelayedOrder, mintUnitTxData, options],
+    estimateGas
+  );
+  return tx;
+}
+
+export async function redeemUnitViaFlatMoney(
+  pool: Pool,
+  withdrawAmount: ethers.BigNumber | string,
+  slippage: number, // 0.5 means 0.5%
+  maxKeeperFeeInUsd: number | null,
+  options: any = null,
+  estimateGas = false
+): Promise<any> {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error("redeemUnitViaFlatMoney: network not supported");
+  }
+  const keeperfee = await getKeeperFee(pool, maxKeeperFeeInUsd); // in RETH
+
+  const amountOut = await getStableWithdrawQuote(pool, withdrawAmount);
+  const minAmountOut = new BigNumber(amountOut.toString())
+    .times(1 - slippage / 100)
+    .minus(keeperfee.toString()) // keeper fee deducted from amountOut
+    .toFixed(0);
+
+  const redeemUnitTxData = await getAnnounceStableWithdrawTxData(
+    withdrawAmount,
+    minAmountOut,
+    keeperfee
+  );
+  const tx = await getPoolTxOrGasEstimate(
+    pool,
+    [flatMoneyContracts.DelayedOrder, redeemUnitTxData, options],
+    estimateGas
+  );
+  return tx;
+}
+
+export async function cancelOrderViaFlatMoney(
+  pool: Pool,
+  options: any = null,
+  estimateGas = false
+): Promise<any> {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error("cancelOrderViaFlatMoney: network not supported");
+  }
+  const cancelOrderTxData = await getCancelExistingOrderTxData(pool.address);
+  const tx = await getPoolTxOrGasEstimate(
+    pool,
+    [flatMoneyContracts.DelayedOrder, cancelOrderTxData, options],
+    estimateGas
+  );
+  return tx;
+}

package/src/services/flatmoney/stableModule.ts

@@ -0,0 +1,43 @@
+import { BigNumber, Contract } from "ethers";
+import { flatMoneyContractAddresses } from "../../config";
+import { Pool } from "../../entities";
+import StableModuleAbi from "../../abi/flatmoney/StableModule.json";
+
+const getStableModuleContract = (pool: Pool): Contract => {
+  const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+  if (!flatMoneyContracts) {
+    throw new Error(
+      `getStableModuleContract: network of ${pool.network} not supported`
+    );
+  }
+  const stableModuleContract = new Contract(
+    flatMoneyContracts.StableModule,
+    StableModuleAbi,
+    pool.signer
+  );
+  return stableModuleContract;
+};
+
+/// @notice Quoter function for getting the stable deposit amount out.
+export const getStableDepositQuote = async (
+  pool: Pool,
+  depositAmount: string | BigNumber
+): Promise<BigNumber> => {
+  const stableModuleContract = getStableModuleContract(pool);
+  const amountOut: BigNumber = await stableModuleContract.stableDepositQuote(
+    depositAmount.toString()
+  );
+  return amountOut;
+};
+
+/// @notice Quoter function for getting the stable withdraw amount out.
+export const getStableWithdrawQuote = async (
+  pool: Pool,
+  withdrawAmount: string | BigNumber
+): Promise<BigNumber> => {
+  const stableModuleContract = getStableModuleContract(pool);
+  const amountOut: BigNumber = await stableModuleContract.stableWithdrawQuote(
+    withdrawAmount.toString()
+  );
+  return amountOut;
+};

package/src/services/lyra/trade.ts

@@ -27,7 +27,7 @@ export async function getLyraOptionTxData(
   const filteredPosition = positions.filter(
     e =>
       e.strikeId.toNumber() === strikeId &&
-      isCall(e.optionType) == (optionType === "call") &&
+      isCall(e.optionType) === (optionType === "call") &&
       e.state === 1
   );
   const positionId =

package/src/services/uniswap/V3Liquidity.ts

@@ -1,4 +1,6 @@
-import { Price, Token } from "@uniswap/sdk-core";
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Token, Price } from "@uniswap/sdk-core";
 import {
   encodeSqrtRatioX96,
   FeeAmount,
@@ -9,14 +11,17 @@ import {
 } from "@uniswap/v3-sdk";
 import { ethers } from "ethers";
 import JSBI from "jsbi";
-import { Pool } from "../..";
+import { Dapp, Pool, Transaction } from "../..";
 import {
+  MaxUint128,
   networkChainIdMap,
   nonfungiblePositionManagerAddress
 } from "../../config";
-import { UniswapV3MintParams } from "./types";
 import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
+import IVeldodromePositionManager from "../../abi/IVelodromeNonfungiblePositionManager.json";
+import IArrakisV1RouterStaking from "../../abi/IArrakisV1RouterStaking.json";
 import { getDeadline } from "../../utils/deadline";
+import BigNumber from "bignumber.js";
 
 export function tryParsePrice(
   baseToken: Token,
@@ -42,7 +47,7 @@ export function tryParsePrice(
 export function tryParseTick(
   baseToken: Token,
   quoteToken: Token,
-  feeAmount: FeeAmount,
+  feeAmount: number,
   value: string
 ): number {
   const price = tryParsePrice(baseToken, quoteToken, value);
@@ -61,10 +66,11 @@ export function tryParseTick(
     tick = priceToClosestTick(price);
   }
 
-  return nearestUsableTick(tick, TICK_SPACINGS[feeAmount]);
+  return nearestUsableTick(tick, TICK_SPACINGS[feeAmount as FeeAmount]);
 }
 
-export async function getUniswapV3MintParams(
+export async function getUniswapV3MintTxData(
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
   pool: Pool,
   assetA: string,
   assetB: string,
@@ -74,8 +80,8 @@ export async function getUniswapV3MintParams(
   maxPrice: number | null,
   minTick: number | null,
   maxTick: number | null,
-  feeAmount: FeeAmount
-): Promise<UniswapV3MintParams> {
+  feeAmountOrTickSpacing: number
+): Promise<any> {
   let tickLower = 0;
   let tickUpper = 0;
   const chainId = networkChainIdMap[pool.network];
@@ -88,14 +94,33 @@ export async function getUniswapV3MintParams(
     ? [tokenA, tokenB]
     : [tokenB, tokenA];
   const invertPrice = !tokenA.equals(token0);
-
   if (minPrice && maxPrice) {
     tickLower = invertPrice
-      ? tryParseTick(token1, token0, feeAmount, maxPrice.toString())
-      : tryParseTick(token0, token1, feeAmount, minPrice.toString());
+      ? tryParseTick(
+          token1,
+          token0,
+          feeAmountOrTickSpacing,
+          maxPrice.toString()
+        )
+      : tryParseTick(
+          token0,
+          token1,
+          feeAmountOrTickSpacing,
+          minPrice.toString()
+        );
     tickUpper = invertPrice
-      ? tryParseTick(token1, token0, feeAmount, minPrice.toString())
-      : tryParseTick(token0, token1, feeAmount, maxPrice.toString());
+      ? tryParseTick(
+          token1,
+          token0,
+          feeAmountOrTickSpacing,
+          minPrice.toString()
+        )
+      : tryParseTick(
+          token0,
+          token1,
+          feeAmountOrTickSpacing,
+          maxPrice.toString()
+        );
   } else if (minTick && maxTick) {
     tickLower = minTick;
     tickUpper = maxTick;
@@ -104,10 +129,10 @@ export async function getUniswapV3MintParams(
     ? [amountB, amountA]
     : [amountA, amountB];
 
-  return [
+  const mintParams = [
     token0.address,
     token1.address,
-    feeAmount,
+    feeAmountOrTickSpacing,
     tickLower,
     tickUpper,
     amount0,
@@ -117,17 +142,115 @@ export async function getUniswapV3MintParams(
     pool.address,
     await getDeadline(pool)
   ];
+
+  let iNonfungiblePositionManager = new ethers.utils.Interface(
+    INonfungiblePositionManager.abi
+  );
+
+  if (dapp === Dapp.VELODROMECL) {
+    iNonfungiblePositionManager = new ethers.utils.Interface(
+      IVeldodromePositionManager.abi
+    );
+    mintParams.push(0);
+  }
+
+  return iNonfungiblePositionManager.encodeFunctionData(Transaction.MINT, [
+    mintParams
+  ]);
+
+  return;
 }
 
 export async function getUniswapV3Liquidity(
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
   tokenId: string,
   pool: Pool
-): Promise<ethers.BigNumber> {
+): Promise<BigNumber> {
   const iNonfungiblePositionManager = new ethers.Contract(
-    nonfungiblePositionManagerAddress[pool.network],
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    nonfungiblePositionManagerAddress[pool.network][dapp]!,
     INonfungiblePositionManager.abi,
     pool.signer
   );
   const result = await iNonfungiblePositionManager.positions(tokenId);
-  return result.liquidity;
+  return new BigNumber(result.liquidity.toString());
+}
+
+export async function getIncreaseLiquidityTxData(
+  pool: Pool,
+  dapp: Dapp,
+  tokenId: string,
+  amountA: ethers.BigNumber | string,
+  amountB: ethers.BigNumber | string
+): Promise<any> {
+  let txData;
+  if (dapp === Dapp.UNISWAPV3 || dapp === Dapp.VELODROMECL) {
+    const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
+    txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
+      [tokenId, amountA, amountB, 0, 0, await getDeadline(pool)]
+    ]);
+  } else if (dapp === Dapp.ARRAKIS) {
+    const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
+    txData = abi.encodeFunctionData(Transaction.ADD_LIQUIDITY_STAKE, [
+      tokenId,
+      amountA,
+      amountB,
+      0,
+      0,
+      0,
+      pool.address
+    ]);
+  } else {
+    throw new Error("dapp not supported");
+  }
+
+  return txData;
+}
+
+export async function getDecreaseLiquidityTxData(
+  pool: Pool,
+  dapp: Dapp,
+  tokenId: string,
+  amount = 100
+): Promise<any> {
+  let txData;
+  if (dapp === Dapp.UNISWAPV3 || dapp === Dapp.VELODROMECL) {
+    const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
+    const liquidity = (await getUniswapV3Liquidity(dapp, tokenId, pool))
+      .times(amount)
+      .div(100);
+
+    const decreaseLiquidityTxData = abi.encodeFunctionData(
+      Transaction.DECREASE_LIQUIDITY,
+      [[tokenId, liquidity.toFixed(0), 0, 0, await getDeadline(pool)]]
+    );
+    const collectTxData = abi.encodeFunctionData(Transaction.COLLECT, [
+      [tokenId, pool.address, MaxUint128, MaxUint128]
+    ]);
+
+    const multicallParams = [decreaseLiquidityTxData, collectTxData];
+
+    if (amount === 100) {
+      const burnTxData = abi.encodeFunctionData(Transaction.BURN, [tokenId]);
+      multicallParams.push(burnTxData);
+    }
+    txData = abi.encodeFunctionData(Transaction.MULTI_CALL, [multicallParams]);
+  } else if (dapp === Dapp.ARRAKIS) {
+    const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
+    const liquidity = new BigNumber(
+      (await pool.utils.getBalance(tokenId, pool.address)).toString()
+    )
+      .times(amount)
+      .div(100);
+    txData = abi.encodeFunctionData(Transaction.REMOVE_LIQUIDITY_UNSTAKE, [
+      tokenId,
+      liquidity,
+      0,
+      0,
+      pool.address
+    ]);
+  } else {
+    throw new Error("dapp not supported");
+  }
+  return txData;
 }

package/src/services/uniswap/V3Trade.ts

@@ -1,4 +1,3 @@
-import { FeeAmount } from "@uniswap/v3-sdk";
 import { ethers } from "ethers";
 import { Pool } from "../..";
 
@@ -12,7 +11,7 @@ export async function getUniswapV3SwapTxData(
   assetB: string,
   amountIn: string | ethers.BigNumber,
   slippage: number,
-  feeAmount: FeeAmount
+  feeAmount: number
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): Promise<any> {
   const quoterContract = new ethers.Contract(

package/src/services/velodrome/liquidity.ts

@@ -1,16 +1,20 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { BigNumber, ethers } from "ethers";
+import { ethers } from "ethers";
 import IVelodromeRouter from "../../abi/IVeldodromeRouter.json";
+import IVelodromeCLGauge from "../../abi/IVelodromeCLGauge.json";
 import { Pool } from "../../entities";
-import { Transaction } from "../../types";
+import { Dapp, Transaction } from "../../types";
 import { getDeadline } from "../../utils/deadline";
+import { getUniswapV3Liquidity } from "../uniswap/V3Liquidity";
+import { nonfungiblePositionManagerAddress } from "../../config";
+import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
 
 export async function getVelodromeAddLiquidityTxData(
   pool: Pool,
   assetA: string,
   assetB: string,
-  amountA: BigNumber | string,
-  amountB: BigNumber | string,
+  amountA: ethers.BigNumber | string,
+  amountB: ethers.BigNumber | string,
   isStable: boolean
 ): Promise<any> {
   const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
@@ -31,7 +35,7 @@ export async function getVelodromeRemoveLiquidityTxData(
   pool: Pool,
   assetA: string,
   assetB: string,
-  amount: BigNumber | string,
+  amount: ethers.BigNumber | string,
   isStable: boolean
 ): Promise<any> {
   const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
@@ -46,3 +50,71 @@ export async function getVelodromeRemoveLiquidityTxData(
     await getDeadline(pool)
   ]);
 }
+
+export async function getVelodromeCLDecreaseStakedLiquidityTxData(
+  pool: Pool,
+  tokenId: string,
+  amount: number
+): Promise<any> {
+  const abi = new ethers.utils.Interface(IVelodromeCLGauge.abi);
+  const liquidity = (
+    await getUniswapV3Liquidity(Dapp.VELODROMECL, tokenId, pool)
+  )
+    .times(amount)
+    .div(100);
+
+  return abi.encodeFunctionData("decreaseStakedLiquidity", [
+    tokenId,
+    liquidity.toFixed(0),
+    0,
+    0,
+    await getDeadline(pool)
+  ]);
+}
+
+export async function getVelodromeCLIncreaseStakedLiquidityTxData(
+  pool: Pool,
+  tokenId: string,
+  amountA: ethers.BigNumber | string,
+  amountB: ethers.BigNumber | string
+): Promise<any> {
+  const abi = new ethers.utils.Interface(IVelodromeCLGauge.abi);
+  return abi.encodeFunctionData("increaseStakedLiquidity", [
+    tokenId,
+    amountA,
+    amountB,
+    0,
+    0,
+    await getDeadline(pool)
+  ]);
+}
+
+export async function getVelodromeCLIncreaseLiquidityTxData(
+  pool: Pool,
+  tokenId: string,
+  amountA: ethers.BigNumber | string,
+  amountB: ethers.BigNumber | string
+): Promise<any> {
+  const abi = new ethers.utils.Interface(IVelodromeCLGauge.abi);
+  return abi.encodeFunctionData("increaseStakedLiquidity", [
+    tokenId,
+    amountA,
+    amountB,
+    0,
+    0,
+    await getDeadline(pool)
+  ]);
+}
+
+export async function getVelodromeClOwner(
+  pool: Pool,
+  tokenId: string
+): Promise<string> {
+  const iNonfungiblePositionManager = new ethers.Contract(
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    nonfungiblePositionManagerAddress[pool.network][Dapp.VELODROMECL]!,
+    INonfungiblePositionManager.abi,
+    pool.signer
+  );
+  return await iNonfungiblePositionManager.ownerOf(tokenId);
+}

package/src/services/velodrome/staking.ts

@@ -2,6 +2,7 @@
 import { BigNumber, ethers } from "ethers";
 import IVelodromeGaugeV1 from "../../abi/IVelodromeGauge.json";
 import IVelodromeGaugeV2 from "../../abi/IVelodromeGaugeV2.json";
+import IVelodromeCLGauge from "../../abi/IVelodromeCLGauge.json";
 import { Pool } from "../../entities";
 import { call } from "../../utils/contract";
 const iVelodromeGaugeV1 = new ethers.utils.Interface(IVelodromeGaugeV1.abi);
@@ -42,3 +43,8 @@ export async function getVelodromeClaimTxData(
     ]);
   }
 }
+
+export async function getVelodromeCLClaimTxData(tokenId: string): Promise<any> {
+  const iVelodromeCLGauge = new ethers.utils.Interface(IVelodromeCLGauge.abi);
+  return iVelodromeCLGauge.encodeFunctionData("getReward(uint256)", [tokenId]);
+}

package/src/test/constants.ts

@@ -56,11 +56,13 @@ export const CONTRACT_ADDRESS = {
     WMATIC: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
     uniswapV3: {
       nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
-    }
+    },
+    VELODROME_CL_USDC_WETH_GAUGE: "",
+    VELO: ""
   },
 
   [Network.OPTIMISM]: {
-    USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
+    USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
     SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     SWETH: "",
     WETH: "0x4200000000000000000000000000000000000006",
@@ -69,10 +71,13 @@ export const CONTRACT_ADDRESS = {
     uniswapV3: {
       nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
     },
+
     WMATIC: "",
     //
     ARRAKIS_USDC_WETH_GAUGE: "",
-    ARRAKIS_USDC_WETH_LP: ""
+    ARRAKIS_USDC_WETH_LP: "",
+    VELODROME_CL_USDC_WETH_GAUGE: "0x8d8d1CdDD5960276A1CDE360e7b5D210C3387948",
+    VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db"
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
@@ -90,7 +95,9 @@ export const CONTRACT_ADDRESS = {
     //
     ARRAKIS_USDC_WETH_GAUGE: "",
     ARRAKIS_USDC_WETH_LP: "",
-    WMATIC: ""
+    WMATIC: "",
+    VELODROME_CL_USDC_WETH_GAUGE: "",
+    VELO: ""
   },
   [Network.BASE]: {
     USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
@@ -103,15 +110,24 @@ export const CONTRACT_ADDRESS = {
     //
     ARRAKIS_USDC_WETH_GAUGE: "",
     ARRAKIS_USDC_WETH_LP: "",
-    WMATIC: ""
+    WMATIC: "",
+    VELODROME_CL_USDC_WETH_GAUGE: "",
+    VELO: ""
   }
 };
 
 export const MAX_AMOUNT = ethers.constants.MaxUint256;
 
 export const USDC_BALANCEOF_SLOT = {
-  [Network.OPTIMISM]: 0,
+  [Network.OPTIMISM]: 9,
   [Network.ARBITRUM]: 9,
   [Network.POLYGON]: 0,
   [Network.BASE]: 9
 };
+
+export const WETH_BALANCEOF_SLOT = {
+  [Network.OPTIMISM]: 3,
+  [Network.ARBITRUM]: 51,
+  [Network.POLYGON]: 0,
+  [Network.BASE]: 0
+};