@gearbox-protocol/sdk 13.1.0 → 13.2.0-next.1

package/dist/cjs/sdk/market/pool/PoolV310Contract.js

@@ -25,16 +25,20 @@ var import_generated = require("../../../abi/310/generated.js");
 var import_iPausable = require("../../../abi/iPausable.js");
 var import_base = require("../../base/index.js");
 var import_utils = require("../../utils/index.js");
+var import_SecuritizeKYCFactory = require("./SecuritizeKYCFactory.js");
 const abi = [...import_generated.iPoolV310Abi, ...import_iPausable.iPausableAbi];
 class PoolV310Contract extends import_base.BaseContract {
   creditManagerDebtParams;
-  constructor(options, data) {
+  #sdk;
+  #kycFactory;
+  constructor(sdk, data) {
     const { baseParams, creditManagerDebtParams, ...rest } = data;
-    super(options, {
+    super(sdk, {
       ...data.baseParams,
       name: `PoolV3(${data.name})`,
       abi
     });
+    this.#sdk = sdk;
     Object.assign(this, rest);
     this.creditManagerDebtParams = new import_utils.AddressMap(
       creditManagerDebtParams.map((p) => [p.creditManager, p])
@@ -46,6 +50,17 @@ class PoolV310Contract extends import_base.BaseContract {
       symbol: data.symbol
     });
   }
+  async getKYCFactory() {
+    if (this.#kycFactory) {
+      return this.#kycFactory;
+    }
+    await this.#sdk.tokensMeta.loadTokenData(this.underlying);
+    const u = this.#sdk.tokensMeta.mustGet(this.underlying);
+    if (this.#sdk.tokensMeta.isKYCUnderlying(u)) {
+      this.#kycFactory = new import_SecuritizeKYCFactory.SecuritizeKYCFactory(this.#sdk, u.kycFactory);
+    }
+    return this.#kycFactory;
+  }
   stateHuman(raw = true) {
     return {
       ...super.stateHuman(raw),

package/dist/cjs/sdk/market/pool/SecuritizeKYCFactory.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SecuritizeKYCFactory_exports = {};
+__export(SecuritizeKYCFactory_exports, {
+  SecuritizeKYCFactory: () => SecuritizeKYCFactory
+});
+module.exports = __toCommonJS(SecuritizeKYCFactory_exports);
+var import_iSecuritizeDegenNFT = require("../../../abi/310/iSecuritizeDegenNFT.js");
+var import_iSecuritizeKYCFactory = require("../../../abi/310/iSecuritizeKYCFactory.js");
+var import_base = require("../../base/index.js");
+var import__ = require("../../index.js");
+const abi = import_iSecuritizeKYCFactory.iSecuritizeKYCFactoryAbi;
+class SecuritizeKYCFactory extends import_base.BaseContract {
+  investorCache;
+  #degenNFT;
+  constructor(options, address) {
+    super(options, {
+      addr: address,
+      name: "SecuritizeKYCFactory",
+      abi
+    });
+  }
+  async precomputeWalletAddress(creditManager, investor) {
+    return this.contract.read.precomputeWalletAddress([
+      creditManager,
+      investor
+    ]);
+  }
+  async getWallet(creditAccount) {
+    return this.contract.read.getWallet([creditAccount]);
+  }
+  /**
+   * Returns the investor address for a credit account.
+   * @param creditAccount - Credit account address
+   * @param fromCache - If true, use and update an in-memory cache (creditAccount -> investor). On cache miss, loads from contract and stores the result for future calls.
+   */
+  async getInvestor(creditAccount, fromCache) {
+    if (fromCache && this.investorCache?.has(creditAccount)) {
+      return this.investorCache.get(creditAccount);
+    }
+    const investor = await this.contract.read.getInvestor([creditAccount]);
+    if (fromCache) {
+      if (!this.investorCache) {
+        this.investorCache = new import__.AddressMap();
+      }
+      this.investorCache.upsert(creditAccount, investor);
+    }
+    return investor;
+  }
+  async getDSTokens() {
+    const degenNFT = await this.getDegenNFT();
+    const tokens = await this.client.readContract({
+      address: degenNFT,
+      abi: import_iSecuritizeDegenNFT.iSecuritizeDegenNFTAbi,
+      functionName: "getDSTokens"
+    });
+    return [...tokens];
+  }
+  multicall(creditAccount, calls, tokensToRegister) {
+    return this.createRawTx({
+      functionName: "multicall",
+      args: [creditAccount, calls, tokensToRegister]
+    });
+  }
+  openCreditAccount(creditManager, calls, tokensToRegister) {
+    return this.createRawTx({
+      functionName: "openCreditAccount",
+      args: [creditManager, calls, tokensToRegister]
+    });
+  }
+  async getDegenNFT() {
+    if (!this.#degenNFT) {
+      this.#degenNFT = await this.contract.read.getDegenNFT();
+    }
+    return this.#degenNFT;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SecuritizeKYCFactory
+});

package/dist/cjs/sdk/market/pool/index.js

@@ -18,11 +18,15 @@ module.exports = __toCommonJS(pool_exports);
 __reExport(pool_exports, require("./GaugeContract.js"), module.exports);
 __reExport(pool_exports, require("./LinearInterestRateModelContract.js"), module.exports);
 __reExport(pool_exports, require("./PoolSuite.js"), module.exports);
+__reExport(pool_exports, require("./PoolV310Contract.js"), module.exports);
+__reExport(pool_exports, require("./SecuritizeKYCFactory.js"), module.exports);
 __reExport(pool_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./GaugeContract.js"),
   ...require("./LinearInterestRateModelContract.js"),
   ...require("./PoolSuite.js"),
+  ...require("./PoolV310Contract.js"),
+  ...require("./SecuritizeKYCFactory.js"),
   ...require("./types.js")
 });

package/dist/cjs/sdk/pools/PoolService.js

@@ -0,0 +1,391 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PoolService_exports = {};
+__export(PoolService_exports, {
+  PoolService: () => PoolService
+});
+module.exports = __toCommonJS(PoolService_exports);
+var import_generated = require("../../abi/310/generated.js");
+var import_iERC20 = require("../../abi/iERC20.js");
+var import_iERC20ZapperDeposits = require("../../abi/iERC20ZapperDeposits.js");
+var import_iETHZapperDeposits = require("../../abi/iETHZapperDeposits.js");
+var import_iZapper = require("../../abi/iZapper.js");
+var import_base = require("../base/index.js");
+var import__ = require("../index.js");
+var import_utils = require("../utils/index.js");
+const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+const POOL_TOKENS_TO_MIGRATE = new import_utils.AddressMap([
+  // v2 diesels
+  ["0x6CFaF95457d7688022FC53e7AbE052ef8DFBbdBA", "dDAI"],
+  ["0xc411dB5f5Eb3f7d552F9B8454B2D74097ccdE6E3", "dUSDC"],
+  ["0xe753260F1955e8678DCeA8887759e07aa57E8c54", "dWBTC"],
+  ["0xF21fc650C1B34eb0FDE786D52d23dA99Db3D6278", "dWETH"],
+  ["0x2158034dB06f06dcB9A786D2F1F8c38781bA779d", "dwstETH"],
+  ["0x8A1112AFef7F4FC7c066a77AABBc01b3Fff31D47", "dFRAX"]
+]);
+class PoolService extends import_base.SDKConstruct {
+  getDepositTokensIn(pool) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#depositTokensIn(pool, false);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [underlying.asset];
+      }
+    }
+    return this.#depositTokensIn(pool, true);
+  }
+  getDepositTokensOut(pool, tokenIn) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#depositTokensOut(pool, tokenIn, false);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [];
+      }
+    }
+    return this.#depositTokensOut(pool, tokenIn, true);
+  }
+  getDepositMetadata(pool, tokenIn, tokenOut) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT: {
+          return this.#depositMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
+        }
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return {
+            zapper: void 0,
+            approveTarget: underlying.liquidityProvider,
+            permissible: false,
+            type: "kyc-on-demand"
+          };
+      }
+    }
+    return this.#depositMetadata("classic", pool, tokenIn, tokenOut, true);
+  }
+  addLiquidity(props) {
+    const { collateral, meta, permit, referralCode, pool, wallet } = props;
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      if (underlying.contractType === import_base.KYC_UNDERLYING_ON_DEMAND) {
+        return void 0;
+      }
+    }
+    const { zapper } = meta;
+    if (zapper && (0, import__.hexEq)(zapper.tokenIn.addr, NATIVE_ADDRESS)) {
+      return {
+        target: zapper.baseParams.addr,
+        abi: import_iETHZapperDeposits.iethZapperDepositsAbi,
+        functionName: "depositWithReferral",
+        args: [wallet, referralCode],
+        value: collateral.balance
+      };
+    } else if (zapper) {
+      return permit ? {
+        target: zapper.baseParams.addr,
+        abi: import_iERC20ZapperDeposits.ierc20ZapperDepositsAbi,
+        functionName: "depositWithReferralAndPermit",
+        args: [
+          collateral.balance,
+          wallet,
+          referralCode,
+          permit.deadline,
+          permit.v,
+          permit.r,
+          permit.s
+        ]
+      } : {
+        target: zapper.baseParams.addr,
+        abi: import_iERC20ZapperDeposits.ierc20ZapperDepositsAbi,
+        functionName: "depositWithReferral",
+        args: [collateral.balance, wallet, referralCode]
+      };
+    } else {
+      return {
+        target: pool,
+        abi: import_generated.iPoolV310Abi,
+        functionName: "depositWithReferral",
+        args: [collateral.balance, wallet, referralCode]
+      };
+    }
+  }
+  getWithdrawalTokensIn(pool) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#withdrawalTokensIn(pool, false);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [];
+      }
+    }
+    return this.#withdrawalTokensIn(pool, true);
+  }
+  getWithdrawalTokensOut(pool, tokenIn) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT:
+          return this.#withdrawalTokensOut(pool, tokenIn, false);
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return [underlying.asset];
+      }
+    }
+    return this.#withdrawalTokensOut(pool, tokenIn, true);
+  }
+  removeLiquidity(props) {
+    const { pool, amount, meta, wallet, permit } = props;
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      if (underlying.contractType === import_base.KYC_UNDERLYING_ON_DEMAND) {
+        return {
+          abi: import_iERC20.ierc20Abi,
+          functionName: "approve",
+          args: [underlying.liquidityProvider, 0n],
+          target: underlying.asset
+        };
+      }
+    }
+    if (meta.zapper) {
+      return permit ? {
+        target: meta.zapper.baseParams.addr,
+        abi: import_iZapper.iZapperAbi,
+        functionName: "redeemWithPermit",
+        args: [
+          amount,
+          wallet,
+          permit.deadline,
+          permit.v,
+          permit.r,
+          permit.s
+        ]
+      } : {
+        target: meta.zapper.baseParams.addr,
+        abi: import_iZapper.iZapperAbi,
+        functionName: "redeem",
+        args: [amount, wallet]
+      };
+    }
+    return {
+      target: pool,
+      abi: import_generated.iPoolV310Abi,
+      functionName: "redeem",
+      args: [amount, wallet, wallet]
+    };
+  }
+  getWithdrawalMetadata(pool, tokenIn, tokenOut) {
+    const underlying = this.#describeUnderlying(pool);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      switch (underlying.contractType) {
+        case import_base.KYC_UNDERLYING_DEFAULT: {
+          return this.#withdrawalMetadata(
+            "kyc-default",
+            pool,
+            tokenIn,
+            tokenOut,
+            false
+          );
+        }
+        case import_base.KYC_UNDERLYING_ON_DEMAND:
+          return {
+            zapper: void 0,
+            approveTarget: void 0,
+            permissible: false,
+            type: "kyc-on-demand"
+          };
+      }
+    }
+    return this.#withdrawalMetadata("classic", pool, tokenIn, tokenOut, true);
+  }
+  /**
+   * Filter out v2 diesel tokens (can come from migration v2 -> v3 zappers)
+   * Also omits "migration" zappers (v3 -> v3.1) since they are treated in a different way
+   */
+  #getDepositZappers(poolAddr) {
+    const zappers = this.sdk.marketRegister.poolZappers(poolAddr);
+    return zappers.filter(
+      (z) => z.type !== "migration" && !POOL_TOKENS_TO_MIGRATE.has(z.tokenIn.addr)
+    );
+  }
+  #depositTokensIn(poolAddr, allowDirectDeposit) {
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const result = new import__.AddressSet();
+    if (allowDirectDeposit) {
+      result.add(pool.underlying);
+    }
+    const zappers = this.#getDepositZappers(poolAddr);
+    for (const z of zappers) {
+      if ((0, import__.hexEq)(z.tokenOut.addr, poolAddr)) {
+        result.add(z.tokenIn.addr);
+      }
+    }
+    if (result.size === 0) {
+      throw new Error(
+        `No tokensIn found for pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return result.asArray();
+  }
+  #withdrawalTokensIn(poolAddr, allowDirectDeposit) {
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const result = new import__.AddressSet();
+    if (allowDirectDeposit && pool) {
+      result.add(poolAddr);
+    }
+    const zappers = this.#getDepositZappers(poolAddr);
+    for (const z of zappers) {
+      result.add(z.tokenOut.addr);
+    }
+    if (result.size === 0) {
+      throw new Error(
+        `No tokensIn found for pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return result.asArray();
+  }
+  #depositTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
+    const result = new import__.AddressSet();
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const zappers = this.#getDepositZappers(poolAddr);
+    for (const z of zappers) {
+      if ((0, import__.hexEq)(z.tokenIn.addr, tokenIn)) {
+        result.add(z.tokenOut.addr);
+      }
+    }
+    if (allowDirectDeposit && (0, import__.hexEq)(tokenIn, pool.underlying)) {
+      result.add(poolAddr);
+    }
+    if (result.size === 0) {
+      throw new Error(
+        `No tokensOut found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    const r = result.asArray();
+    return r;
+  }
+  #withdrawalTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
+    const result = new import__.AddressSet();
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const zappers = this.#getDepositZappers(poolAddr);
+    for (const z of zappers) {
+      if ((0, import__.hexEq)(z.tokenOut.addr, tokenIn)) {
+        result.add(z.tokenIn.addr);
+      }
+    }
+    if (allowDirectDeposit && (0, import__.hexEq)(tokenIn, poolAddr)) {
+      result.add(pool.underlying);
+    }
+    if (result.size === 0) {
+      throw new Error(
+        `No tokensOut found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    const r = result.asArray();
+    return r;
+  }
+  /**
+   * Filter out v2 diesel tokens (can come from migration v2 -> v3 zappers)
+   * Also omits "migration" zappers (v3 -> v3.1) since they are treated in a different way
+   */
+  #getDepositZapper(poolAddr, tokenIn, tokenOut) {
+    const zappers = this.sdk.marketRegister.getZapper(poolAddr, tokenIn, tokenOut)?.filter(
+      (z) => z.type !== "migration" && !POOL_TOKENS_TO_MIGRATE.has(z.tokenIn.addr)
+    );
+    if (zappers && zappers.length > 1) {
+      throw new Error(
+        `Multiple zappers found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} and tokenOut ${this.labelAddress(
+          tokenOut
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return zappers?.[0];
+  }
+  #depositMetadata(type, poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
+    if (!tokenOut) {
+      throw new Error("tokenOut is required for classic pool deposit");
+    }
+    const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+    const zapper = this.#getDepositZapper(poolAddr, tokenIn, tokenOut);
+    if (!zapper && !allowDirectDeposit) {
+      throw new Error(
+        `No zapper found for tokenIn ${this.labelAddress(
+          tokenIn
+        )} and tokenOut ${this.labelAddress(
+          tokenOut
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return {
+      zapper,
+      // zapper or pool itself
+      approveTarget: zapper?.baseParams.addr ?? pool.pool.address,
+      // TODO: instead of permissible, return permitType зависимости от tokenIn
+      // "none" | "eip2612" | "dai_like";
+      permissible: !!zapper && !(0, import__.hexEq)(tokenIn, NATIVE_ADDRESS),
+      type
+    };
+  }
+  #withdrawalMetadata(type, poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
+    if (!tokenOut) {
+      throw new Error("tokenOut is required for classic pool deposit");
+    }
+    const zapper = this.#getDepositZapper(poolAddr, tokenOut, tokenIn);
+    if (!zapper && !allowDirectDeposit) {
+      throw new Error(
+        `No zapper found for tokenIn ${this.labelAddress(
+          tokenOut
+        )} and tokenOut ${this.labelAddress(
+          tokenIn
+        )} on pool ${this.labelAddress(poolAddr)}`
+      );
+    }
+    return {
+      zapper,
+      // zapper or pool itself
+      approveTarget: zapper?.baseParams.addr,
+      // TODO: instead of permissible, return permitType зависимости от tokenIn
+      // "none" | "eip2612" | "dai_like";
+      permissible: !!zapper,
+      type
+    };
+  }
+  #describeUnderlying(pool) {
+    const market = this.sdk.marketRegister.findByPool(pool);
+    return this.sdk.tokensMeta.mustGet(market.underlying);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PoolService
+});

package/dist/cjs/sdk/pools/index.js

@@ -15,12 +15,10 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var pools_exports = {};
 module.exports = __toCommonJS(pools_exports);
-__reExport(pools_exports, require("./AbstractPoolService.js"), module.exports);
-__reExport(pools_exports, require("./createPoolService.js"), module.exports);
+__reExport(pools_exports, require("./PoolService.js"), module.exports);
 __reExport(pools_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./AbstractPoolService.js"),
-  ...require("./createPoolService.js"),
+  ...require("./PoolService.js"),
   ...require("./types.js")
 });

package/dist/cjs/sdk/utils/AddressMap.js

@@ -37,7 +37,7 @@ class AddressMap {
     this.#name = name;
   }
   /**
-   * Adds or updates value, undefined removes value
+   * Adds or overwrites value, undefined removes value
    * @param address
    * @param value
    */

package/dist/cjs/sdk/utils/viem/sendRawTx.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var sendRawTx_exports = {};
 __export(sendRawTx_exports, {
+  estimateRawTxGas: () => estimateRawTxGas,
   sendRawTx: () => sendRawTx
 });
 module.exports = __toCommonJS(sendRawTx_exports);
@@ -36,7 +37,22 @@ async function sendRawTx(client, params) {
     value: BigInt(tx.value)
   });
 }
+async function estimateRawTxGas(client, params) {
+  const { tx, ...rest } = params;
+  return (0, import_utils.getAction)(
+    client,
+    import_actions.estimateGas,
+    "estimateGas"
+  )({
+    ...rest,
+    account: params.account,
+    data: tx.callData,
+    to: tx.to,
+    value: BigInt(tx.value)
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  estimateRawTxGas,
   sendRawTx
 });