@dhedge/v2-sdk 1.11.1 → 2.0.1

package/src/services/flatmoney/stableLp.ts

@@ -1,11 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import BigNumber from "bignumber.js";
-import { Pool, ethers } from "../..";
+import { Pool, SDKOptions, ethers } from "../..";
 import DelayedOrderAbi from "../../abi/flatmoney/DelayedOrder.json";
 import IOrderExecutionModuleAbi from "../../abi/flatmoney/v2/IOrderExecutionModule.json";
 import { flatMoneyContractAddresses } from "../../config";
-import { getPoolTxOrGasEstimate } from "../../utils/contract";
+import {
+  getPoolTxOrGasEstimate,
+  isSdkOptionsBoolean
+} from "../../utils/contract";
 import { getStableDepositQuote, getStableWithdrawQuote } from "./stableModule";
 import { getKeeperFee } from "./keeperFee";
 
@@ -55,7 +58,9 @@ export async function mintUnitViaFlatMoney(
   slippage: number, // 0.5 means 0.5%
   maxKeeperFeeInUsd: number | null,
   options: any = null,
-  estimateGas = false
+  sdkOptions: SDKOptions = {
+    estimateGas: false
+  }
 ): Promise<any> {
   const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
   if (!flatMoneyContracts) {
@@ -85,7 +90,7 @@ export async function mintUnitViaFlatMoney(
   const tx = await getPoolTxOrGasEstimate(
     pool,
     [flatMoneyContracts.DelayedOrder, mintUnitTxData, options],
-    estimateGas
+    sdkOptions
   );
   return tx;
 }
@@ -96,7 +101,9 @@ export async function redeemUnitViaFlatMoney(
   slippage: number, // 0.5 means 0.5%
   maxKeeperFeeInUsd: number | null,
   options: any = null,
-  estimateGas = false
+  sdkOptions: SDKOptions = {
+    estimateGas: false
+  }
 ): Promise<any> {
   const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
   if (!flatMoneyContracts) {
@@ -118,7 +125,7 @@ export async function redeemUnitViaFlatMoney(
   const tx = await getPoolTxOrGasEstimate(
     pool,
     [flatMoneyContracts.DelayedOrder, redeemUnitTxData, options],
-    estimateGas
+    sdkOptions
   );
   return tx;
 }
@@ -126,7 +133,9 @@ export async function redeemUnitViaFlatMoney(
 export async function cancelOrderViaFlatMoney(
   pool: Pool,
   options: any = null,
-  estimateGas = false
+  sdkOptions: SDKOptions = {
+    estimateGas: false
+  }
 ): Promise<any> {
   const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
   if (!flatMoneyContracts) {
@@ -140,18 +149,15 @@ export async function cancelOrderViaFlatMoney(
     toAddress = flatMoneyContracts.OrderExecution;
     cancelOrderTxData = await getCancelExistingOrderTxDataForV2(pool.address);
   }
-  // use trader address to cancel order
-  if (estimateGas) {
-    return pool.signer.estimateGas({
-      to: toAddress,
-      data: cancelOrderTxData
-    });
-  } else {
-    const tx = await pool.signer.sendTransaction({
-      to: toAddress,
-      data: cancelOrderTxData,
-      ...options
-    });
-    return tx;
-  }
+  const tx = await getPoolTxOrGasEstimate(
+    pool,
+    [toAddress, cancelOrderTxData, options],
+    {
+      ...(isSdkOptionsBoolean(sdkOptions)
+        ? { estimateGas: sdkOptions }
+        : sdkOptions),
+      useTraderAddressAsFrom: true
+    }
+  );
+  return tx;
 }

package/src/services/odos/index.ts

@@ -4,7 +4,7 @@ import { ApiError, ethers } from "../..";
 import { networkChainIdMap } from "../../config";
 import { Pool } from "../../entities";
 
-const odosBaseUrl = "https://api.odos.xyz/sor";
+export const odosBaseUrl = "https://api.odos.xyz/sor";
 
 export async function getOdosSwapTxData(
   pool: Pool,
@@ -12,7 +12,7 @@ export async function getOdosSwapTxData(
   assetTo: string,
   amountIn: ethers.BigNumber | string,
   slippage: number
-): Promise<string> {
+): Promise<{ swapTxData: string; minAmountOut: string }> {
   let referralCode = 0; //  Defaults to 0 for unregistered activity.
   if (
     process.env.ODOS_REFERAL_CODE &&
@@ -53,7 +53,10 @@ export async function getOdosSwapTxData(
       `${odosBaseUrl}/assemble`,
       assembleParams
     );
-    return assembleResult.data.transaction.data;
+    return {
+      swapTxData: assembleResult.data.transaction.data,
+      minAmountOut: assembleResult.data.outputTokens[0].amount
+    };
   } catch (e) {
     console.error("Error in Odos API request:", e);
     throw new ApiError("Swap api request of Odos failed");

package/src/services/pendle/index.ts

@@ -4,6 +4,9 @@ import { ApiError, ethers } from "../..";
 import { networkChainIdMap } from "../../config";
 import { Pool } from "../../entities";
 import ActionMiscV3Abi from "../../abi/pendle/ActionMiscV3.json";
+import PTAbi from "../../abi/pendle/PT.json";
+import SYAbi from "../../abi/pendle/SY.json";
+import BigNumber from "bignumber.js";
 
 const pendleBaseUrl = "https://api-v2.pendle.finance/core/v1";
 
@@ -13,17 +16,27 @@ export async function getPendleSwapTxData(
   tokenOut: string,
   amountIn: ethers.BigNumber | string,
   slippage: number
-): Promise<string> {
+): Promise<{ swapTxData: string; minAmountOut: string | null }> {
   const expiredMarket = await checkExitPostExpPT(pool, tokenIn, tokenOut);
   if (expiredMarket) {
-    return getExitExpPTTxData(pool, tokenOut, amountIn, expiredMarket);
+    const result = await getExitExpPTTxData(
+      pool,
+      tokenIn,
+      tokenOut,
+      amountIn,
+      expiredMarket
+    );
+    return {
+      swapTxData: result.txData,
+      minAmountOut: result.minAmountOut
+    };
   }
   const params = {
     receiver: pool.address,
     tokenIn,
     tokenOut,
     amountIn: amountIn.toString(),
-    slippage
+    slippage: slippage / 100
   };
   const market = await getMarket(pool, tokenIn, tokenOut);
   try {
@@ -33,8 +46,10 @@ export async function getPendleSwapTxData(
       }/markets/${market}/swap`,
       { params }
     );
-
-    return swapResult.data.tx.data;
+    return {
+      swapTxData: swapResult.data.tx.data,
+      minAmountOut: swapResult.data.data.amountOut
+    };
   } catch (e) {
     console.error("Error in Pendle API request:", e);
     throw new ApiError("Pendle api request failed");
@@ -111,12 +126,13 @@ const checkExitPostExpPT = async (
   }
 };
 
-const getExitExpPTTxData = (
+const getExitExpPTTxData = async (
   pool: Pool,
+  tokenIn: string,
   tokenOut: string,
   amountIn: ethers.BigNumber | string,
   market: string
-) => {
+): Promise<{ txData: string; minAmountOut: string | null }> => {
   const actionMiscV3 = new ethers.utils.Interface(ActionMiscV3Abi);
   const txData = actionMiscV3.encodeFunctionData("exitPostExpToToken", [
     pool.address, // receiver
@@ -137,5 +153,24 @@ const getExitExpPTTxData = (
       ]
     ]
   ]);
-  return txData;
+
+  // Get the PT contract instance
+  const PTcontract = new ethers.Contract(tokenIn, PTAbi, pool.signer);
+  // Get the SY contract instance
+  const SYcontract = new ethers.Contract(
+    await PTcontract.SY(),
+    SYAbi,
+    pool.signer
+  );
+
+  const exchangeRate = await SYcontract.exchangeRate();
+  const minAmountOut = new BigNumber(amountIn.toString())
+    .times(1e18)
+    .div(exchangeRate.toString())
+    .decimalPlaces(0, BigNumber.ROUND_DOWN)
+    .toFixed(0);
+  return {
+    txData,
+    minAmountOut
+  };
 };

package/src/services/toros/completeWithdrawal.ts

@@ -0,0 +1,209 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Dapp, ethers, Pool } from "../..";
+import { networkChainIdMap, routerAddress } from "../../config";
+import IEasySwapperV2 from "../../abi/IEasySwapperV2.json";
+import BigNumber from "bignumber.js";
+import AssetHandlerAbi from "../../abi/AssetHandler.json";
+import IERC20Abi from "../../abi/IERC20.json";
+import {
+  LOW_USD_VALUE_FOR_WITHDRAWAL,
+  SLIPPAGE_FOR_LOW_VALUE_SWAP
+} from "./easySwapper";
+import { retry } from "./retry";
+import { getSwapDataViaOdos, SWAPPER_ADDERSS } from "./swapData";
+
+export interface TrackedAsset {
+  token: string;
+  balance: ethers.BigNumber;
+}
+
+const getSwapWithdrawData = async (
+  pool: Pool,
+  trackedAssets: TrackedAsset[],
+  receiveToken: string,
+  slippage: number,
+  swapDestMinDestAmount: BigNumber
+) => {
+  const srcData = [];
+  const routerKey = ethers.utils.formatBytes32String("ODOS_V2");
+  // const destData
+  for (const { token, balance } of trackedAssets) {
+    if (token.toLowerCase() === receiveToken.toLowerCase()) {
+      continue;
+    }
+    const swapData = await retry({
+      fn: () => {
+        return getSwapDataViaOdos({
+          srcAsset: token,
+          srcAmount: balance.toString(),
+          dstAsset: receiveToken,
+          chainId: networkChainIdMap[pool.network],
+          from: SWAPPER_ADDERSS,
+          receiver: SWAPPER_ADDERSS,
+          slippage
+        });
+      },
+      delayMs: 1500,
+      maxRetries: 7
+    });
+    srcData.push({
+      token,
+      amount: balance,
+      aggregatorData: { routerKey, swapData }
+    });
+  }
+  return {
+    srcData,
+    destData: {
+      destToken: receiveToken,
+      minDestAmount: swapDestMinDestAmount.toString()
+    }
+  };
+};
+export const createCompleteWithdrawalTxArguments = async (
+  pool: Pool,
+  receiveToken: string,
+  slippage: number
+): Promise<any> => {
+  const easySwapper = new ethers.Contract(
+    routerAddress[pool.network][Dapp.TOROS] as string,
+    IEasySwapperV2,
+    pool.signer
+  );
+  const trackedAssets: TrackedAsset[] = await easySwapper.getTrackedAssets(
+    pool.address
+  );
+
+  if (
+    trackedAssets.length === 0 ||
+    trackedAssets.every(
+      ({ token }) => token.toLowerCase() === receiveToken.toLowerCase()
+    )
+  ) {
+    // just do simple complete withdraw
+    return {
+      isSwapNeeded: false,
+      swapData: null,
+      estimatedMinReceiveAmount: null
+    };
+  }
+
+  const swapTrackedAssets = trackedAssets.filter(
+    ({ token }) => token.toLowerCase() !== receiveToken.toLowerCase()
+  );
+
+  const assetHandlerAddress = await pool.factory.callStatic.getAssetHandler();
+  const assetHandler = new ethers.Contract(
+    assetHandlerAddress,
+    AssetHandlerAbi.abi,
+    pool.signer
+  );
+  const receiveTokenPriceD18 = new BigNumber(
+    (await assetHandler.getUSDPrice(receiveToken)).toString()
+  );
+  const receiveTokenErc20 = await new ethers.Contract(
+    receiveToken,
+    IERC20Abi.abi,
+    pool.signer
+  );
+  const receiveTokenDecimals = await receiveTokenErc20.decimals();
+  // swap dest minDestAmount
+  const tAssetInfos = await Promise.all(
+    swapTrackedAssets.map(async swapTAsset => {
+      const swapTAssetPriceD18 = new BigNumber(
+        (await assetHandler.getUSDPrice(swapTAsset.token)).toString()
+      );
+      const swapTAssetTokenErc20 = await new ethers.Contract(
+        swapTAsset.token,
+        IERC20Abi.abi,
+        pool.signer
+      );
+      const swapTAssetDecimals = await swapTAssetTokenErc20.decimals();
+      const tokenBalanceBN = new BigNumber(swapTAsset.balance.toString());
+      const estimatedValueToSwapD0 = tokenBalanceBN
+        .times(swapTAssetPriceD18)
+        .div(10 ** 18)
+        .div(10 ** Number(swapTAssetDecimals.toString()));
+
+      // --- caution: if the estimated value to swap is less than the low USD value for withdrawal, use a higher slippage
+      const adjustedSlippage = estimatedValueToSwapD0.lte(
+        LOW_USD_VALUE_FOR_WITHDRAWAL
+      )
+        ? SLIPPAGE_FOR_LOW_VALUE_SWAP
+        : slippage;
+      // -----
+
+      const estimatedMinReceiveAmount = tokenBalanceBN
+        .times(swapTAssetPriceD18)
+        .div(receiveTokenPriceD18)
+        .div(10 ** Number(swapTAssetDecimals.toString()))
+        .times(10 ** Number(receiveTokenDecimals.toString()))
+        .times(1 - adjustedSlippage / 10000) // slippage is in basis points, so divide by 10000
+        .decimalPlaces(0, BigNumber.ROUND_DOWN);
+
+      return {
+        token: swapTAsset.token,
+        balance: swapTAsset.balance,
+        estimatedMinReceiveAmount
+      };
+    })
+  );
+  const swapDestMinDestAmount = tAssetInfos.reduce(
+    (acc, { estimatedMinReceiveAmount }) => acc.plus(estimatedMinReceiveAmount),
+    new BigNumber(0)
+  );
+
+  const withdrawalVaultAddress = await easySwapper.withdrawalContracts(
+    pool.address
+  );
+  const balanceOfReceiveToken = await receiveTokenErc20.balanceOf(
+    withdrawalVaultAddress
+  );
+
+  // complete withdraw _expectedDestTokenAmount
+  const estimatedMinReceiveAmount = swapDestMinDestAmount.plus(
+    balanceOfReceiveToken.toString()
+  );
+
+  const swapData = await getSwapWithdrawData(
+    pool,
+    swapTrackedAssets,
+    receiveToken,
+    slippage,
+    estimatedMinReceiveAmount
+  );
+
+  return {
+    isSwapNeeded: true,
+    swapData,
+    estimatedMinReceiveAmount: estimatedMinReceiveAmount.toFixed(0)
+  };
+};
+
+export const getCompleteWithdrawalTxData = async (
+  pool: Pool,
+  receiveToken: string,
+  slippage: number,
+  useOnChainSwap: boolean
+): Promise<string> => {
+  const completeWithdrawTxArguments = await createCompleteWithdrawalTxArguments(
+    pool,
+    receiveToken,
+    slippage
+  );
+
+  const isSwapNeeded = completeWithdrawTxArguments.isSwapNeeded;
+  const isOffchainSwap = !useOnChainSwap && isSwapNeeded;
+  const iEasySwapperV2 = new ethers.utils.Interface(IEasySwapperV2);
+  if (isOffchainSwap) {
+    return iEasySwapperV2.encodeFunctionData(
+      "completeWithdrawal(((address,uint256,(bytes32,bytes))[],(address,uint256)),uint256)",
+      [
+        completeWithdrawTxArguments.swapData,
+        completeWithdrawTxArguments.estimatedMinReceiveAmount
+      ]
+    );
+  } else {
+    return iEasySwapperV2.encodeFunctionData("completeWithdrawal()");
+  }
+};

package/src/services/toros/easySwapper.ts

@@ -1,12 +1,15 @@
 import { ethers } from "ethers";
 import { Dapp, Pool } from "../..";
 
-import IDhedgeEasySwapper from "../../abi/IDhedgeEasySwapper.json";
+import IEasySwapperV2 from "../../abi/IEasySwapperV2.json";
 import { routerAddress } from "../../config";
-import { getChainlinkPriceInUsd } from "../chainLink/price";
+
 import { isPool, loadPool } from "./pool";
-import { getOneInchSwapTxData } from "../oneInch";
-import { wait } from "../../test/utils/testingHelper";
+
+import { getInitWithdrawalTxData } from "./initWithdrawal";
+
+export const LOW_USD_VALUE_FOR_WITHDRAWAL = 1; // 1 USD minimum value for withdrawal
+export const SLIPPAGE_FOR_LOW_VALUE_SWAP = 500;
 
 export async function getPoolDepositAsset(
   pool: Pool,
@@ -39,32 +42,13 @@ export async function getEasySwapperDepositQuote(
 ): Promise<ethers.BigNumber> {
   const easySwapper = new ethers.Contract(
     routerAddress[pool.network][Dapp.TOROS] as string,
-    IDhedgeEasySwapper,
+    IEasySwapperV2,
     pool.signer
   );
 
   return await easySwapper.depositQuote(torosAsset, investAsset, amountIn);
 }
 
-export async function getEasySwapperWithdrawalQuote(
-  pool: Pool,
-  torosAsset: string,
-  investAsset: string,
-  amountIn: ethers.BigNumber
-): Promise<ethers.BigNumber> {
-  const [torosTokenPrice, assetPrice, assetDecimals] = await Promise.all([
-    getTorosPoolTokenPrice(pool, torosAsset),
-    getChainlinkPriceInUsd(pool, investAsset),
-    pool.utils.getDecimals(investAsset)
-  ]);
-
-  return amountIn
-    .mul(torosTokenPrice)
-    .div(assetPrice)
-    .div(1e10)
-    .div(10 ** (18 - assetDecimals));
-}
-
 export async function getEasySwapperTxData(
   pool: Pool,
   assetFrom: string,
@@ -77,13 +61,15 @@ export async function getEasySwapperTxData(
   const [torosAsset, investAsset] = isWithdrawal
     ? [assetFrom, assetTo]
     : [assetTo, assetFrom];
-  const iDhedgeEasySwapper = new ethers.utils.Interface(IDhedgeEasySwapper);
+  const iEasySwapperV2 = new ethers.utils.Interface(IEasySwapperV2);
   if (isWithdrawal) {
-    return iDhedgeEasySwapper.encodeFunctionData("initWithdrawal", [
+    return getInitWithdrawalTxData(
+      pool,
       torosAsset,
-      amountIn,
-      slippage * 100
-    ]);
+      amountIn.toString(),
+      slippage * 100,
+      false
+    );
   } else {
     const depositAsset = await getPoolDepositAsset(
       pool,
@@ -99,7 +85,7 @@ export async function getEasySwapperTxData(
       investAsset,
       amountIn
     );
-    return iDhedgeEasySwapper.encodeFunctionData("depositWithCustomCooldown", [
+    return iEasySwapperV2.encodeFunctionData("depositWithCustomCooldown", [
       torosAsset,
       depositAsset,
       amountIn,
@@ -107,57 +93,3 @@ export async function getEasySwapperTxData(
     ]);
   }
 }
-
-export async function getCompleteWithdrawalTxData(
-  pool: Pool,
-  destToken: string,
-  slippage: number
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): Promise<string> {
-  const easySwapper = new ethers.Contract(
-    routerAddress[pool.network][Dapp.TOROS] as string,
-    IDhedgeEasySwapper,
-    pool.signer
-  );
-  const trackedAssets: {
-    token: string;
-    balance: ethers.BigNumber;
-  }[] = await easySwapper.getTrackedAssets(pool.address);
-  const trackedAssetsExcludingDestToken = trackedAssets.filter(
-    ({ token }) => token.toLowerCase() !== destToken.toLowerCase()
-  );
-
-  const srcData = [];
-  let minDestAmount = ethers.BigNumber.from(0);
-  for (const { token, balance } of trackedAssetsExcludingDestToken) {
-    const { swapTxData, dstAmount } = await getOneInchSwapTxData(
-      pool,
-      token,
-      destToken,
-      balance,
-      slippage,
-      true
-    );
-    srcData.push({
-      token,
-      amount: balance,
-      aggregatorData: {
-        routerKey: ethers.utils.formatBytes32String("ONE_INCH"),
-        swapData: swapTxData
-      }
-    });
-    minDestAmount = minDestAmount.add(dstAmount);
-    await wait(2);
-  }
-
-  return easySwapper.interface.encodeFunctionData("completeWithdrawal", [
-    {
-      srcData,
-      destData: {
-        destToken,
-        minDestAmount
-      }
-    },
-    minDestAmount.mul(10000 - slippage * 100).div(10000)
-  ]);
-}