@dhedge/v2-sdk 1.10.15 → 1.10.16

package/package.json

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

package/src/abi/pendle/ActionMiscV3.json

@@ -0,0 +1,122 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "receiver",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "market",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "netPtIn",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "netLpIn",
+                "type": "uint256"
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "address",
+                        "name": "tokenOut",
+                        "type": "address"
+                    },
+                    {
+                        "internalType": "uint256",
+                        "name": "minTokenOut",
+                        "type": "uint256"
+                    },
+                    {
+                        "internalType": "address",
+                        "name": "tokenRedeemSy",
+                        "type": "address"
+                    },
+                    {
+                        "internalType": "address",
+                        "name": "pendleSwap",
+                        "type": "address"
+                    },
+                    {
+                        "components": [
+                            {
+                                "internalType": "enum SwapType",
+                                "name": "swapType",
+                                "type": "uint8"
+                            },
+                            {
+                                "internalType": "address",
+                                "name": "extRouter",
+                                "type": "address"
+                            },
+                            {
+                                "internalType": "bytes",
+                                "name": "extCalldata",
+                                "type": "bytes"
+                            },
+                            {
+                                "internalType": "bool",
+                                "name": "needScale",
+                                "type": "bool"
+                            }
+                        ],
+                        "internalType": "struct SwapData",
+                        "name": "swapData",
+                        "type": "tuple"
+                    }
+                ],
+                "internalType": "struct TokenOutput",
+                "name": "output",
+                "type": "tuple"
+            }
+        ],
+        "name": "exitPostExpToToken",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "totalTokenOut",
+                "type": "uint256"
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "uint256",
+                        "name": "netPtFromRemove",
+                        "type": "uint256"
+                    },
+                    {
+                        "internalType": "uint256",
+                        "name": "netSyFromRemove",
+                        "type": "uint256"
+                    },
+                    {
+                        "internalType": "uint256",
+                        "name": "netPtRedeem",
+                        "type": "uint256"
+                    },
+                    {
+                        "internalType": "uint256",
+                        "name": "netSyFromRedeem",
+                        "type": "uint256"
+                    },
+                    {
+                        "internalType": "uint256",
+                        "name": "totalSyOut",
+                        "type": "uint256"
+                    }
+                ],
+                "internalType": "struct IPActionMiscV3.ExitPostExpReturnParams",
+                "name": "params",
+                "type": "tuple"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

package/src/config.ts

@@ -44,7 +44,8 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.VELODROMEV2]: "0xa062ae8a9c5e11aaa026fc2670b0d65ccc8b2858",
     [Dapp.LYRA]: "0xCCE7819d65f348c64B7Beb205BA367b3fE33763B",
     [Dapp.ARRAKIS]: "0x9ce88a56d120300061593eF7AD074A1B710094d5",
-    [Dapp.ODOS]: "0xca423977156bb05b13a2ba3b76bc5419e2fe9680"
+    [Dapp.ODOS]: "0xca423977156bb05b13a2ba3b76bc5419e2fe9680",
+    [Dapp.PENDLE]: "0x888888888889758F76e7103c6CbF23ABbF58F946"
   },
   [Network.ARBITRUM]: {
     [Dapp.ONEINCH]: "0x111111125421ca6dc452d289314280a0f8842a65",
@@ -53,18 +54,21 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8",
     [Dapp.RAMSES]: "0xaaa87963efeb6f7e0a2711f397663105acb1805e",
     [Dapp.TOROS]: "0xA5679C4272A056Bb83f039961fae7D99C48529F5",
-    [Dapp.ODOS]: "0xa669e7A0d4b3e4Fa48af2dE86BD4CD7126Be4e13"
+    [Dapp.ODOS]: "0xa669e7A0d4b3e4Fa48af2dE86BD4CD7126Be4e13",
+    [Dapp.PENDLE]: "0x888888888889758F76e7103c6CbF23ABbF58F946"
   },
   [Network.BASE]: {
     [Dapp.ONEINCH]: "0x111111125421ca6dc452d289314280a0f8842a65",
     [Dapp.AERODROME]: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
     [Dapp.AAVEV3]: "0xA238Dd80C259a72e81d7e4664a9801593F98d1c5",
     [Dapp.TOROS]: "0xf067575Eb60c7587C11e867907AA7284833704d1",
-    [Dapp.ODOS]: "0x19cEeAd7105607Cd444F5ad10dd51356436095a1"
+    [Dapp.ODOS]: "0x19cEeAd7105607Cd444F5ad10dd51356436095a1",
+    [Dapp.PENDLE]: "0x888888888889758F76e7103c6CbF23ABbF58F946"
   },
   [Network.SONIC]: {
     [Dapp.AAVEV3]: "0x5362dBb1e601abF3a4c14c22ffEdA64042E5eAA3",
-    [Dapp.ODOS]: "0xaC041Df48dF9791B0654f1Dbbf2CC8450C5f2e9D"
+    [Dapp.ODOS]: "0xaC041Df48dF9791B0654f1Dbbf2CC8450C5f2e9D",
+    [Dapp.PENDLE]: "0x888888888889758F76e7103c6CbF23ABbF58F946"
   }
 };
 
@@ -204,5 +208,12 @@ export const flatMoneyContractAddresses: Readonly<Partial<
     FlatcoinVault: "0x86C7b9640302082B0dF78023F930d8612bFcaD3f",
     COLLATERAL: "0x68f180fcCe6836688e9084f035309E29Bf0A2095", // WBTC
     StableModule: "0x357CB23571EF7a3d6189b7FAcFC361eA71f7CAB5"
+  },
+  [Network.ARBITRUM]: {
+    OrderExecution: "0x7e50AD6E467D9FAFC3B4BFd003247cEaA2F17e5b",
+    DelayedOrder: "0x2326BB21B769D81E134C9b305ca156f989249fE7", // OrderAnnouncementModule
+    FlatcoinVault: "0x29fAD9d44C550e5D8081AB35763797B39d75b858",
+    COLLATERAL: "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f", // WBTC
+    StableModule: "0xcD3657cB0E851b6a734c4D1e7FC2640Bcd9f6B2d"
   }
 };

package/src/entities/pool.ts

@@ -86,6 +86,7 @@ import {
   getPancakeUnStakeTxData,
 } from "../services/pancake/staking";
 import { getOdosSwapTxData } from "../services/odos";
+import { getPendleSwapTxData } from "../services/pendle";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -422,6 +423,15 @@ export class Pool {
           slippage
         );
         break;
+      case Dapp.PENDLE:
+        swapTxData = await getPendleSwapTxData(
+          this,
+          assetFrom,
+          assetTo,
+          amountIn,
+          slippage
+        );
+        break;
       default:
         const iUniswapV2Router = new ethers.utils.Interface(
           IUniswapV2Router.abi

package/src/services/pendle/index.ts

@@ -0,0 +1,141 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import axios from "axios";
+import { ApiError, ethers } from "../..";
+import { networkChainIdMap } from "../../config";
+import { Pool } from "../../entities";
+import ActionMiscV3Abi from "../../abi/pendle/ActionMiscV3.json";
+
+const pendleBaseUrl = "https://api-v2.pendle.finance/core/v1";
+
+export async function getPendleSwapTxData(
+  pool: Pool,
+  tokenIn: string,
+  tokenOut: string,
+  amountIn: ethers.BigNumber | string,
+  slippage: number
+): Promise<string> {
+  const expiredMarket = await checkExitPostExpPT(pool, tokenIn, tokenOut);
+  if (expiredMarket) {
+    return getExitExpPTTxData(pool, tokenOut, amountIn, expiredMarket);
+  }
+  const params = {
+    receiver: pool.address,
+    tokenIn,
+    tokenOut,
+    amountIn: amountIn.toString(),
+    slippage
+  };
+  const market = await getMarket(pool, tokenIn, tokenOut);
+  try {
+    const swapResult = await axios.get(
+      `${pendleBaseUrl}/sdk/${
+        networkChainIdMap[pool.network]
+      }/markets/${market}/swap`,
+      { params }
+    );
+
+    return swapResult.data.tx.data;
+  } catch (e) {
+    console.error("Error in Pendle API request:", e);
+    throw new ApiError("Pendle api request failed");
+  }
+}
+
+const checkUnderlying = (market: any, token: string, networkId: number) => {
+  if (market.underlyingAsset !== `${networkId}-${token.toLocaleLowerCase()}`) {
+    throw new Error("Can only trade in or out of the underlying asset");
+  }
+};
+
+export async function getMarket(
+  pool: Pool,
+  tokenIn: string,
+  tokenOut: string
+): Promise<string> {
+  const networkId = networkChainIdMap[pool.network];
+  let marketResult;
+  try {
+    marketResult = await axios.get(
+      `${pendleBaseUrl}/${networkId}/markets/active`
+    );
+  } catch (e) {
+    console.error("Error in Pendle API request:", e);
+    throw new ApiError("Pendle api request failed");
+  }
+
+  const allMarkets = marketResult.data.markets;
+  const markets = [tokenIn, tokenOut].map(token =>
+    allMarkets.find(
+      (market: any) => market.pt === `${networkId}-${token.toLocaleLowerCase()}`
+    )
+  );
+  if (markets[0]) {
+    checkUnderlying(markets[0], tokenOut, networkId);
+    return markets[0].address;
+  } else if (markets[1]) {
+    checkUnderlying(markets[1], tokenIn, networkId);
+    return markets[1].address;
+  } else {
+    throw new Error("Can only trade PT assets");
+  }
+}
+
+const checkExitPostExpPT = async (
+  pool: Pool,
+  tokenIn: string,
+  tokenOut: string
+): Promise<string | null> => {
+  const networkId = networkChainIdMap[pool.network];
+  let inactiveMarketResult;
+  try {
+    inactiveMarketResult = await axios.get(
+      `${pendleBaseUrl}/${networkId}/markets/inactive`
+    );
+  } catch (e) {
+    console.error("Error in Pendle API request:", e);
+    throw new ApiError("Pendle api request failed");
+  }
+  const allInactiveMarkets = inactiveMarketResult.data.markets;
+  const markets = [tokenIn, tokenOut].map(token =>
+    allInactiveMarkets.find(
+      (market: any) => market.pt === `${networkId}-${token.toLocaleLowerCase()}`
+    )
+  );
+  if (markets[0]) {
+    checkUnderlying(markets[0], tokenOut, networkId);
+    return markets[0].address;
+  } else if (markets[1]) {
+    throw new Error("Can not trade to expired PT asset");
+  } else {
+    return null;
+  }
+};
+
+const getExitExpPTTxData = (
+  pool: Pool,
+  tokenOut: string,
+  amountIn: ethers.BigNumber | string,
+  market: string
+) => {
+  const actionMiscV3 = new ethers.utils.Interface(ActionMiscV3Abi);
+  const txData = actionMiscV3.encodeFunctionData("exitPostExpToToken", [
+    pool.address, // receiver
+    market, // market
+    amountIn.toString(), // netPtIn
+    0, // netLpIn
+    [
+      tokenOut,
+      0, // minTokenOut
+      tokenOut, // tokenRedeemSy,
+      ethers.constants.AddressZero, //pendleSwap;
+      // swapData
+      [
+        0, // swapType
+        ethers.constants.AddressZero, // extRouter
+        ethers.constants.HashZero, // extCalldata
+        false // needScale
+      ]
+    ]
+  ]);
+  return txData;
+};

package/src/test/pendle.test.ts

@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import { Dhedge, Pool } from "..";
+
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT } from "./constants";
+import {
+  TestingRunParams,
+  setTokenAmount,
+  setUSDCAmount,
+  testingHelper,
+  wait
+} from "./utils/testingHelper";
+
+import { getTxOptions } from "./txOptions";
+import BigNumber from "bignumber.js";
+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_matured = "0xe2b2d203577c7cb3d043e89ccf90b5e24d19b66f";
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(wallet.address, false);
+      // top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+      // top up USDC
+      await setUSDCAmount({
+        amount: new BigNumber(2000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+      await pool.approve(Dapp.ODOS, USDC, MAX_AMOUNT);
+      await pool.trade(
+        Dapp.ODOS,
+        USDC,
+        weETH,
+        "2000000000",
+        0.5,
+        await getTxOptions(network)
+      );
+    });
+
+    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("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 wait(3);
+      await pool.trade(
+        Dapp.PENDLE,
+        PTweETH_matured,
+        weETH,
+        PTweEthBalance,
+        0.5,
+        await getTxOptions(network)
+      );
+      const weEthBalanceDelta = await balanceDelta(
+        pool.address,
+        weETH,
+        pool.signer
+      );
+      expect(weEthBalanceDelta.eq(PTweEthBalance));
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testPendle
+});

package/src/types.ts

@@ -31,7 +31,8 @@ export enum Dapp {
   PANCAKECL = "pancakeCL",
   COMPOUNDV3 = "compoundV3",
   ODOS = "odos",
-  SHADOWCL = "shadowCL"
+  SHADOWCL = "shadowCL",
+  PENDLE = "pendle"
 }
 
 export enum Transaction {