@dhedge/v2-sdk 2.0.0 → 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,

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)
-  ]);
-}

package/src/services/toros/initWithdrawal.ts

@@ -0,0 +1,166 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Dapp, ethers, Pool } from "../..";
+import { networkChainIdMap, routerAddress } from "../../config";
+import { retry } from "./retry";
+import AaveLendingPoolAssetGuardAbi from "../../abi/IAaveLendingPoolAssetGuard.json";
+import IEasySwapperV2 from "../../abi/IEasySwapperV2.json";
+import { loadPool } from "./pool";
+import { getSwapDataViaOdos, SWAPPER_ADDERSS } from "./swapData";
+const AAVE_WITHDRAW_ONCHAIN_SWAP_SLIPPAGE = 150; // 1.5% slippage for onchain swap in Aave withdrawal
+
+const getCalculateSwapDataParams = async (
+  pool: Pool,
+  torosAsset: string,
+  amountIn: string,
+  slippage: number
+): Promise<{
+  offchainSwapNeeded: boolean;
+  swapDataParams: any;
+}> => {
+  const aaveAssetGuardAddress = await pool.factory.getAssetGuard(
+    routerAddress[pool.network][Dapp.AAVEV3] as string
+  );
+
+  const aaveAssetGuard = new ethers.Contract(
+    aaveAssetGuardAddress,
+    AaveLendingPoolAssetGuardAbi,
+    pool.signer
+  );
+  const swapDataParams = await aaveAssetGuard.callStatic.calculateSwapDataParams(
+    torosAsset,
+    amountIn,
+    slippage
+  );
+
+  return {
+    offchainSwapNeeded: swapDataParams.srcData.length !== 0,
+    swapDataParams
+  };
+};
+
+const getAaveAssetWithdrawData = async (
+  pool: Pool,
+  swapDataParams: any,
+  slippage: number
+) => {
+  const { srcData, dstData } = swapDataParams;
+
+  const srcDataToEncode: unknown[] = [];
+  const routerKey = ethers.utils.formatBytes32String("ODOS_V2");
+  for (const { asset, amount } of srcData) {
+    const swapData = await retry({
+      fn: () => {
+        return getSwapDataViaOdos({
+          srcAsset: asset,
+          srcAmount: amount.toString(),
+          dstAsset: dstData.asset,
+          chainId: networkChainIdMap[pool.network],
+          from: SWAPPER_ADDERSS,
+          receiver: SWAPPER_ADDERSS,
+          slippage
+        });
+      },
+      delayMs: 1500,
+      maxRetries: 7
+    });
+    srcDataToEncode.push([asset, amount, [routerKey, swapData]]);
+  }
+  const coder = ethers.utils.defaultAbiCoder;
+
+  const encodedSrcData = coder.encode(
+    ["tuple(address, uint256, tuple(bytes32, bytes))[]"],
+    [srcDataToEncode]
+  );
+  const withdrawData = coder.encode(
+    ["tuple(bytes, tuple(address, uint256), uint256)"],
+    [[encodedSrcData, [dstData.asset, dstData.amount], slippage]]
+  );
+
+  return withdrawData;
+};
+
+export const createWithdrawTxArguments = async (
+  pool: Pool,
+  torosAsset: string,
+  amountIn: string,
+  slippage: number,
+  useOnChainSwap: boolean
+): Promise<any> => {
+  const torosPool = await loadPool(pool, torosAsset);
+  const supportedAssets: {
+    asset: string;
+  }[] = await torosPool.managerLogic.getSupportedAssets();
+
+  if (useOnChainSwap) {
+    return supportedAssets.map(assetObj => {
+      return {
+        supportedAsset: assetObj.asset,
+        withdrawData: "0x",
+        slippageTolerance: AAVE_WITHDRAW_ONCHAIN_SWAP_SLIPPAGE
+      };
+    });
+  }
+
+  // for off-chain swap
+  const aaveLendingPoolAddress = routerAddress[pool.network][
+    Dapp.AAVEV3
+  ] as string;
+  return Promise.all(
+    supportedAssets.map(async assetObj => {
+      if (
+        assetObj.asset.toLowerCase() === aaveLendingPoolAddress.toLowerCase()
+      ) {
+        const {
+          offchainSwapNeeded,
+          swapDataParams
+        } = await getCalculateSwapDataParams(
+          pool,
+          torosAsset,
+          amountIn,
+          slippage
+        );
+        if (offchainSwapNeeded) {
+          const withdrawData = await getAaveAssetWithdrawData(
+            pool,
+            swapDataParams,
+            slippage
+          );
+
+          return {
+            supportedAsset: assetObj.asset,
+            withdrawData,
+            slippageTolerance: slippage
+          };
+        }
+      }
+
+      return {
+        supportedAsset: assetObj.asset,
+        withdrawData: "0x",
+        slippageTolerance: slippage
+      };
+    })
+  );
+};
+
+export const getInitWithdrawalTxData = async (
+  pool: Pool,
+  torosAsset: string,
+  amountIn: string,
+  slippage: number,
+  useOnChainSwap: boolean
+): Promise<string> => {
+  const complexAssetsData = await createWithdrawTxArguments(
+    pool,
+    torosAsset,
+    amountIn,
+    slippage,
+    useOnChainSwap
+  );
+  const iEasySwapperV2 = new ethers.utils.Interface(IEasySwapperV2);
+  return iEasySwapperV2.encodeFunctionData("initWithdrawal", [
+    torosAsset,
+    amountIn,
+    complexAssetsData
+  ]);
+};

package/src/services/toros/retry.ts

@@ -0,0 +1,28 @@
+export async function retry<T>({
+  fn,
+  maxRetries = 3,
+  delayMs = 1000
+}: {
+  fn: () => Promise<T>;
+  maxRetries?: number;
+  delayMs?: number;
+}): Promise<T> {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (attempt === maxRetries) {
+        throw new Error(`Retry failed after ${maxRetries} attempts: ${err}`);
+      }
+
+      console.warn(
+        `Retry ${attempt}/${maxRetries} failed, retrying in ${delayMs}ms`,
+        err
+      );
+      await new Promise(res => setTimeout(res, delayMs));
+    }
+  }
+
+  // Should never reach here
+  throw new Error("Unexpected retry failure");
+}