@gearbox-protocol/sdk 11.9.0-next.1 → 11.9.0

package/dist/cjs/sdk/market/pricefeeds/updates/RedstoneUpdater.js

@@ -61,6 +61,7 @@ const RedstoneOptions = import_v4.z.object({
   enableLogging: import_v4.z.boolean().optional()
 });
 class RedstoneUpdater extends import_base.SDKConstruct {
+  #logger;
   #cache;
   #historicalTimestampMs;
   #gateways;
@@ -68,6 +69,7 @@ class RedstoneUpdater extends import_base.SDKConstruct {
   #enableLogging;
   constructor(sdk, opts = {}) {
     super(sdk);
+    this.#logger = (0, import_utils.childLogger)("RedstoneUpdater", sdk.logger);
     this.#ignoreMissingFeeds = opts.ignoreMissingFeeds;
     this.#enableLogging = opts.enableLogging;
     this.#gateways = opts.gateways?.length ? opts.gateways : void 0;
@@ -75,7 +77,7 @@ class RedstoneUpdater extends import_base.SDKConstruct {
     if (ts) {
       ts = ts === true ? Number(this.sdk.timestamp) * 1e3 : ts;
       this.#historicalTimestampMs = 6e4 * Math.floor(ts / 6e4);
-      this.logger?.debug(
+      this.#logger?.debug(
         `using historical timestamp ${this.#historicalTimestampMs}`
       );
     }
@@ -91,7 +93,7 @@ class RedstoneUpdater extends import_base.SDKConstruct {
     if (feeds.length === 0) {
       return [];
     }
-    this.logger?.debug(
+    this.#logger?.debug(
       `generating update transactions for ${feeds.length} redstone price feeds`
     );
     const groupedFeeds = {};
@@ -148,7 +150,7 @@ class RedstoneUpdater extends import_base.SDKConstruct {
         tsRange = `${tsRange} - ${maxTimestamp} (${maxDelta})`;
       }
     }
-    this.logger?.debug(
+    this.#logger?.debug(
       `generated ${results.length} update transactions for redstone price feeds: ${Array.from(priceFeeds.keys()).join(", ")}${tsRange}`
     );
     return results;
@@ -173,7 +175,7 @@ class RedstoneUpdater extends import_base.SDKConstruct {
     for (const { timestamp, dataFeedId } of result) {
       const delta = Number(this.sdk.timestamp) - timestamp;
       if (delta >= 240 && delta < 255) {
-        this.logger?.warn(
+        this.#logger?.warn(
           `payload for ${dataFeedId} has expired by ${delta} seconds`
         );
         expired = true;
@@ -197,7 +199,7 @@ class RedstoneUpdater extends import_base.SDKConstruct {
    * @returns
    */
   async #getPayloads(dataServiceId, dataFeedsIds, uniqueSignersCount) {
-    this.logger?.debug(
+    this.#logger?.debug(
       `getting redstone payloads for ${dataFeedsIds.size} data feeds in ${dataServiceId} with ${uniqueSignersCount} signers: ${Array.from(dataFeedsIds).join(", ")}`
     );
     const fromCache = [];
@@ -222,7 +224,7 @@ class RedstoneUpdater extends import_base.SDKConstruct {
     for (const resp of fromRedstone) {
       this.#cache.set(resp, dataServiceId, resp.dataFeedId, uniqueSignersCount);
     }
-    this.logger?.debug(
+    this.#logger?.debug(
       `got ${fromRedstone.length} new redstone updates and ${fromCache.length} from cache`
     );
     return [...fromCache, ...fromRedstone];
@@ -241,7 +243,7 @@ class RedstoneUpdater extends import_base.SDKConstruct {
     }
     const dataPackagesIds = Array.from(dataFeedsIds);
     const tsStr = this.#historicalTimestampMs ? ` with historical timestamp ${this.#historicalTimestampMs}` : "";
-    this.logger?.debug(
+    this.#logger?.debug(
       `fetching redstone payloads for ${dataFeedsIds.size} data feeds in ${dataServiceId} with ${uniqueSignersCount} signers: ${dataPackagesIds.join(", ")}${tsStr}`
     );
     const wrapper = new import_evm_connector.DataServiceWrapper({
@@ -270,14 +272,14 @@ class RedstoneUpdater extends import_base.SDKConstruct {
       const signedDataPackages = packagesByDataFeedId[dataFeedId];
       if (!signedDataPackages) {
         if (this.#ignoreMissingFeeds) {
-          this.logger?.warn(`cannot find data packages for ${dataFeedId}`);
+          this.#logger?.warn(`cannot find data packages for ${dataFeedId}`);
           continue;
         }
         throw new Error(`cannot find data packages for ${dataFeedId}`);
       }
       if (signedDataPackages.length !== uniqueSignersCount) {
         if (this.#ignoreMissingFeeds) {
-          this.logger?.warn(
+          this.#logger?.warn(
             `got ${signedDataPackages.length} data packages for ${dataFeedId}, but expected ${uniqueSignersCount}`
           );
           continue;

package/dist/cjs/sdk/router/AbstractRouterContract.js

@@ -22,6 +22,7 @@ __export(AbstractRouterContract_exports, {
 });
 module.exports = __toCommonJS(AbstractRouterContract_exports);
 var import_base = require("../base/index.js");
+var import_math = require("../constants/math.js");
 var import_utils = require("../utils/index.js");
 var import_internal = require("../utils/internal/index.js");
 var import_helpers = require("./helpers.js");
@@ -29,13 +30,12 @@ class AbstractRouterContract extends import_base.BaseContract {
   hooks = new import_internal.Hooks();
   addHook = this.hooks.addHook.bind(this.hooks);
   removeHook = this.hooks.removeHook.bind(this.hooks);
-  sdk;
-  constructor(sdk, args) {
-    super(sdk, args);
-    this.sdk = sdk;
-  }
-  getExpectedAndLeftover(ca, cm, balances, keepAssets) {
-    const b = balances || this.getDefaultExpectedAndLeftover(ca, keepAssets);
+  getExpectedAndLeftover(ca, cm, options = {}) {
+    const b = options.balances ? options.balances : this.getDefaultExpectedAndLeftover(
+      ca,
+      options.keepAssets,
+      options.debtOnly
+    );
     const { leftoverBalances, expectedBalances, tokensToClaim } = b;
     const expected = new import_utils.AddressMap();
     const leftover = new import_utils.AddressMap();
@@ -53,15 +53,22 @@ class AbstractRouterContract extends import_base.BaseContract {
       tokensToClaim
     };
   }
-  getDefaultExpectedAndLeftover(ca, keepAssets) {
+  getDefaultExpectedAndLeftover(ca, keepAssets, debtOnly) {
     const expectedBalances = new import_utils.AddressMap();
     const leftoverBalances = new import_utils.AddressMap();
-    const keepAssetsSet = new Set(keepAssets?.map((a) => a.toLowerCase()));
-    for (const { token: t, balance, mask } of ca.tokens) {
-      const token = t;
+    const keepAssetsSet = new import_utils.AddressSet(keepAssets);
+    if (debtOnly) {
+      const result = this.getLeftoversAfterBuyingDebt(ca, keepAssetsSet);
+      if (result) {
+        return result;
+      } else {
+        this.logger?.warn("no token found to cover debt");
+      }
+    }
+    for (const { token, balance, mask } of ca.tokens) {
       const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
       expectedBalances.upsert(token, { token, balance });
-      if (keepAssetsSet.has(token.toLowerCase()) || !isEnabled || (0, import_utils.isDust)({
+      if (keepAssetsSet.has(token) || !isEnabled || (0, import_utils.isDust)({
         sdk: this.sdk,
         token,
         balance,
@@ -79,6 +86,101 @@ class AbstractRouterContract extends import_base.BaseContract {
       tokensToClaim: new import_utils.AddressMap()
     };
   }
+  /**
+   * Tries to sell just enought of most valuable token to cover debt
+   * @param ca
+   * @param keepAssets
+   * @returns
+   */
+  getLeftoversAfterBuyingDebt(ca, keepAssets) {
+    const { priceOracle } = this.sdk.marketRegister.findByCreditManager(
+      ca.creditManager
+    );
+    const expectedBalances = new import_utils.AddressMap();
+    const leftoverBalances = new import_utils.AddressMap();
+    const usdBalances = [];
+    for (const { token, balance, mask } of ca.tokens) {
+      const isEnabled = (mask & ca.enabledTokensMask) !== 0n;
+      expectedBalances.upsert(token, { token, balance });
+      leftoverBalances.upsert(token, {
+        token,
+        balance: (0, import_helpers.limitLeftover)(balance, token) ?? balance
+      });
+      if (isEnabled && !keepAssets.has(token)) {
+        usdBalances.push({
+          token,
+          balance: this.safeConvertToUSD(priceOracle, token, balance)
+        });
+      }
+    }
+    usdBalances.sort((a, b) => {
+      if (a.balance > b.balance) return -1;
+      if (a.balance < b.balance) return 1;
+      return 0;
+    });
+    if (usdBalances.length === 0) {
+      return void 0;
+    }
+    const highestToken = usdBalances[0];
+    const lt = this.sdk.marketRegister.findCreditManager(ca.creditManager).creditManager.liquidationThresholds.mustGet(highestToken.token);
+    const requiredDebtUSD = ca.totalDebtUSD * import_math.PERCENTAGE_FACTOR / BigInt(lt);
+    if (highestToken.balance < requiredDebtUSD) {
+      return void 0;
+    }
+    const tokenAmount = this.safeConvertFromUSD(
+      priceOracle,
+      highestToken.token,
+      requiredDebtUSD
+    );
+    if (tokenAmount === 0n) {
+      return void 0;
+    }
+    let leftoverBalance = leftoverBalances.get(highestToken.token)?.balance ?? 0n;
+    leftoverBalance -= tokenAmount;
+    if (leftoverBalance < 0n) {
+      return void 0;
+    }
+    leftoverBalances.upsert(highestToken.token, {
+      token: highestToken.token,
+      balance: leftoverBalance
+    });
+    const tokenAmountStr = this.sdk.tokensMeta.formatBN(
+      highestToken.token,
+      tokenAmount,
+      { symbol: true }
+    );
+    const totalDebtUSDStr = (0, import_utils.formatBN)(ca.totalDebtUSD, 8);
+    this.logger?.debug(
+      `will sell ${tokenAmountStr} (LT=${lt}) to cover debt of ${totalDebtUSDStr} USD`
+    );
+    return {
+      expectedBalances,
+      leftoverBalances,
+      tokensToClaim: new import_utils.AddressMap()
+    };
+  }
+  safeConvertToUSD(priceOracle, token, balance) {
+    try {
+      return priceOracle.convertToUSD(token, balance);
+    } catch {
+      try {
+        return priceOracle.convertToUSD(token, balance, true);
+      } catch {
+        return 0n;
+      }
+    }
+  }
+  safeConvertFromUSD(priceOracle, token, balance) {
+    try {
+      return priceOracle.convertFromUSD(token, balance);
+    } catch {
+      try {
+        return priceOracle.convertFromUSD(token, balance, true);
+      } catch {
+        return 0n;
+      }
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/router/RouterV300Contract.js

@@ -194,22 +194,22 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     creditAccount: ca,
     creditManager: cm,
     slippage,
-    balances
+    balances,
+    debtOnly
   }) {
     const {
       pathOptions,
       expected,
       leftover: leftoverUnsafe,
       connectors
-    } = this.getFindClosePathInput(
-      ca,
-      cm,
-      balances ? {
+    } = this.getFindClosePathInput(ca, cm, {
+      balances: balances ? {
         expectedBalances: (0, import_helpers.assetsMap)(balances.expectedBalances),
         leftoverBalances: (0, import_helpers.assetsMap)(balances.leftoverBalances),
         tokensToClaim: (0, import_helpers.assetsMap)(balances.tokensToClaim || [])
-      } : void 0
-    );
+      } : void 0,
+      debtOnly
+    });
     const leftover = leftoverUnsafe.map((a) => ({
       ...a,
       balance: (0, import_helpers.limitLeftover)(a.balance, a.token) ?? 0n
@@ -269,12 +269,11 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
   /**
    * Implements {@link IRouterContract.getFindClosePathInput}
    */
-  getFindClosePathInput(ca, cm, balances, keepAssets) {
+  getFindClosePathInput(ca, cm, options) {
     const { expectedBalances, leftoverBalances } = this.getExpectedAndLeftover(
       ca,
       cm,
-      balances,
-      keepAssets
+      options
     );
     const leftover = leftoverBalances.values().map((a) => ({
       ...a,

package/dist/cjs/sdk/router/RouterV310Contract.js

@@ -182,18 +182,18 @@ class RouterV310Contract extends import_AbstractRouterContract.AbstractRouterCon
       creditManager: cm,
       slippage,
       balances,
-      keepAssets
+      keepAssets,
+      debtOnly
     } = props;
-    const { expectedBalances, leftoverBalances, tokensToClaim } = this.getExpectedAndLeftover(
-      ca,
-      cm,
-      balances ? {
+    const { expectedBalances, leftoverBalances, tokensToClaim } = this.getExpectedAndLeftover(ca, cm, {
+      balances: balances ? {
         expectedBalances: (0, import_helpers.assetsMap)(balances.expectedBalances),
         leftoverBalances: (0, import_helpers.assetsMap)(balances.leftoverBalances),
         tokensToClaim: (0, import_helpers.assetsMap)(balances.tokensToClaim || [])
       } : void 0,
-      keepAssets
-    );
+      keepAssets: balances ? void 0 : keepAssets,
+      debtOnly
+    });
     const getNumSplits = this.#numSplitsGetter(cm, expectedBalances.values());
     const tData = [];
     for (const token of cm.collateralTokens) {
@@ -299,15 +299,15 @@ class RouterV310Contract extends import_AbstractRouterContract.AbstractRouterCon
    * @returns
    */
   #convertToUSDForSort(oracle, token, amount) {
-    const scale = 10n ** BigInt(this.tokensMeta.get(token)?.decimals ?? 0);
+    const scale = 10n ** BigInt(this.sdk.tokensMeta.get(token)?.decimals ?? 0);
     const price = oracle.mainPrices.get(token)?.price || oracle.reservePrices.get(token)?.price || scale;
     return amount * price / scale;
   }
   #debugTokenData(tData) {
     return tData.map((t) => ({
       token: this.labelAddress(t.token),
-      balance: `${this.tokensMeta.formatBN(t.token, t.balance)} (${t.balance})`,
-      leftoverBalance: this.tokensMeta.formatBN(t.token, t.leftoverBalance) + ` (${t.leftoverBalance})`,
+      balance: `${this.sdk.tokensMeta.formatBN(t.token, t.balance)} (${t.balance})`,
+      leftoverBalance: this.sdk.tokensMeta.formatBN(t.token, t.leftoverBalance) + ` (${t.leftoverBalance})`,
       numSplits: t.numSplits,
       claimRewards: t.claimRewards
     }));

package/dist/cjs/sdk/router/createRouter.js

@@ -25,10 +25,6 @@ var import_constants = require("../constants/index.js");
 var import_RouterV300Contract = require("./RouterV300Contract.js");
 var import_RouterV310Contract = require("./RouterV310Contract.js");
 function createRouter(sdk, address, version) {
-  const contract = sdk.getContract(address);
-  if (contract) {
-    return contract;
-  }
   if ((0, import_constants.isV300)(version)) {
     return new import_RouterV300Contract.RouterV300Contract(sdk, address, version);
   }

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

@@ -17,7 +17,6 @@ var utils_exports = {};
 module.exports = __toCommonJS(utils_exports);
 __reExport(utils_exports, require("./AddressMap.js"), module.exports);
 __reExport(utils_exports, require("./AddressSet.js"), module.exports);
-__reExport(utils_exports, require("./abi-decode.js"), module.exports);
 __reExport(utils_exports, require("./bytes32ToString.js"), module.exports);
 __reExport(utils_exports, require("./childLogger.js"), module.exports);
 __reExport(utils_exports, require("./createRawTx.js"), module.exports);
@@ -36,7 +35,6 @@ __reExport(utils_exports, require("./zod.js"), module.exports);
 0 && (module.exports = {
   ...require("./AddressMap.js"),
   ...require("./AddressSet.js"),
-  ...require("./abi-decode.js"),
   ...require("./bytes32ToString.js"),
   ...require("./childLogger.js"),
   ...require("./createRawTx.js"),

package/dist/esm/dev/create2.js

@@ -5,10 +5,10 @@ import {
   stringToHex
 } from "viem";
 import { getCode, sendTransaction } from "viem/actions";
-import { Construct } from "../sdk/index.js";
+import { SDKConstruct } from "../sdk/index.js";
 const PUBLIC_CREATE2_FACTORY = "0x4e59b44847b379578588920ca78fbf26c0b4956c";
 const DEFAULT_CREATE2_SALT = "GEARBOX";
-class Create2Deployer extends Construct {
+class Create2Deployer extends SDKConstruct {
   #walletClient;
   #logger;
   constructor(sdk, walletClient) {

package/dist/esm/dev/mint/AbstractMinter.js

@@ -1,14 +1,18 @@
 import { parseEther } from "viem";
 import { ierc20Abi } from "../../abi/iERC20.js";
-import { SDKConstruct } from "../../sdk/index.js";
+import {
+  SDKConstruct
+} from "../../sdk/index.js";
 import { iOwnableAbi } from "../abi.js";
 class AbstractMinter extends SDKConstruct {
   anvil;
+  logger;
   name;
-  constructor(sdk, anvil) {
+  constructor(sdk, anvil, name = "Minter") {
     super(sdk);
     this.anvil = anvil;
-    this.name = this.constructor.name;
+    this.name = name;
+    this.logger = sdk.logger?.child?.({ name }) ?? sdk.logger;
   }
   async tryMint(token, dest, amount) {
     const amnt = this.fmt(token, amount);

package/dist/esm/dev/mint/DealMinter.js

@@ -1,5 +1,8 @@
 import AbstractMinter from "./AbstractMinter.js";
 class DealMinter extends AbstractMinter {
+  constructor(sdk, anvil) {
+    super(sdk, anvil, "DealMinter");
+  }
   async mint(token, dest, amount) {
     const { deal } = await import("viem-deal").catch(() => ({ deal: null }));
     if (!deal) {

package/dist/esm/dev/mint/DirectMinter.js

@@ -1,6 +1,9 @@
 import { parseAbi } from "viem";
 import AbstractMinter from "./AbstractMinter.js";
 class DirectMinter extends AbstractMinter {
+  constructor(sdk, anvil) {
+    super(sdk, anvil, "DirectMinter");
+  }
   async mint(token, dest, amount) {
     const owner = await this.getOwner(token);
     const stopImpersonating = await this.impersonateWithBalance(owner);

package/dist/esm/dev/mint/FallbackMinter.js

@@ -2,7 +2,7 @@ import AbstractMinter from "./AbstractMinter.js";
 class FallbackMinter extends AbstractMinter {
   #minters;
   constructor(sdk, anvil, minters) {
-    super(sdk, anvil);
+    super(sdk, anvil, "FallbackMinter");
     this.#minters = minters;
   }
   async mint(token, dest, amount) {

package/dist/esm/dev/mint/TransferMinter.js

@@ -2,6 +2,9 @@ import { parseAbi } from "viem";
 import { ierc20Abi } from "../../abi/iERC20.js";
 import AbstractMinter from "./AbstractMinter.js";
 class TransferMinter extends AbstractMinter {
+  constructor(sdk, anvil) {
+    super(sdk, anvil, "TransferMinter");
+  }
   async mint(token, dest, amount) {
     const owner = await this.getOwner(token);
     const stopImpersonating = await this.impersonateWithBalance(owner);

package/dist/esm/permissionless/bindings/address-provider.js

@@ -1,10 +1,10 @@
-import {
-  stringToHex
-} from "viem";
-import { AddressProviderV310Contract } from "../../sdk/index.js";
-class AddressProviderContract extends AddressProviderV310Contract {
-  constructor(addr, client) {
-    super({ client }, addr);
+import { stringToHex } from "viem";
+import { iAddressProviderV310Abi } from "../../abi/310/generated.js";
+import { BaseContract } from "./base-contract.js";
+const abi = iAddressProviderV310Abi;
+class AddressProviderContract extends BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "AddressProvider");
   }
   async getAddressOrRevert(key, version = 0n) {
     return await this.contract.read.getAddressOrRevert([

package/dist/esm/permissionless/bindings/base-contract.js

@@ -0,0 +1,151 @@
+import {
+  getContract
+} from "viem";
+import { createRawTx } from "../../sdk/utils/index.js";
+import { decodeFunctionWithNamedArgs } from "../utils/abi-decoder.js";
+class BaseContract {
+  abi;
+  address;
+  name;
+  static register = {};
+  contract;
+  client;
+  constructor(abi, address, client, name) {
+    this.abi = abi;
+    this.client = client;
+    this.address = address.toLowerCase();
+    this.name = name;
+    this.contract = getContract({
+      address,
+      abi,
+      client
+    });
+    BaseContract.register[this.address] = this;
+  }
+  static parseCall(call) {
+    const parsedCall = BaseContract.parse(call.target, call.callData);
+    return {
+      ...parsedCall,
+      chainId: call.chainId
+    };
+  }
+  static parse(address, calldata) {
+    const contract = BaseContract.register[address.toLowerCase()];
+    if (contract) {
+      return contract.parseFunctionData(calldata);
+    } else {
+      return {
+        chainId: 0,
+        target: address,
+        label: "Unknown contract",
+        functionName: `Unknown function: ${calldata}`,
+        args: {}
+      };
+    }
+  }
+  parseFunctionData(calldata) {
+    const decodedWithNames = decodeFunctionWithNamedArgs(this.abi, calldata);
+    if (!decodedWithNames) {
+      return {
+        chainId: 0,
+        target: this.address,
+        label: this.name,
+        functionName: `Unknown function: ${calldata}`,
+        args: {}
+      };
+    }
+    const specParsed = this.parseFunctionParams(
+      decodedWithNames.originalDecoded
+    );
+    if (specParsed) {
+      return specParsed;
+    }
+    return this.wrapParseCall(
+      decodedWithNames.originalDecoded,
+      decodedWithNames.args
+    );
+  }
+  wrapParseCall(params, parsedParams) {
+    return {
+      chainId: 0,
+      target: this.address,
+      label: this.name,
+      functionName: params.functionName,
+      args: parsedParams
+    };
+  }
+  parseFunctionParams(_params) {
+    return void 0;
+  }
+  createRawTx(parameters) {
+    const { description: argsDescription } = parameters;
+    const tx = createRawTx(
+      this.address,
+      {
+        abi: this.abi,
+        ...parameters
+      },
+      argsDescription
+    );
+    tx.description = parameters.description || argsDescription || this.stringifyParsedCall(this.parseFunctionData(tx.callData));
+    return tx;
+  }
+  stringifyParsedCall(parsedCall) {
+    const argsStr = Object.entries(parsedCall.args).map(([key, value]) => `${key}: ${value}`).join(", ");
+    return `${parsedCall.label}.${parsedCall.functionName}(${argsStr})`;
+  }
+  async getEvents(eventName, fromBlock, toBlock, args, chunkSize) {
+    if (chunkSize) {
+      const chunkSizeBigint = BigInt(chunkSize);
+      const getEventPromises = [];
+      for (let i = fromBlock; i < toBlock; i += chunkSizeBigint) {
+        getEventPromises.push(
+          this.client.getContractEvents({
+            address: this.address,
+            fromBlock: i,
+            toBlock: i + chunkSizeBigint,
+            abi: this.abi,
+            eventName,
+            args
+          })
+        );
+      }
+      const events = (await Promise.all(getEventPromises)).flat();
+      return events;
+    }
+    try {
+      const events = await this.client.getContractEvents({
+        address: this.address,
+        fromBlock,
+        toBlock,
+        abi: this.abi,
+        eventName,
+        args
+      });
+      return events;
+    } catch (e) {
+      const blockRangeErrors = [
+        "query exceeds max block",
+        "range is too large",
+        "eth_getLogs is limited to",
+        "Unable to perform request",
+        "Block range limit exceeded"
+      ];
+      if (e instanceof Error && blockRangeErrors.some((errorText) => e.message.includes(errorText))) {
+        const middle = (fromBlock + toBlock) / 2n;
+        const [firstHalfEvents, secondHalfEvents] = await Promise.all([
+          this.getEvents(eventName, fromBlock, middle, args),
+          this.getEvents(eventName, middle + 1n, toBlock, args)
+        ]);
+        return [...firstHalfEvents, ...secondHalfEvents];
+      }
+      throw e;
+    }
+  }
+  getContract() {
+    return this.contract;
+  }
+}
+export {
+  BaseContract
+};