@dhedge/v2-sdk 1.10.15 → 1.11.0

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/services/uniswap/V3Liquidity.ts

@@ -19,7 +19,6 @@ import {
 } from "../../config";
 import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
 import IVeldodromePositionManager from "../../abi/IVelodromeNonfungiblePositionManager.json";
-import IShadowNonfungiblePositionManager from "../../abi/IShadowNonfungiblePositionManager.json";
 import IRamsesPositionManager from "../../abi/IRamsesNonfungiblePositionManager.json";
 import IArrakisV1RouterStaking from "../../abi/IArrakisV1RouterStaking.json";
 import IPancakeMasterChef from "../../abi/IPancakeMasterChefV3.json";
@@ -78,8 +77,8 @@ export async function getUniswapV3MintTxData(
     | Dapp.VELODROMECL
     | Dapp.AERODROMECL
     | Dapp.RAMSESCL
-    | Dapp.PANCAKECL
-    | Dapp.SHADOWCL,
+    | Dapp.PANCAKECL,
+
   pool: Pool,
   assetA: string,
   assetB: string,
@@ -170,12 +169,6 @@ export async function getUniswapV3MintTxData(
     mintParams.push(0);
   }
 
-  if (dapp === Dapp.SHADOWCL) {
-    iNonfungiblePositionManager = new ethers.utils.Interface(
-      IShadowNonfungiblePositionManager
-    );
-  }
-
   return iNonfungiblePositionManager.encodeFunctionData(Transaction.MINT, [
     mintParams
   ]);
@@ -196,9 +189,7 @@ export async function getUniswapV3Liquidity(
   const iNonfungiblePositionManager = new ethers.Contract(
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     nonfungiblePositionManagerAddress[pool.network][dapp]!,
-    dapp === Dapp.SHADOWCL
-      ? IShadowNonfungiblePositionManager
-      : INonfungiblePositionManager.abi,
+    INonfungiblePositionManager.abi,
     pool.signer
   );
   const result = await iNonfungiblePositionManager.positions(tokenId);
@@ -218,8 +209,7 @@ export async function getIncreaseLiquidityTxData(
     dapp === Dapp.VELODROMECL ||
     dapp === Dapp.AERODROMECL ||
     dapp === Dapp.RAMSESCL ||
-    dapp === Dapp.PANCAKECL ||
-    dapp === Dapp.SHADOWCL
+    dapp === Dapp.PANCAKECL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
@@ -256,8 +246,7 @@ export async function getDecreaseLiquidityTxData(
     dapp === Dapp.VELODROMECL ||
     dapp === Dapp.AERODROMECL ||
     dapp === Dapp.RAMSESCL ||
-    dapp === Dapp.PANCAKECL ||
-    dapp === Dapp.SHADOWCL
+    dapp === Dapp.PANCAKECL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     const liquidity = (await getUniswapV3Liquidity(dapp, tokenId, pool))

package/src/test/constants.ts

@@ -43,7 +43,7 @@ export const TEST_POOL = {
   [Network.OPTIMISM]: "0x12573bfdf764ab9d52aca20e2827497a66829716",
   [Network.ARBITRUM]: "0x0b5f6591c8eb23e5a68102d3d39ebbb464ee5c14",
   [Network.BASE]: "0x4842b42F68524383F609aa46eAfc18c1459cE3cD",
-  [Network.SONIC]: ""
+  [Network.ETHEREUM]: "0xe8e74f664d2d6a919a18b911990db0979789b6f7"
 };
 
 export const CONTRACT_ADDRESS = {
@@ -135,11 +135,11 @@ export const CONTRACT_ADDRESS = {
     COMPOUNDV3_WETH: "",
     TOROS: ""
   },
-  [Network.SONIC]: {
-    USDC: "0x29219dd400f2bf60e5a23d13be72b486d4038894",
+  [Network.ETHEREUM]: {
+    USDC: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
     USDT: "",
     SUSD: "",
-    WETH: "0x50c42deacd8fc9773493ed674b675be577f2634b",
+    WETH: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
     WBTC: "",
     SWETH: "",
     uniswapV3: {
@@ -164,7 +164,7 @@ export const USDC_BALANCEOF_SLOT = {
   [Network.ARBITRUM]: 9,
   [Network.POLYGON]: 0,
   [Network.BASE]: 9,
-  [Network.SONIC]: 9
+  [Network.ETHEREUM]: 9
 };
 
 export const WETH_BALANCEOF_SLOT = {
@@ -172,5 +172,5 @@ export const WETH_BALANCEOF_SLOT = {
   [Network.ARBITRUM]: 51,
   [Network.POLYGON]: 0,
   [Network.BASE]: 0,
-  [Network.SONIC]: 0
+  [Network.ETHEREUM]: 3
 };

package/src/test/oneInch.test.ts

@@ -34,6 +34,13 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
         "0x10000000000000000"
       ]);
       await provider.send("evm_mine", []);
+
+      const newAssets = [
+        { asset: USDC, isDeposit: true },
+        { asset: WETH, isDeposit: true }
+      ];
+
+      await pool.managerLogic.changeAssets(newAssets, []);
       // top up USDC
       await setUSDCAmount({
         amount: new BigNumber(2).times(1e6).toFixed(0),
@@ -104,10 +111,10 @@ const testOneInch = ({ wallet, network, provider }: TestingRunParams) => {
   });
 };
 
-testingHelper({
-  network: Network.OPTIMISM,
-  testingRun: testOneInch
-});
+// testingHelper({
+//   network: Network.OPTIMISM,
+//   testingRun: testOneInch
+// });
 
 // testingHelper({
 //   network: Network.POLYGON,
@@ -120,3 +127,8 @@ testingHelper({
 //   onFork: false,
 //   testingRun: testOneInch
 // });
+
+testingHelper({
+  network: Network.ETHEREUM,
+  testingRun: testOneInch
+});

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/test/wallet.ts

@@ -8,7 +8,7 @@ export const networkPortMap = {
   [Network.OPTIMISM]: 8544,
   [Network.ARBITRUM]: 8540,
   [Network.BASE]: 8546,
-  [Network.SONIC]: 8547
+  [Network.ETHEREUM]: 8547
 };
 
 export const getWalletData = (

package/src/types.ts

@@ -6,7 +6,7 @@ export enum Network {
   OPTIMISM = "optimism",
   ARBITRUM = "arbitrum",
   BASE = "base",
-  SONIC = "sonic"
+  ETHEREUM = "ethereum"
 }
 
 export enum Dapp {
@@ -31,7 +31,7 @@ export enum Dapp {
   PANCAKECL = "pancakeCL",
   COMPOUNDV3 = "compoundV3",
   ODOS = "odos",
-  SHADOWCL = "shadowCL"
+  PENDLE = "pendle"
 }
 
 export enum Transaction {