@dhedge/v2-sdk 1.11.1 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.11.1",
+  "version": "2.0.0",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",

package/src/abi/pendle/PT.json

@@ -0,0 +1,15 @@
+ [
+  {
+    "inputs": [],
+    "name": "SY",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

package/src/abi/pendle/SY.json

@@ -0,0 +1 @@
+[{"inputs":[],"name":"exchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

package/src/entities/pool.ts

@@ -372,9 +372,10 @@ export class Pool {
     estimateGas = false
   ): Promise<any> {
     let swapTxData: string;
+    let minAmountOut: string | null = null;
     switch (dapp) {
       case Dapp.ONEINCH:
-        ({ swapTxData } = await getOneInchSwapTxData(
+        ({ swapTxData, dstAmount: minAmountOut } = await getOneInchSwapTxData(
           this,
           assetFrom,
           assetTo,
@@ -415,28 +416,28 @@ export class Pool {
         );
         break;
       case Dapp.ODOS:
-        swapTxData = await getOdosSwapTxData(
+        ({ swapTxData, minAmountOut } = await getOdosSwapTxData(
           this,
           assetFrom,
           assetTo,
           amountIn,
           slippage
-        );
+        ));
         break;
       case Dapp.PENDLE:
-        swapTxData = await getPendleSwapTxData(
+        ({ swapTxData, minAmountOut } = await getPendleSwapTxData(
           this,
           assetFrom,
           assetTo,
           amountIn,
           slippage
-        );
+        ));
         break;
       default:
         const iUniswapV2Router = new ethers.utils.Interface(
           IUniswapV2Router.abi
         );
-        const minAmountOut = await this.utils.getMinAmountOut(
+        const calculatedMinAmountOut = await this.utils.getMinAmountOut(
           dapp,
           assetFrom,
           assetTo,
@@ -445,7 +446,7 @@ export class Pool {
         );
         swapTxData = iUniswapV2Router.encodeFunctionData(Transaction.SWAP, [
           amountIn,
-          minAmountOut,
+          calculatedMinAmountOut,
           [assetFrom, assetTo],
           this.address,
           await getDeadline(this)
@@ -453,7 +454,7 @@ export class Pool {
     }
     const tx = await getPoolTxOrGasEstimate(
       this,
-      [routerAddress[this.network][dapp], swapTxData, options],
+      [routerAddress[this.network][dapp], swapTxData, options, minAmountOut],
       estimateGas
     );
     return tx;

package/src/services/odos/index.ts

@@ -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/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/utils/contract.ts

@@ -101,17 +101,43 @@ export const getPoolTxOrGasEstimate = async (
 ): Promise<any> => {
   if (pool.isDhedge) {
     if (estimateGas) {
-      return await pool.poolLogic.estimateGas.execTransaction(
-        args[0],
-        args[1],
-        args[2]
-      );
+      let gas = null;
+      let gasEstimationError = null;
+      try {
+        gas = await pool.poolLogic.estimateGas.execTransaction(
+          args[0],
+          args[1],
+          args[2]
+        );
+      } catch (e) {
+        gasEstimationError = e;
+      }
+      return {
+        gas,
+        txData: args[1],
+        to: args[0],
+        gasEstimationError,
+        minAmountOut: args[3] || null
+      };
     } else {
       return await pool.poolLogic.execTransaction(args[0], args[1], args[2]);
     }
   } else {
     if (estimateGas) {
-      return await pool.signer.estimateGas({ to: args[0], data: args[1] });
+      let gas = null;
+      let gasEstimationError = null;
+      try {
+        gas = await pool.signer.estimateGas({ to: args[0], data: args[1] });
+      } catch (e) {
+        gasEstimationError = e;
+      }
+      return {
+        gas,
+        txData: args[1],
+        to: args[0],
+        gasEstimationError,
+        minAmountOut: args[3] || null
+      };
     } else {
       return await pool.signer.sendTransaction({
         to: args[0],