@dhedge/v2-sdk 2.1.1 → 2.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "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/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";
 
@@ -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

package/src/services/pendle/index.ts

@@ -8,7 +8,7 @@ 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";
+const pendleBaseUrl = "https://api-v2.pendle.finance/core";
 
 export async function getPendleSwapTxData(
   pool: Pool,
@@ -41,7 +41,7 @@ export async function getPendleSwapTxData(
   const market = await getMarket(pool, tokenIn, tokenOut);
   try {
     const swapResult = await axios.get(
-      `${pendleBaseUrl}/sdk/${
+      `${pendleBaseUrl}/v2/sdk/${
         networkChainIdMap[pool.network]
       }/markets/${market}/swap`,
       { params }
@@ -70,9 +70,10 @@ export async function getMarket(
   const networkId = networkChainIdMap[pool.network];
   let marketResult;
   try {
-    marketResult = await axios.get(
-      `${pendleBaseUrl}/${networkId}/markets/active`
-    );
+    const params = { isActive: true, chainId: networkId };
+    marketResult = await axios.get(`${pendleBaseUrl}/v1/markets/all`, {
+      params
+    });
   } catch (e) {
     console.error("Error in Pendle API request:", e);
     throw new ApiError("Pendle api request failed");
@@ -103,9 +104,10 @@ const checkExitPostExpPT = async (
   const networkId = networkChainIdMap[pool.network];
   let inactiveMarketResult;
   try {
-    inactiveMarketResult = await axios.get(
-      `${pendleBaseUrl}/${networkId}/markets/inactive`
-    );
+    const params = { isActive: false, chainId: networkId };
+    inactiveMarketResult = await axios.get(`${pendleBaseUrl}/v1/markets/all`, {
+      params
+    });
   } catch (e) {
     console.error("Error in Pendle API request:", e);
     throw new ApiError("Pendle api request failed");

package/src/test/pendle.test.ts

@@ -18,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 = "0xab7f3837e6e721abbc826927b655180af6a04388";
   const PTweETH_matured = "0xe2b2d203577c7cb3d043e89ccf90b5e24d19b66f";
 
   let dhedge: Dhedge;
@@ -53,24 +53,24 @@ 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);

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