@dhedge/v2-sdk 2.1.2 → 2.1.4

package/package.json

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

package/src/abi/PoolManagerLogic.json

@@ -825,6 +825,32 @@
       "outputs": [],
       "stateMutability": "nonpayable",
       "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "_maxSupplyCapD18",
+          "type": "uint256"
+        }
+      ],
+      "name": "setMaxSupplyCap",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "maxSupplyCap",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
     }
   ]
-}
+}

package/src/abi/pendle/PT.json

@@ -11,5 +11,18 @@
     ],
     "stateMutability": "view",
     "type": "function"
+  },
+   {
+    "inputs": [],
+    "name": "YT",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
   }
 ]

package/src/entities/pool.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Contract, ethers, Wallet, BigNumber } from "ethers";
+import { Contract, ethers, Wallet, BigNumber, BigNumberish } from "ethers";
 
 import IERC20 from "../abi/IERC20.json";
 
@@ -84,7 +84,7 @@ import {
   getPancakeUnStakeTxData
 } from "../services/pancake/staking";
 import { getOdosSwapTxData } from "../services/odos";
-import { getPendleSwapTxData } from "../services/pendle";
+import { getPendleMintTxData, getPendleSwapTxData } from "../services/pendle";
 import { getCompleteWithdrawalTxData } from "../services/toros/completeWithdrawal";
 import { getKyberSwapTxData } from "../services/kyberSwap";
 
@@ -1025,6 +1025,31 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Sets max supply cap for a pool
+   * @param {BigNumberish} _maxSupplyCapD18 Max supply cap with 18 decimals
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async setMaxCap(
+    _maxSupplyCapD18: BigNumberish,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    if (estimateGas) {
+      return await this.managerLogic.estimateGas.setMaxSupplyCap(
+        _maxSupplyCapD18,
+        options
+      );
+    }
+    const tx = await this.managerLogic.setMaxSupplyCap(
+      _maxSupplyCapD18,
+      options
+    );
+    return tx;
+  }
+
   /**
    * Invest into a Balancer pool
    * @param {string} poolId Balancer pool id
@@ -2082,4 +2107,44 @@ export class Pool {
     );
     return tx;
   }
+
+  /**
+   * Mint PT and YT tokens on Pendle
+   * @param {string} assetFrom Asset to mint from (only underlying asset)
+   * @param {string} pt PT address
+   * @param {BigNumber | string} amountIn Amount underlying asset
+   * @param {number} slippage Slippage tolerance in %
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+  async mintPendle(
+    assetFrom: string,
+    pt: string,
+    amountIn: BigNumber | string,
+    slippage = 0.5,
+    options: any = null,
+    sdkOptions: SDKOptions = {
+      estimateGas: false
+    }
+  ): Promise<any> {
+    const { swapTxData, minAmountOut } = await getPendleMintTxData(
+      this,
+      assetFrom,
+      pt,
+      amountIn,
+      slippage
+    );
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [
+        routerAddress[this.network][Dapp.PENDLE],
+        swapTxData,
+        options,
+        minAmountOut
+      ],
+      sdkOptions
+    );
+    return tx;
+  }
 }

package/src/services/pendle/index.ts

@@ -56,6 +56,39 @@ export async function getPendleSwapTxData(
   }
 }
 
+export async function getPendleMintTxData(
+  pool: Pool,
+  tokenIn: string,
+  pt: string,
+  amountIn: ethers.BigNumber | string,
+  slippage: number
+): Promise<{ swapTxData: string; minAmountOut: string | null }> {
+  const PTcontract = new ethers.Contract(pt, PTAbi, pool.signer);
+  const ytAddress = await PTcontract.YT();
+  const params = {
+    receiver: pool.address,
+    tokensIn: tokenIn,
+    tokensOut: `${pt},${ytAddress}`,
+    amountsIn: amountIn.toString(),
+    slippage: slippage / 100
+  };
+  try {
+    const swapResult = await axios.get(
+      `${pendleBaseUrl}/v2/sdk/${networkChainIdMap[pool.network]}/convert`,
+      { params }
+    );
+    return {
+      swapTxData: swapResult.data.routes[0].tx.data,
+      minAmountOut: swapResult.data.routes[0].outputs.filter(
+        (e: { token: string }) => e.token === pt.toLowerCase()
+      )[0].amount
+    };
+  } 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");

package/src/test/pendleMint.test.ts

@@ -0,0 +1,59 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import { Dhedge, Pool } from "..";
+
+import { Network } from "../types";
+import { CONTRACT_ADDRESS } from "./constants";
+import { getTxOptions } from "./txOptions";
+import { TestingRunParams, testingHelper } from "./utils/testingHelper";
+
+const testPendle = ({ wallet, network }: TestingRunParams) => {
+  const USDE = CONTRACT_ADDRESS[network].USDE;
+  const PTJan26Usde = "0x93b544c330f60a2aa05ced87aeeffb8d38fd8c9a";
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(
+        "0xdad21646ebb0997eb59de1f6a68a67059daf4c31"
+      );
+    });
+
+    it("can get TX Data for mint PT and SY", async () => {
+      const usdeBalance = await pool.utils.getBalance(USDE, pool.address);
+      const { txData, minAmountOut } = await pool.mintPendle(
+        USDE,
+        PTJan26Usde,
+        usdeBalance,
+        0.5,
+        null,
+        { onlyGetTxData: true, estimateGas: true }
+      );
+      expect(txData).not.toBeNull();
+      expect(minAmountOut).not.toBeNull();
+    });
+
+    it("can get for mint PT and SY", async () => {
+      const usdeBalance = await pool.utils.getBalance(USDE, pool.address);
+      await pool.mintPendle(
+        USDE,
+        PTJan26Usde,
+        usdeBalance,
+        0.5,
+        await getTxOptions(network)
+      );
+      const ptBalance = await pool.utils.getBalance(PTJan26Usde, pool.address);
+      expect(ptBalance.gt(0)).toBe(true);
+    });
+  });
+};
+
+testingHelper({
+  network: Network.PLASMA,
+  onFork: false,
+  testingRun: testPendle
+});

package/src/test/pool.test.ts

@@ -1,16 +1,15 @@
+import { BigNumber } from "ethers";
 import { Dhedge, Pool } from "..";
 import { Network } from "../types";
-import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { TEST_POOL } from "./constants";
 
 import { testingHelper, TestingRunParams } from "./utils/testingHelper";
-import { balanceDelta } from "./utils/token";
+// import { balanceDelta } from "./utils/token";
 
-const testPool = ({ wallet, network }: TestingRunParams) => {
+const testPool = ({ wallet, network, provider }: TestingRunParams) => {
   let dhedge: Dhedge;
   let pool: Pool;
 
-  const USDT = CONTRACT_ADDRESS[network].USDT;
-
   jest.setTimeout(200000);
 
   describe(`pool on ${network}`, () => {
@@ -18,18 +17,31 @@ const testPool = ({ wallet, network }: TestingRunParams) => {
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
 
-      // await provider.send("hardhat_setBalance", [
-      //   wallet.address,
-      //   "0x10000000000000000"
-      // ]);
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
     });
 
     it("checks fund composition", async () => {
       const result = await pool.getComposition();
-      console.log(result);
+      // console.log(result);
       expect(result.length).toBeGreaterThan(0);
     });
 
+    it("sets max supply cap", async () => {
+      const totalSupply: BigNumber = await pool.poolLogic.totalSupply();
+      let initCap = totalSupply;
+      if (totalSupply.eq(0)) {
+        initCap = BigNumber.from(1000).mul(BigNumber.from(10).pow(18));
+      }
+      await pool.setMaxCap(initCap.mul(2), null, true);
+      const tx = await pool.setMaxCap(initCap.mul(2));
+      await tx.wait(1);
+      const maxCapAfter: BigNumber = await pool.managerLogic.maxSupplyCap();
+      expect(maxCapAfter).toEqual(initCap.mul(2));
+    });
+
     // it("sets pool private", async () => {
     //   const result = await pool.setPrivate(true);
     //   expect(result).not.toBeNull();
@@ -65,18 +77,18 @@ const testPool = ({ wallet, network }: TestingRunParams) => {
     //   expect(usdtAllowanceDelta.gt(0));
     // });
 
-    it("deposits 200 USDT into Pool", async () => {
-      await pool.deposit(
-        CONTRACT_ADDRESS[network].USDT,
-        (200000000).toString()
-      );
-      const poolTokenDelta = await balanceDelta(
-        pool.address,
-        USDT,
-        pool.signer
-      );
-      expect(poolTokenDelta.gt(0));
-    });
+    // it("deposits 200 USDT into Pool", async () => {
+    //   await pool.deposit(
+    //     CONTRACT_ADDRESS[network].USDT,
+    //     (200000000).toString()
+    //   );
+    //   const poolTokenDelta = await balanceDelta(
+    //     pool.address,
+    //     USDT,
+    //     pool.signer
+    //   );
+    //   expect(poolTokenDelta.gt(0));
+    // });
 
     //   it("get available Manager Fee", async () => {
     //     const result = await pool.getAvailableManagerFee();
@@ -108,7 +120,6 @@ const testPool = ({ wallet, network }: TestingRunParams) => {
 // });
 
 testingHelper({
-  network: Network.PLASMA,
-  onFork: false,
+  network: Network.ARBITRUM,
   testingRun: testPool
 });