@dhedge/v2-sdk 2.0.1 → 2.0.2

package/package.json

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

package/src/abi/PoolManagerLogic.json

@@ -812,6 +812,19 @@
       ],
       "stateMutability": "view",
       "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bool",
+          "name": "_privatePool",
+          "type": "bool"
+        }
+      ],
+      "name": "setPoolPrivate",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
     }
   ]
 }

package/src/entities/pool.ts

@@ -993,6 +993,28 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Sets a pool private or public
+   * @param {boolean} _private True for private, false for public
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async setPrivate(
+    _private: boolean,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    if (estimateGas) {
+      return await this.managerLogic.estimateGas.setPoolPrivate(
+        _private,
+        options
+      );
+    }
+    const tx = await this.managerLogic.setPoolPrivate(_private, options);
+    return tx;
+  }
+
   /**
    * Invest into a Balancer pool
    * @param {string} poolId Balancer pool id

package/src/test/pool.test.ts

@@ -1,14 +1,8 @@
-import { BigNumber } from "ethers";
-import { Dhedge, ethers, Pool } from "..";
-import { AssetEnabled, Network } from "../types";
-import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
-
-import {
-  beforeAfterReset,
-  testingHelper,
-  TestingRunParams
-} from "./utils/testingHelper";
-import { allowanceDelta, balanceDelta } from "./utils/token";
+import { Dhedge, Pool } from "..";
+import { Network } from "../types";
+import { TEST_POOL } from "./constants";
+
+import { testingHelper, TestingRunParams } from "./utils/testingHelper";
 
 const testPool = ({ wallet, network, provider }: TestingRunParams) => {
   let dhedge: Dhedge;
@@ -20,85 +14,94 @@ const testPool = ({ wallet, network, provider }: TestingRunParams) => {
     beforeAll(async () => {
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
     });
-    beforeAfterReset({ beforeAll, afterAll, provider });
 
     it("checks fund composition", async () => {
       const result = await pool.getComposition();
       expect(result.length).toBeGreaterThan(0);
     });
 
-    it("approves USDC balance of User for Deposit", async () => {
-      await pool.approveDeposit(
-        CONTRACT_ADDRESS[network].USDC,
-        ethers.constants.MaxUint256
-      );
-      const UsdcAllowanceDelta = await allowanceDelta(
-        pool.signer.address,
-        CONTRACT_ADDRESS[network].USDC,
-        pool.address,
-        pool.signer
-      );
-      expect(UsdcAllowanceDelta.gt(0));
+    it("sets pool private", async () => {
+      const result = await pool.setPrivate(true);
+      expect(result).not.toBeNull();
     });
 
-    it("deposits 1 USDC into Pool", async () => {
-      await pool.deposit(CONTRACT_ADDRESS[network].USDC, (1e6).toString());
-      const poolTokenDelta = await balanceDelta(
-        pool.signer.address,
-        pool.address,
-        pool.signer
-      );
-      expect(poolTokenDelta.gt(0));
-    });
+    //   it("approves USDC balance of User for Deposit", async () => {
+    //     await pool.approveDeposit(
+    //       CONTRACT_ADDRESS[network].USDC,
+    //       ethers.constants.MaxUint256
+    //     );
+    //     const UsdcAllowanceDelta = await allowanceDelta(
+    //       pool.signer.address,
+    //       CONTRACT_ADDRESS[network].USDC,
+    //       pool.address,
+    //       pool.signer
+    //     );
+    //     expect(UsdcAllowanceDelta.gt(0));
+    //   });
 
-    it("adds WBTC to enabled assets", async () => {
-      const assetsBefore = await pool.getComposition();
-
-      const newAssets: AssetEnabled[] = [
-        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
-        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: false },
-        { asset: CONTRACT_ADDRESS[network].WBTC, isDeposit: false }
-      ];
-      await pool.changeAssets(newAssets);
-      const assetsAfter = await pool.getComposition();
-      if (assetsBefore.length < newAssets.length) {
-        expect(assetsAfter.length).toBeGreaterThan(assetsBefore.length);
-      } else {
-        expect(assetsAfter.length).toBeLessThanOrEqual(assetsBefore.length);
-      }
-    });
+    //   it("deposits 1 USDC into Pool", async () => {
+    //     await pool.deposit(CONTRACT_ADDRESS[network].USDC, (1e6).toString());
+    //     const poolTokenDelta = await balanceDelta(
+    //       pool.signer.address,
+    //       pool.address,
+    //       pool.signer
+    //     );
+    //     expect(poolTokenDelta.gt(0));
+    //   });
 
-    it("get available Manager Fee", async () => {
-      const result = await pool.getAvailableManagerFee();
-      expect(result).toBeInstanceOf(BigNumber);
-    });
+    //   it("adds WBTC to enabled assets", async () => {
+    //     const assetsBefore = await pool.getComposition();
 
-    it("mintManagerFee; should not revert", async () => {
-      const tx = await pool.mintManagerFee();
-      expect(tx).toHaveProperty("wait");
-    });
+    //     const newAssets: AssetEnabled[] = [
+    //       { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
+    //       { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: false },
+    //       { asset: CONTRACT_ADDRESS[network].WBTC, isDeposit: false }
+    //     ];
+    //     await pool.changeAssets(newAssets);
+    //     const assetsAfter = await pool.getComposition();
+    //     if (assetsBefore.length < newAssets.length) {
+    //       expect(assetsAfter.length).toBeGreaterThan(assetsBefore.length);
+    //     } else {
+    //       expect(assetsAfter.length).toBeLessThanOrEqual(assetsBefore.length);
+    //     }
+    //   });
 
-    it("withdraw 0.1 pool token into Pool", async () => {
-      await provider.send("evm_increaseTime", [24 * 60 * 60]);
-      await provider.send("evm_mine", []);
-      await pool.withdraw((0.1 * 1e18).toString());
-      const poolTokenDelta = await balanceDelta(
-        pool.signer.address,
-        pool.address,
-        pool.signer
-      );
-      expect(poolTokenDelta.lt(0));
-    });
+    //   it("get available Manager Fee", async () => {
+    //     const result = await pool.getAvailableManagerFee();
+    //     expect(result).toBeInstanceOf(BigNumber);
+    //   });
+
+    //   it("mintManagerFee; should not revert", async () => {
+    //     const tx = await pool.mintManagerFee();
+    //     expect(tx).toHaveProperty("wait");
+    //   });
+
+    //   it("withdraw 0.1 pool token into Pool", async () => {
+    //     await provider.send("evm_increaseTime", [24 * 60 * 60]);
+    //     await provider.send("evm_mine", []);
+    //     await pool.withdraw((0.1 * 1e18).toString());
+    //     const poolTokenDelta = await balanceDelta(
+    //       pool.signer.address,
+    //       pool.address,
+    //       pool.signer
+    //     );
+    //     expect(poolTokenDelta.lt(0));
+    //   });
   });
 };
 
-testingHelper({
-  network: Network.POLYGON,
-  testingRun: testPool
-});
-
 // testingHelper({
-//   network: Network.OPTIMISM,
+//   network: Network.POLYGON,
 //   testingRun: testPool
 // });
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testPool
+});