@dhedge/v2-sdk 1.11.1 → 2.0.1

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");
+}

package/src/services/toros/swapData.ts

@@ -0,0 +1,70 @@
+import axios from "axios";
+import BigNumber from "bignumber.js";
+import { odosBaseUrl } from "../odos";
+
+export const SWAPPER_ADDERSS = "0x4F754e0F0924afD74980886b0B479Fa1D7C58D0D";
+
+export interface SwapParams {
+  srcAsset: string; // Source asset address
+  srcAmount: string; // Amount to swap (use string for big numbers)
+  dstAsset: string; // Destination asset address
+  chainId: number; // Chain ID
+  from: string; // Sender address
+  receiver: string; // Receiver address
+  slippage: number; // Slippage tolerance in basis points (100 = 1%)
+}
+
+export const getSwapDataViaOdos = async ({
+  srcAsset,
+  srcAmount,
+  dstAsset,
+  chainId,
+  from,
+  slippage
+}: SwapParams): Promise<string> => {
+  let referralCode = 0; //  Defaults to 0 for unregistered activity.
+  if (
+    process.env.ODOS_REFERAL_CODE &&
+    Number(process.env.ODOS_REFERAL_CODE) > 0
+  ) {
+    referralCode = Number(process.env.ODOS_REFERAL_CODE);
+  }
+  const quoteParams = {
+    chainId: chainId,
+    inputTokens: [
+      {
+        tokenAddress: srcAsset,
+        amount: srcAmount
+      }
+    ],
+    outputTokens: [
+      {
+        tokenAddress: dstAsset,
+        proportion: 1
+      }
+    ],
+    slippageLimitPercent: new BigNumber(slippage).div(100).toString(), // Convert basis points to percentage
+    userAddr: from,
+    referralCode
+  };
+  try {
+    const quoteResult = await axios.post(
+      `${odosBaseUrl}/quote/v2`,
+      quoteParams
+    );
+
+    const assembleParams = {
+      pathId: quoteResult.data.pathId,
+      userAddr: from
+    };
+
+    const assembleResult = await axios.post(
+      `${odosBaseUrl}/assemble`,
+      assembleParams
+    );
+    return assembleResult.data.transaction.data;
+  } catch (e) {
+    console.error("Error in Odos API request:", e);
+    throw new Error("Swap api request of Odos failed");
+  }
+};

package/src/test/constants.ts

@@ -89,7 +89,7 @@ export const CONTRACT_ADDRESS = {
     VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db",
     COMPOUNDV3_WETH: "",
     FLUID_WETH: "",
-    TOROS: "0x49bf093277bf4dde49c48c6aa55a3bda3eedef68" //USDmny
+    TOROS: "0xcacb5a722a36cff6baeb359e21c098a4acbffdfa" //ETHBEAR1X
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",

package/src/test/odos.test.ts

@@ -63,7 +63,8 @@ const testOdos = ({ wallet, network, provider }: TestingRunParams) => {
         await getTxOptions(network),
         true
       );
-      expect(gasEstimate.gt(0));
+      expect(gasEstimate.gas.gt(0));
+      expect(gasEstimate.minAmountOut).not.toBeNull();
     });
 
     it("trades 2 USDC into WETH on Odos", async () => {
@@ -86,16 +87,16 @@ const testOdos = ({ wallet, network, provider }: TestingRunParams) => {
   });
 };
 
-// testingHelper({
-//   network: Network.OPTIMISM,
-//   testingRun: testOdos
-// });
-
 testingHelper({
-  network: Network.ARBITRUM,
+  network: Network.OPTIMISM,
   testingRun: testOdos
 });
 
+// testingHelper({
+//   network: Network.ARBITRUM,
+//   testingRun: testOdos
+// });
+
 // testingHelper({
 //   network: Network.POLYGON,
 //   onFork: false,

package/src/test/oneInch.test.ts

@@ -71,24 +71,22 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
         await getTxOptions(network),
         true
       );
-      expect(gasEstimate.gt(0));
+      expect(gasEstimate.gas.gt(0));
+      expect(gasEstimate.minAmountOut).not.toBeNull();
     });
 
     it("gets error on gas estimation for 200 USDC into WETH on 1Inch", async () => {
       await wait(1);
-      let gasEstimate = null;
-      try {
-        gasEstimate = await pool.trade(
-          Dapp.ONEINCH,
-          USDC,
-          WETH,
-          "200000000",
-          1,
-          await getTxOptions(network),
-          true
-        );
-      } catch (err) {}
-      expect(gasEstimate).toBeNull();
+      const gasEstimate = await pool.trade(
+        Dapp.ONEINCH,
+        USDC,
+        WETH,
+        "200000000",
+        1,
+        await getTxOptions(network),
+        true
+      );
+      expect(gasEstimate.gasEstimationError).not.toBeNull();
     });
 
     it("trades 2 USDC into WETH on 1Inch", async () => {
@@ -111,10 +109,10 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
   });
 };
 
-// testingHelper({
-//   network: Network.OPTIMISM,
-//   testingRun: testOneInch
-// });
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testOneInch
+});
 
 // testingHelper({
 //   network: Network.POLYGON,
@@ -128,7 +126,7 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
 //   testingRun: testOneInch
 // });
 
-testingHelper({
-  network: Network.ETHEREUM,
-  testingRun: testOneInch
-});
+// testingHelper({
+//   network: Network.ETHEREUM,
+//   testingRun: testOneInch
+// });

package/src/test/pendle.test.ts

@@ -8,8 +8,7 @@ import {
   TestingRunParams,
   setTokenAmount,
   setUSDCAmount,
-  testingHelper,
-  wait
+  testingHelper
 } from "./utils/testingHelper";
 
 import { getTxOptions } from "./txOptions";
@@ -19,7 +18,7 @@ import { balanceDelta } from "./utils/token";
 const testPendle = ({ wallet, network, provider }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
   const weETH = "0x35751007a407ca6feffe80b3cb397736d2cf4dbe";
-  const PTweETH = "0xb33808ea0e883138680ba29311a220a7377cdb92";
+  // const PTweETH = "0xb33808ea0e883138680ba29311a220a7377cdb92";
   const PTweETH_matured = "0xe2b2d203577c7cb3d043e89ccf90b5e24d19b66f";
 
   let dhedge: Dhedge;
@@ -54,33 +53,62 @@ const testPendle = ({ wallet, network, provider }: TestingRunParams) => {
       );
     });
 
-    it("swaps weETH to PTweETH on Pendle", async () => {
-      await pool.approve(Dapp.PENDLE, weETH, MAX_AMOUNT);
-      const weEthBalance = await pool.utils.getBalance(weETH, pool.address);
-      await pool.trade(
-        Dapp.PENDLE,
-        weETH,
-        PTweETH,
-        weEthBalance,
-        0.5,
-        await getTxOptions(network)
-      );
-      const ptWeEthBalanceDelta = await balanceDelta(
-        pool.address,
-        PTweETH,
-        pool.signer
-      );
-      expect(ptWeEthBalanceDelta.gt(0));
-    });
+    // it("swaps weETH to PTweETH on Pendle", async () => {
+    //   await pool.approve(Dapp.PENDLE, weETH, MAX_AMOUNT);
+    //   const weEthBalance = await pool.utils.getBalance(weETH, pool.address);
+    //   await pool.trade(
+    //     Dapp.PENDLE,
+    //     weETH,
+    //     PTweETH,
+    //     weEthBalance,
+    //     0.5,
+    //     await getTxOptions(network)
+    //   );
+    //   const ptWeEthBalanceDelta = await balanceDelta(
+    //     pool.address,
+    //     PTweETH,
+    //     pool.signer
+    //   );
+    //   expect(ptWeEthBalanceDelta.gt(0));
+    // });
+
+    // it("swaps PTweETH to weETH on Pendle", async () => {
+    //   await pool.approve(Dapp.PENDLE, PTweETH, MAX_AMOUNT);
+    //   const PTweEthBalance = await pool.utils.getBalance(PTweETH, pool.address);
+    //   console.log("PTweEthBalance", PTweEthBalance.toString());
+    //   await wait(3);
+    //   await pool.trade(
+    //     Dapp.PENDLE,
+    //     PTweETH,
+    //     weETH,
+    //     PTweEthBalance,
+    //     0.5,
+    //     await getTxOptions(network)
+    //   );
+    //   const weEthBalanceDelta = await balanceDelta(
+    //     pool.address,
+    //     weETH,
+    //     pool.signer
+    //   );
+    //   expect(weEthBalanceDelta.gt(0));
+    // });
 
-    it("swaps PTweETH to weETH on Pendle", async () => {
-      await pool.approve(Dapp.PENDLE, PTweETH, MAX_AMOUNT);
-      const PTweEthBalance = await pool.utils.getBalance(PTweETH, pool.address);
-      console.log("PTweEthBalance", PTweEthBalance.toString());
-      await wait(3);
+    it("exit matured PTweETH to weETH on Pendle", async () => {
+      await setTokenAmount({
+        amount: new BigNumber(1).times(1e18).toString(),
+        provider,
+        tokenAddress: PTweETH_matured,
+        slot: 0,
+        userAddress: pool.address
+      });
+      await pool.approve(Dapp.PENDLE, PTweETH_matured, MAX_AMOUNT);
+      const PTweEthBalance = await pool.utils.getBalance(
+        PTweETH_matured,
+        pool.address
+      );
       await pool.trade(
         Dapp.PENDLE,
-        PTweETH,
+        PTweETH_matured,
         weETH,
         PTweEthBalance,
         0.5,
@@ -91,7 +119,7 @@ const testPendle = ({ wallet, network, provider }: TestingRunParams) => {
         weETH,
         pool.signer
       );
-      expect(weEthBalanceDelta.gt(0));
+      expect(weEthBalanceDelta.eq(PTweEthBalance));
     });
 
     it("exit matured PTweETH to weETH on Pendle", async () => {
@@ -107,21 +135,19 @@ const testPendle = ({ wallet, network, provider }: TestingRunParams) => {
         PTweETH_matured,
         pool.address
       );
-      await wait(3);
-      await pool.trade(
+      const result = await pool.trade(
         Dapp.PENDLE,
         PTweETH_matured,
         weETH,
         PTweEthBalance,
         0.5,
-        await getTxOptions(network)
-      );
-      const weEthBalanceDelta = await balanceDelta(
-        pool.address,
-        weETH,
-        pool.signer
+        await getTxOptions(network),
+        true
       );
-      expect(weEthBalanceDelta.eq(PTweEthBalance));
+
+      expect(result.gas).not.toBeNull();
+      expect(result.minAmountOut).not.toBeNull();
+      expect(result.gasEstimationError).toBeNull();
     });
   });
 };

package/src/test/toros.test.ts

@@ -1,18 +1,19 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
+import BigNumber from "bignumber.js";
 import { Dhedge, Pool } from "..";
 import { routerAddress } from "../config";
 
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
 import {
-  TestingRunParams,
   setChainlinkTimeout,
   setUSDCAmount,
-  testingHelper
+  testingHelper,
+  TestingRunParams
 } from "./utils/testingHelper";
+
 import { allowanceDelta, balanceDelta } from "./utils/token";
-import BigNumber from "bignumber.js";
 
 const testToros = ({ wallet, network, provider }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
@@ -34,7 +35,7 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
       ]);
       await provider.send("evm_mine", []);
       // top up USDC
-      const amount = new BigNumber(1000).times(1e6).toFixed(0);
+      const amount = new BigNumber(100).times(1e6).toFixed(0);
       await setUSDCAmount({
         amount,
         userAddress: pool.address,
@@ -56,7 +57,7 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
 
     it("trades USDC balance into Toros Token", async () => {
       const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
-      await pool.trade(Dapp.TOROS, USDC, TOROS, usdcBalance, 1);
+      await pool.trade(Dapp.TOROS, USDC, TOROS, usdcBalance, 1.5);
       const torosBalanceDelta = await balanceDelta(
         pool.address,
         TOROS,
@@ -70,7 +71,7 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
       await provider.send("evm_mine", []);
       const torosBalance = await pool.utils.getBalance(TOROS, pool.address);
       await pool.approve(Dapp.TOROS, TOROS, MAX_AMOUNT);
-      await pool.trade(Dapp.TOROS, TOROS, USDC, torosBalance, 1);
+      await pool.trade(Dapp.TOROS, TOROS, USDC, torosBalance, 1.5);
       const torosBalanceDelta = await balanceDelta(
         pool.address,
         TOROS,
@@ -80,7 +81,7 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
     });
 
     it("complete withdrawal from Toros asset", async () => {
-      await pool.completeTorosWithdrawal(USDC, 1);
+      await pool.completeTorosWithdrawal(USDC, 1.5);
       const usdcBalanceDelta = await balanceDelta(
         pool.address,
         USDC,
@@ -93,5 +94,6 @@ const testToros = ({ wallet, network, provider }: TestingRunParams) => {
 
 testingHelper({
   network: Network.OPTIMISM,
-  testingRun: testToros
+  testingRun: testToros,
+  onFork: true
 });

package/src/types.ts

@@ -101,3 +101,11 @@ export type LyraPosition = {
   collateral: BigNumber;
   state: number;
 };
+
+export type SDKOptions =
+  | {
+      estimateGas: boolean;
+      onlyGetTxData?: boolean;
+      useTraderAddressAsFrom?: boolean;
+    }
+  | boolean; // shorthand for { estimateGas: true/false }; for backward compatibility