@dhedge/v2-sdk 2.0.1 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "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/flatmoney.test.ts

@@ -118,6 +118,14 @@ const testFlatMoney = ({
       await expect(collateralAllowanceDelta.gt(0));
 
       const depositAmountStr = new BigNumber(1).times(1e18).toString();
+      const estimateData = await pool.mintUnitViaFlatMoney(
+        depositAmountStr,
+        0.5,
+        10, // set higher to tolerate high gasPrice returned by forked local chain
+        null,
+        true
+      );
+      expect(estimateData.gasEstimationError).toBe(null);
       const tx = await pool.mintUnitViaFlatMoney(
         depositAmountStr,
         0.5,
@@ -132,6 +140,12 @@ const testFlatMoney = ({
       expect(existingOrder.orderType).toBe(1);
     });
 
+    it("cancel order(estimate)", async () => {
+      await provider.send("evm_increaseTime", [60 * 2]); // more than 1 min
+      const res = await pool.cancelOrderViaFlatMoney({}, true);
+      expect(res.gasEstimationError).toBe(null);
+    });
+
     it("cancel order", async () => {
       await provider.send("evm_increaseTime", [60 * 2]); // more than 1 min
       await pool.cancelOrderViaFlatMoney();
@@ -148,6 +162,14 @@ const testFlatMoney = ({
       } else {
         withdrawAmountStr = new BigNumber(2).times(1e18).toString();
       }
+      const estimateData = await pool.redeemUnitViaFlatMoney(
+        withdrawAmountStr,
+        0.5,
+        10, //  set higher to tolerate high gasPrice returned by forked local chain
+        null,
+        true
+      );
+      expect(estimateData.gasEstimationError).toBe(null);
 
       const tx = await pool.redeemUnitViaFlatMoney(
         withdrawAmountStr,

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

package/src/utils/contract.ts

@@ -4,6 +4,7 @@ import set from "lodash/set";
 import { Interface } from "@ethersproject/abi";
 import { multiCallAddress } from "../config";
 import { ethers, Network, Pool, SDKOptions } from "..";
+import { Signer } from "ethers";
 
 export async function call(
   provider: ethers.Signer,
@@ -95,14 +96,29 @@ export class Multicaller {
 }
 
 const getGasEstimateData = async (
+  pool: Pool,
   estimateFunc: ethers.ContractFunction<ethers.BigNumber>,
   txInfoData: { to: string; txData: string; minAmountOut: any },
-  txOptions: any = {}
+  txOptions: any = {},
+  sdkOptions: SDKOptions
 ) => {
   let gas = null;
   let gasEstimationError = null;
   try {
-    gas = await estimateFunc(txInfoData.to, txInfoData.txData, txOptions);
+    if (
+      !pool.isDhedge ||
+      (!isSdkOptionsBoolean(sdkOptions) && sdkOptions.useTraderAddressAsFrom)
+    ) {
+      // for pool.signer.estimateGas
+      gas = await (estimateFunc as Signer["estimateGas"])({
+        to: txInfoData.to,
+        data: txInfoData.txData,
+        ...txOptions
+      });
+    } else {
+      // for pool.poolLogic.estimateGas.execTransaction
+      gas = await estimateFunc(txInfoData.to, txInfoData.txData, txOptions);
+    }
   } catch (e) {
     gasEstimationError = e;
   }
@@ -145,9 +161,11 @@ export const getPoolTxOrGasEstimate = async (
       (!isSdkOptionsBoolean(sdkOptions) && sdkOptions.estimateGas)
     ) {
       return await getGasEstimateData(
-        pool.signer.estimateGas,
+        pool,
+        pool.signer.estimateGas.bind(pool.signer),
         txInfoData,
-        txOptions
+        txOptions,
+        sdkOptions
       );
     } else {
       return await pool.signer.sendTransaction({
@@ -162,9 +180,11 @@ export const getPoolTxOrGasEstimate = async (
       (!isSdkOptionsBoolean(sdkOptions) && sdkOptions.estimateGas)
     ) {
       return await getGasEstimateData(
+        pool,
         pool.poolLogic.estimateGas.execTransaction,
         txInfoData,
-        txOptions
+        txOptions,
+        sdkOptions
       );
     } else {
       return await pool.poolLogic.execTransaction(