@dhedge/v2-sdk 1.11.0 → 2.0.0

package/package.json

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

package/src/abi/fluid/IFToken.json

@@ -0,0 +1,27 @@
+[
+  {
+    "inputs": [
+      { "internalType": "uint256", "name": "assets_", "type": "uint256" },
+      { "internalType": "address", "name": "receiver_", "type": "address" }
+    ],
+    "name": "deposit",
+    "outputs": [
+      { "internalType": "uint256", "name": "shares_", "type": "uint256" }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      { "internalType": "uint256", "name": "shares_", "type": "uint256" },
+      { "internalType": "address", "name": "receiver_", "type": "address" },
+      { "internalType": "address", "name": "owner_", "type": "address" }
+    ],
+    "name": "redeem",
+    "outputs": [
+      { "internalType": "uint256", "name": "assets_", "type": "uint256" }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]

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;
@@ -717,8 +718,8 @@ export class Pool {
   }
 
   /**
-   * Lend asset to a Compound V3 style lending pool
-   * @param {string} market Address of market e.g cUSDCv3 address
+   * Lend asset to a Compound V3 or Fluid lending pool
+   * @param {string} market Address of cToken or fToken
    * @param {string} asset Asset
    * @param {BigNumber | string} amount Amount of asset to lend
    * @param {any} options Transaction options
@@ -732,7 +733,12 @@ export class Pool {
     options: any = null,
     estimateGas = false
   ): Promise<any> {
-    const supplyTxData = getCompoundV3LendTxData(asset, amount);
+    const supplyTxData = await getCompoundV3LendTxData(
+      this,
+      market,
+      asset,
+      amount
+    );
 
     const tx = await getPoolTxOrGasEstimate(
       this,
@@ -773,8 +779,8 @@ export class Pool {
   }
 
   /**
-   * Witdraw asset from a COmpound V3 style lending pool
-   * @param {string} market Address of market e.g cUSDCv3 address
+   * Witdraw asset from a Compound V3 or Fluid lending pool
+   * @param {string} market Address of cToken or fToken
    * @param {string} asset Asset
    * @param  {BigNumber | string} amount Amount of asset to withdraw
    * @param {any} options Transaction options
@@ -788,7 +794,12 @@ export class Pool {
     options: any = null,
     estimateGas = false
   ): Promise<any> {
-    const withdrawTxData = getCompoundV3WithdrawTxData(asset, amount);
+    const withdrawTxData = await getCompoundV3WithdrawTxData(
+      this,
+      market,
+      asset,
+      amount
+    );
 
     const tx = await getPoolTxOrGasEstimate(
       this,

package/src/services/compound/lending.ts

@@ -1,20 +1,59 @@
-import { ethers } from "../..";
+import { ethers, Pool } from "../..";
 import ICompoundV3Comet from "../../abi/compound/ICompoundV3Comet.json";
+import IFToken from "../../abi/fluid/IFToken.json";
 
-export function getCompoundV3LendTxData(
+export async function getCompoundV3LendTxData(
+  pool: Pool,
+  market: string,
   asset: string,
   amount: ethers.BigNumber | string
-): string {
-  return new ethers.utils.Interface(
-    ICompoundV3Comet
-  ).encodeFunctionData("supply", [asset, amount]);
+): Promise<string> {
+  if (await isCompoundV3Market(pool, market)) {
+    return new ethers.utils.Interface(
+      ICompoundV3Comet
+    ).encodeFunctionData("supply", [asset, amount]);
+  } else {
+    //Fluid lending
+    return new ethers.utils.Interface(IFToken).encodeFunctionData("deposit", [
+      amount,
+      pool.address
+    ]);
+  }
 }
 
-export function getCompoundV3WithdrawTxData(
+export async function getCompoundV3WithdrawTxData(
+  pool: Pool,
+  market: string,
   asset: string,
   amount: ethers.BigNumber | string
-): string {
-  return new ethers.utils.Interface(
-    ICompoundV3Comet
-  ).encodeFunctionData("withdraw", [asset, amount]);
+): Promise<string> {
+  if (await isCompoundV3Market(pool, market)) {
+    return new ethers.utils.Interface(
+      ICompoundV3Comet
+    ).encodeFunctionData("withdraw", [asset, amount]);
+  } else {
+    //Fluid withdrawal
+    return new ethers.utils.Interface(IFToken).encodeFunctionData("redeem", [
+      amount,
+      pool.address,
+      pool.address
+    ]);
+  }
+}
+
+export async function isCompoundV3Market(
+  pool: Pool,
+  market: string
+): Promise<boolean> {
+  const marketContract = new ethers.Contract(
+    market,
+    ICompoundV3Comet,
+    pool.signer
+  );
+  try {
+    await marketContract.baseToken();
+    return true;
+  } catch (error) {
+    return false;
+  }
 }

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/constants.ts

@@ -63,6 +63,7 @@ export const CONTRACT_ADDRESS = {
     VELODROME_CL_USDC_WETH_GAUGE: "",
     VELO: "",
     COMPOUNDV3_WETH: "",
+    FLUID_WETH: "",
     TOROS: "",
     UNIT: ""
   },
@@ -87,6 +88,7 @@ export const CONTRACT_ADDRESS = {
     VELODROME_CL_USDC_WETH_GAUGE: "0xa75127121d28a9BF848F3B70e7Eea26570aa7700",
     VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db",
     COMPOUNDV3_WETH: "",
+    FLUID_WETH: "",
     TOROS: "0x49bf093277bf4dde49c48c6aa55a3bda3eedef68" //USDmny
   },
   [Network.ARBITRUM]: {
@@ -113,6 +115,7 @@ export const CONTRACT_ADDRESS = {
     VELODROME_CL_USDC_WETH_GAUGE: "",
     VELO: "",
     COMPOUNDV3_WETH: "0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486",
+    FLUID_WETH: "0x45df0656f8adf017590009d2f1898eeca4f0a205",
     TOROS: ""
   },
   [Network.BASE]: {
@@ -133,6 +136,7 @@ export const CONTRACT_ADDRESS = {
     VELODROME_CL_USDC_WETH_GAUGE: "0xF33a96b5932D9E9B9A0eDA447AbD8C9d48d2e0c8",
     VELO: "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
     COMPOUNDV3_WETH: "",
+    FLUID_WETH: "",
     TOROS: ""
   },
   [Network.ETHEREUM]: {
@@ -152,6 +156,7 @@ export const CONTRACT_ADDRESS = {
     VELODROME_CL_USDC_WETH_GAUGE: "",
     VELO: "",
     COMPOUNDV3_WETH: "",
+    FLUID_WETH: "",
     TOROS: "",
     UNIT: ""
   }

package/src/test/fluid.test.ts

@@ -0,0 +1,90 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import BigNumber from "bignumber.js";
+import { Dhedge, Pool } from "..";
+import { AssetEnabled, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setWETHAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import { getWalletData } from "./wallet";
+
+const testFluid = ({ network, provider }: TestingRunParams) => {
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  const FLUID_WETH = CONTRACT_ADDRESS[network].FLUID_WETH;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] compound V3 tests`, () => {
+    beforeAll(async () => {
+      const { wallet } = getWalletData(network);
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+      await setWETHAmount({
+        amount: new BigNumber(1e18).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+
+      const newAssets: AssetEnabled[] = [
+        { asset: WETH, isDeposit: true },
+        {
+          asset: FLUID_WETH,
+          isDeposit: false
+        }
+      ];
+      await pool.managerLogic.changeAssets(newAssets, []);
+    });
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    it("approves unlimited WETH for fWETH market", async () => {
+      await pool.approveSpender(FLUID_WETH, WETH, MAX_AMOUNT);
+      const wethAllowanceDelta = await allowanceDelta(
+        pool.address,
+        WETH,
+        FLUID_WETH,
+        pool.signer
+      );
+      await expect(wethAllowanceDelta.gt(0));
+    });
+
+    it("lends WETH to Fluid WETH market", async () => {
+      const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+      await pool.lendCompoundV3(FLUID_WETH, WETH, wethBalance);
+
+      const fWETHTokenDelta = await balanceDelta(
+        pool.address,
+        FLUID_WETH,
+        pool.signer
+      );
+      expect(fWETHTokenDelta.gt(0));
+    });
+
+    it("withdraw WETH from Fluid WETH market", async () => {
+      const fWETHBalance = await pool.utils.getBalance(
+        FLUID_WETH,
+        pool.address
+      );
+      await pool.withdrawCompoundV3(FLUID_WETH, WETH, fWETHBalance);
+      const wethBalance = await balanceDelta(pool.address, WETH, pool.signer);
+      expect(wethBalance.gt(0));
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testFluid
+});

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