envio 3.15.0 → 3.16.0-subgraph

package/src/ChainFetching.res.mjs

@@ -1,14 +1,18 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Logger from "./Logger.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as RunScope from "./RunScope.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
+import * as FetchState from "./FetchState.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as ChainMetadata from "./ChainMetadata.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SourceManager from "./sources/SourceManager.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as HandlerRuntime from "./HandlerRuntime.res.mjs";
@@ -20,32 +24,74 @@ function hasContractRegister(item) {
   if (item.kind === 0) {
     return item.onEventRegistration.contractRegister !== undefined;
   } else {
-    return false;
+    return item.onBlockRegistration.contractRegister !== undefined;
   }
 }
 
 function invokeContractRegister(runtime, item) {
-  let match = item.onEventRegistration;
-  let contractRegister = match.contractRegister;
-  let contractRegister$1 = contractRegister !== undefined ? contractRegister : Stdlib_JsError.throwWithMessage("Contract register is not set for event " + match.eventConfig.name);
-  return contractRegister$1({
-    event: Ecosystem.getItemEvent(item, HandlerRuntime.ecosystem(runtime)),
-    context: runtime.contractRegisterContext
-  });
+  if (item.kind === 0) {
+    let onEventRegistration = item.onEventRegistration;
+    let contractRegister = onEventRegistration.contractRegister;
+    let contractRegister$1 = contractRegister !== undefined ? contractRegister : Stdlib_JsError.throwWithMessage("Contract register is not set for event " + onEventRegistration.eventConfig.name);
+    return contractRegister$1({
+      event: Ecosystem.getItemEvent(item, HandlerRuntime.ecosystem(runtime)),
+      context: runtime.contractRegisterContext
+    });
+  }
+  let block = item.block;
+  let blockNumber = item.blockNumber;
+  let onBlockRegistration = item.onBlockRegistration;
+  let contractRegister$2 = onBlockRegistration.contractRegister;
+  let contractRegister$3 = contractRegister$2 !== undefined ? contractRegister$2 : Stdlib_JsError.throwWithMessage("Contract register is not set for block handler " + onBlockRegistration.name);
+  let ecosystem = HandlerRuntime.ecosystem(runtime);
+  let context = runtime.contractRegisterContext;
+  let match = ecosystem.name;
+  let tmp;
+  let exit = 0;
+  switch (match) {
+    case "evm" :
+    case "fuel" :
+      exit = 1;
+      break;
+    case "svm" :
+      tmp = {
+        slot: blockNumber,
+        block: block,
+        context: context
+      };
+      break;
+  }
+  if (exit === 1) {
+    tmp = {
+      block: Primitive_option.some(Stdlib_Option.getOr(block, Ecosystem.makeKeyOnlyBlock(blockNumber, ecosystem))),
+      context: context
+    };
+  }
+  return contractRegister$3(tmp);
 }
 
 async function runContractRegistersOrThrow(itemsWithContractRegister, runtime, chainState) {
-  await ChainState.materializePageItems(itemsWithContractRegister, ChainState.transactionStore(chainState), ChainState.blockStore(chainState), ChainState.shouldChecksum(chainState));
+  await ChainState.materializePageItems(Env.subgraphMode.contents ? itemsWithContractRegister.filter(item => item.kind === 0) : itemsWithContractRegister, ChainState.transactionStore(chainState), ChainState.blockStore(chainState), ChainState.shouldChecksum(chainState));
   let registrations = [];
   let chainLogger = ChainState.logger(chainState);
   let ecosystem = HandlerRuntime.ecosystem(runtime);
+  let isSubgraph = Env.subgraphMode.contents;
   await Promise.all(itemsWithContractRegister.map(async item => {
+    let tmp;
+    if (isSubgraph) {
+      let tmp$1;
+      tmp$1 = item.kind === 0 ? FetchState.creationRoundOfRegistration(ChainState.fetchState(chainState), item) : 1;
+      tmp = tmp$1;
+    } else {
+      tmp = undefined;
+    }
     let run = {
       item: item,
       isResolved: false,
       chainLogger: chainLogger,
       ecosystem: ecosystem,
-      registrations: registrations
+      registrations: registrations,
+      creationRound: tmp
     };
     let scope = {
       TAG: "ContractRegister",
@@ -57,16 +103,208 @@ async function runContractRegistersOrThrow(itemsWithContractRegister, runtime, c
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       RunScope.resolve(scope);
-      return ErrorHandling.mkLogAndRaise(RunScope.contractRegisterLogger(run), "Event contractRegister failed, please fix the error to keep the indexer running smoothly", exn);
+      let tmp$2;
+      tmp$2 = item.kind === 0 ? "Event contractRegister failed, please fix the error to keep the indexer running smoothly" : "Block handler contractRegister failed, please fix the error to keep the indexer running smoothly";
+      return ErrorHandling.mkLogAndRaise(RunScope.contractRegisterLogger(run), tmp$2, exn);
     }
     return RunScope.resolve(scope);
   }));
   return registrations;
 }
 
+function mergeRegisterItems(eventItems, blockItems) {
+  let merged = [];
+  let i = 0;
+  let j = 0;
+  while (i < eventItems.length || j < blockItems.length) {
+    let match = eventItems[i];
+    let match$1 = blockItems[j];
+    let takeBlock;
+    if (match !== undefined) {
+      if (match$1 !== undefined) {
+        let eventBlock = match.blockNumber;
+        let blockBlock = match$1.blockNumber;
+        takeBlock = blockBlock < eventBlock || blockBlock === eventBlock && Internal.itemRunsFirst(match$1);
+      } else {
+        takeBlock = false;
+      }
+    } else {
+      takeBlock = true;
+    }
+    if (takeBlock) {
+      merged.push(blockItems[j]);
+      j = j + 1 | 0;
+    } else {
+      merged.push(eventItems[i]);
+      i = i + 1 | 0;
+    }
+  };
+  return merged;
+}
+
+async function runRegisterPassesOrThrow(eventItems, blockItems, runtime, chainState) {
+  let items = mergeRegisterItems(eventItems, blockItems);
+  let registrations = [];
+  let start = 0;
+  while (start < items.length) {
+    let chunk = items.slice(start, start + 2048 | 0);
+    registrations.push(...await runContractRegistersOrThrow(chunk, runtime, chainState));
+    start = start + 2048 | 0;
+  };
+  return registrations;
+}
+
+function sortRegistrations(registrations) {
+  return registrations.toSorted((a, b) => {
+    let order = Primitive_int.compare(a.registrationBlock, b.registrationBlock);
+    if (order !== 0) {
+      return order;
+    } else {
+      return Primitive_int.compare(Stdlib_Option.getOr(a.creationRound, 1), Stdlib_Option.getOr(b.creationRound, 1));
+    }
+  });
+}
+
+async function runResponsePassesOrThrow(eventItems, through, runtime, chainState) {
+  let registrations = [];
+  let eventIdx = 0;
+  let passedThrough;
+  let after = Stdlib_Option.getOr(ChainState.blockRegisterThrough(chainState), through);
+  let isDone = false;
+  while (!isDone) {
+    let match = ChainState.blockRegisterItemsAfter(chainState, after, through, 10000);
+    let match$1 = match !== undefined ? [
+        match[0],
+        match[1]
+      ] : [
+        [],
+        undefined
+      ];
+    let covered = match$1[1];
+    let blockItems = match$1[0];
+    let eventEnd;
+    if (covered !== undefined) {
+      if (covered < through) {
+        let idx = eventIdx;
+        while (idx < eventItems.length && eventItems[idx].blockNumber <= covered) {
+          idx = idx + 1 | 0;
+        };
+        eventEnd = idx;
+      } else {
+        eventEnd = eventItems.length;
+      }
+    } else {
+      eventEnd = eventItems.length;
+    }
+    let startedAt = Date.now();
+    let windowRegistrations = await runRegisterPassesOrThrow(eventItems.slice(eventIdx, eventEnd), blockItems, runtime, chainState);
+    Logger.trace(ChainState.logger(chainState), "Ran register passes with block passes", {
+      after: after,
+      through: covered,
+      blockPasses: blockItems.length,
+      eventPasses: eventEnd - eventIdx | 0,
+      registrations: windowRegistrations.length,
+      ms: Date.now() - startedAt
+    });
+    registrations.push(...windowRegistrations);
+    eventIdx = eventEnd;
+    if (covered !== undefined) {
+      passedThrough = covered;
+      after = covered;
+      isDone = covered >= through && eventIdx >= eventItems.length;
+    } else {
+      isDone = true;
+    }
+  };
+  return [
+    sortRegistrations(registrations),
+    passedThrough
+  ];
+}
+
+let registerCallsPerItem = (() => {
+  const cost = globalThis.__envioSubgraphRegisterCostPerItem
+  const value = cost ? cost() : undefined
+  return value === undefined ? undefined : value
+});
+
+let reportRegisterFrontier = ((chainId, block) => {
+  const report = globalThis.__envioSubgraphRegisterFrontier
+  if (report) report(chainId, block)
+});
+
+function registerChunkLimit() {
+  if (!Env.subgraphMode.contents) {
+    return;
+  }
+  if (Env.subgraphRegisterChunk !== undefined) {
+    if (Env.subgraphRegisterChunk > 0) {
+      return Env.subgraphRegisterChunk;
+    } else {
+      return;
+    }
+  }
+  let cost = registerCallsPerItem();
+  if (cost !== undefined) {
+    if (cost < 0.5) {
+      return;
+    } else {
+      return Primitive_int.max(100, 3000 / cost | 0);
+    }
+  } else {
+    return 100;
+  }
+}
+
+function cutAtRegisterLimit(items, latestFetchedBlock, limit) {
+  let seen = 0;
+  let cutIdx = -1;
+  let idx = 0;
+  while (cutIdx < 0 && idx < items.length) {
+    if (hasContractRegister(items[idx])) {
+      seen = seen + 1 | 0;
+      if (seen >= limit) {
+        cutIdx = idx;
+      }
+    }
+    idx = idx + 1 | 0;
+  };
+  if (cutIdx < 0) {
+    return [
+      items,
+      latestFetchedBlock
+    ];
+  }
+  let cutBlock = items[cutIdx].blockNumber;
+  let last = cutIdx;
+  while ((last + 1 | 0) < items.length && items[last + 1 | 0].blockNumber <= cutBlock) {
+    last = last + 1 | 0;
+  };
+  if ((last + 1 | 0) >= items.length && cutBlock >= latestFetchedBlock) {
+    return [
+      items,
+      latestFetchedBlock
+    ];
+  } else {
+    return [
+      items.slice(0, last + 1 | 0),
+      cutBlock
+    ];
+  }
+}
+
 function applyQueryResponse(state, chainId, newItems, newRegistrations, knownHeight, latestFetchedBlock, query) {
   let chainState = IndexerState.getChainState(state, chainId);
   ChainState.handleQueryResult(chainState, query, newItems, newRegistrations, latestFetchedBlock, knownHeight);
+  if (Env.subgraphMode.contents) {
+    let fetchState = ChainState.fetchState(chainState);
+    let frontier = FetchState.OptimizedPartitions.getLatestFullyFetchedBlock(fetchState.optimizedPartitions);
+    if (frontier !== undefined) {
+      let through = fetchState.blockRegisterThrough;
+      let frontier$1 = through !== undefined ? Primitive_int.min(frontier, through) : frontier;
+      reportRegisterFrontier(chainId, frontier$1);
+    }
+  }
   if (!IndexerState.exitAfterFirstEventBlock(state)) {
     return;
   }
@@ -89,8 +327,15 @@ async function onQueryResponse(state, param, runtime, stateId, scheduleFetch, sc
   let transactionStore = response.transactionStore;
   let parsedQueueItems = response.parsedQueueItems;
   let knownHeight = response.knownHeight;
-  ChainState.recordBlockRangeFetch(chainState, stats["total time elapsed (s)"], Stdlib_Option.getOr(stats["parsing time (s)"], 0), parsedQueueItems.length, (latestFetchedBlockNumber - query.fromBlock | 0) + 1 | 0);
-  let numContractRegisterEvents = Stdlib_Array.reduce(parsedQueueItems, 0, (count, item) => {
+  let limit = registerChunkLimit();
+  let match = limit !== undefined ? cutAtRegisterLimit(parsedQueueItems, latestFetchedBlockNumber, limit) : [
+      parsedQueueItems,
+      latestFetchedBlockNumber
+    ];
+  let latestFetchedBlockNumber$1 = match[1];
+  let parsedQueueItems$1 = match[0];
+  ChainState.recordBlockRangeFetch(chainState, stats["total time elapsed (s)"], Stdlib_Option.getOr(stats["parsing time (s)"], 0), parsedQueueItems$1.length, (latestFetchedBlockNumber$1 - query.fromBlock | 0) + 1 | 0);
+  let numContractRegisterEvents = Stdlib_Array.reduce(parsedQueueItems$1, 0, (count, item) => {
     if (hasContractRegister(item)) {
       return count + 1 | 0;
     } else {
@@ -101,15 +346,15 @@ async function onQueryResponse(state, param, runtime, stateId, scheduleFetch, sc
     Logger.trace(ChainState.logger(chainState), "Finished querying", {
       partitionId: query.partitionId,
       fromBlock: query.fromBlock,
-      toBlock: latestFetchedBlockNumber,
-      numEvents: parsedQueueItems.length
+      toBlock: latestFetchedBlockNumber$1,
+      numEvents: parsedQueueItems$1.length
     });
   } else {
     Logger.trace(ChainState.logger(chainState), "Finished querying", {
       partitionId: query.partitionId,
       fromBlock: query.fromBlock,
-      toBlock: latestFetchedBlockNumber,
-      numEvents: parsedQueueItems.length,
+      toBlock: latestFetchedBlockNumber$1,
+      numEvents: parsedQueueItems$1.length,
       numContractRegisterEvents: numContractRegisterEvents
     });
   }
@@ -118,22 +363,22 @@ async function onQueryResponse(state, param, runtime, stateId, scheduleFetch, sc
   if (typeof reorgResult !== "object") {
     rollbackWithReorgDetectedBlockNumber = undefined;
   } else {
-    let match = reorgResult._0;
-    let scannedBlock = match.scannedBlock;
+    let match$1 = reorgResult._0;
+    let scannedBlock = match$1.scannedBlock;
     Logger.info(ChainState.logger(chainState), `Blockchain reorg detected. ` + (
       ChainState.shouldRollbackOnReorg(chainState) ? "Initiating indexer rollback" : "NOT initiating indexer rollback due to configuration"
     ) + `.`, {
       blockNumber: scannedBlock.blockNumber,
       indexedBlockHash: scannedBlock.blockHash,
-      receivedBlockHash: match.receivedBlock.blockHash
+      receivedBlockHash: match$1.receivedBlock.blockHash
     });
     ChainState.recordReorgDetected(chainState, scannedBlock.blockNumber);
     rollbackWithReorgDetectedBlockNumber = ChainState.shouldRollbackOnReorg(chainState) ? scannedBlock.blockNumber : undefined;
   }
   if (rollbackWithReorgDetectedBlockNumber !== undefined) {
-    let match$1 = IndexerState.rollbackState(state);
+    let match$2 = IndexerState.rollbackState(state);
     let eventsProcessedDiffByChain;
-    eventsProcessedDiffByChain = typeof match$1 !== "object" || match$1.TAG !== "RollbackReady" ? undefined : match$1.eventsProcessedDiffByChain;
+    eventsProcessedDiffByChain = typeof match$2 !== "object" || match$2.TAG !== "RollbackReady" ? undefined : match$2.eventsProcessedDiffByChain;
     Utils.Dict.forEach(IndexerState.chainStates(state), cs => ChainState.prepareReorg(cs, eventsProcessedDiffByChain !== undefined ? eventsProcessedDiffByChain[ChainState.chainConfig(cs).id] : undefined));
     IndexerState.beginReorg(state, chainId, rollbackWithReorgDetectedBlockNumber);
     return scheduleRollback();
@@ -142,31 +387,86 @@ async function onQueryResponse(state, param, runtime, stateId, scheduleFetch, sc
     ChainState.transactionStore(chainState).merge(Primitive_option.valFromOption(transactionStore));
   }
   let itemsWithContractRegister = [];
-  for (let idx = 0, idx_finish = parsedQueueItems.length; idx < idx_finish; ++idx) {
-    let item = parsedQueueItems[idx];
+  for (let idx = 0, idx_finish = parsedQueueItems$1.length; idx < idx_finish; ++idx) {
+    let item = parsedQueueItems$1[idx];
     if (hasContractRegister(item)) {
       itemsWithContractRegister.push(item);
     }
   }
-  let proceed = newRegistrations => {
+  let proceed = (newRegistrations, blockRegisterThrough, newItemsOpt, latestFetchedBlockOpt) => {
+    let newItems = newItemsOpt !== undefined ? newItemsOpt : parsedQueueItems$1;
+    let latestFetchedBlock = latestFetchedBlockOpt !== undefined ? latestFetchedBlockOpt : latestFetchedBlockNumber$1;
     if (!IndexerState.isStale(state, stateId)) {
-      applyQueryResponse(state, chainId, parsedQueueItems, newRegistrations, knownHeight, latestFetchedBlockNumber, query);
+      applyQueryResponse(state, chainId, newItems, newRegistrations, knownHeight, latestFetchedBlock, query);
+      if (blockRegisterThrough !== undefined) {
+        ChainState.markBlockRegistered(chainState, blockRegisterThrough);
+      }
       ChainMetadata.stage(state);
       scheduleFetch();
       return scheduleProcessing();
     }
   };
+  let blockRegisterCeiling = Primitive_int.min(latestFetchedBlockNumber$1, Primitive_int.max(knownHeight, ChainState.knownHeight(chainState)));
+  let withBlockPasses = ChainState.hasBlockRegisters(chainState) && (Utils.$$Array.notEmpty(itemsWithContractRegister) || ChainState.canAdvanceBlockRegisters(chainState, blockRegisterCeiling));
+  if (withBlockPasses) {
+    let match$3 = ChainState.queueBlockRegisterRun(chainState);
+    let finish = match$3[1];
+    let held = ChainState.holdExtraBudget(chainState, Primitive_int.max(0, parsedQueueItems$1.length - query.itemsEst | 0));
+    await match$3[0];
+    if (IndexerState.isStale(state, stateId)) {
+      ChainState.releaseExtraBudget(chainState, held);
+      finish();
+      return scheduleFetch();
+    }
+    let match$4 = ChainState.blockRegisterItemsAfter(chainState, Primitive_int.max(Stdlib_Option.getOr(ChainState.blockRegisterThrough(chainState), blockRegisterCeiling), query.fromBlock - 1 | 0), blockRegisterCeiling, 50000);
+    let cutAt;
+    if (match$4 !== undefined) {
+      let covered = match$4[1];
+      cutAt = covered < blockRegisterCeiling ? covered : undefined;
+    } else {
+      cutAt = undefined;
+    }
+    let through = Stdlib_Option.getOr(cutAt, blockRegisterCeiling);
+    let match$5;
+    if (cutAt !== undefined) {
+      let isKept = item => item.blockNumber <= through;
+      match$5 = [
+        parsedQueueItems$1.filter(isKept),
+        itemsWithContractRegister.filter(isKept),
+        through
+      ];
+    } else {
+      match$5 = [
+        parsedQueueItems$1,
+        itemsWithContractRegister,
+        latestFetchedBlockNumber$1
+      ];
+    }
+    let val;
+    try {
+      val = await runResponsePassesOrThrow(match$5[1], through, runtime, chainState);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      finish();
+      return IndexerState.errorExit(state, ErrorHandling.make(exn, ChainState.logger(chainState), undefined));
+    }
+    ChainState.releaseExtraBudget(chainState, held);
+    proceed(val[0], val[1], match$5[0], match$5[2]);
+    return finish();
+  }
   if (itemsWithContractRegister.length === 0) {
-    return proceed([]);
+    return proceed([], undefined, undefined, undefined);
   }
+  let held$1 = Env.subgraphMode.contents ? Primitive_option.some(ChainState.holdExtraBudget(chainState, Primitive_int.max(0, parsedQueueItems$1.length - query.itemsEst | 0))) : undefined;
   let newRegistrations;
   try {
     newRegistrations = await runContractRegistersOrThrow(itemsWithContractRegister, runtime, chainState);
-  } catch (raw_exn) {
-    let exn = Primitive_exceptions.internalToException(raw_exn);
-    return IndexerState.errorExit(state, ErrorHandling.make(exn, ChainState.logger(chainState), undefined));
+  } catch (raw_exn$1) {
+    let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
+    return IndexerState.errorExit(state, ErrorHandling.make(exn$1, ChainState.logger(chainState), undefined));
   }
-  return proceed(newRegistrations);
+  Stdlib_Option.forEach(held$1, held => ChainState.releaseExtraBudget(chainState, held));
+  return proceed(newRegistrations, undefined, undefined, undefined);
 }
 
 function finishWaitingForNewBlock(state, chainId, knownHeight, stateId, scheduleFetch, scheduleProcessing) {
@@ -179,11 +479,55 @@ function finishWaitingForNewBlock(state, chainId, knownHeight, stateId, schedule
   scheduleProcessing();
 }
 
+async function catchUpBlockRegisters(state, chainId, runtime, stateId, scheduleFetch, scheduleProcessing) {
+  let chainState = IndexerState.getChainState(state, chainId);
+  if (!ChainState.isBlockRegisterIdle(chainState)) {
+    return;
+  }
+  let match = ChainState.nextBlockRegisterItems(chainState, ChainState.blockRegisterFrontier(chainState), 10000);
+  if (match === undefined) {
+    return;
+  }
+  let through = match[1];
+  let blockItems = match[0];
+  let match$1 = ChainState.queueBlockRegisterRun(chainState);
+  let finish = match$1[1];
+  let startedAt = Date.now();
+  let registrations;
+  try {
+    registrations = await runRegisterPassesOrThrow([], blockItems, runtime, chainState);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    finish();
+    return IndexerState.errorExit(state, ErrorHandling.make(exn, ChainState.logger(chainState), undefined));
+  }
+  let isStale = IndexerState.isStale(state, stateId);
+  Logger.trace(ChainState.logger(chainState), "Ran block passes", {
+    through: through,
+    blockPasses: blockItems.length,
+    registrations: registrations.length,
+    stale: isStale,
+    ms: Date.now() - startedAt
+  });
+  if (!isStale) {
+    ChainState.applyBlockRegisters(chainState, sortRegistrations(registrations), through);
+  }
+  finish();
+  if (!isStale) {
+    ChainMetadata.stage(state);
+    scheduleProcessing();
+  }
+  return scheduleFetch();
+}
+
 async function fetchChain(state, chainId, runtime, action, stateId, scheduleFetch, scheduleProcessing, scheduleRollback) {
   let chainState = IndexerState.getChainState(state, chainId);
   if (IndexerState.isResolvingReorg(state) || IndexerState.isStopped(state)) {
     return;
   }
+  if (ChainState.hasBlockRegisters(chainState)) {
+    catchUpBlockRegisters(state, chainId, runtime, stateId, scheduleFetch, scheduleProcessing);
+  }
   let isRealtime = IndexerState.isRealtime(state);
   let sourceManager = ChainState.sourceManager(chainState);
   let reducedPolling = !isRealtime && ChainState.knownHeight(chainState) > 0;
@@ -207,13 +551,40 @@ async function fetchChain(state, chainId, runtime, action, stateId, scheduleFetc
   }
 }
 
+let blockRegisterChunk = 2048;
+
+let blockRegisterWindow = 10000;
+
+let maxResponseBlockPasses = 50000;
+
+let registerCallsPerChunk = 3000;
+
+let unknownCostChunk = 100;
+
+let minRegisterChunk = 100;
+
 export {
   hasContractRegister,
   invokeContractRegister,
   runContractRegistersOrThrow,
+  mergeRegisterItems,
+  blockRegisterChunk,
+  blockRegisterWindow,
+  maxResponseBlockPasses,
+  runRegisterPassesOrThrow,
+  sortRegistrations,
+  runResponsePassesOrThrow,
+  registerCallsPerItem,
+  reportRegisterFrontier,
+  registerCallsPerChunk,
+  unknownCostChunk,
+  minRegisterChunk,
+  registerChunkLimit,
+  cutAtRegisterLimit,
   onQueryResponse,
   applyQueryResponse,
   finishWaitingForNewBlock,
+  catchUpBlockRegisters,
   fetchChain,
 }
-/* Utils Not a pure module */
+/* Env Not a pure module */