envio 3.15.0-subgraph → 3.16.0

package/src/ChainFetching.res.mjs

@@ -1,18 +1,14 @@
 // 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";
@@ -24,74 +20,32 @@ function hasContractRegister(item) {
   if (item.kind === 0) {
     return item.onEventRegistration.contractRegister !== undefined;
   } else {
-    return item.onBlockRegistration.contractRegister !== undefined;
+    return false;
   }
 }
 
 function invokeContractRegister(runtime, item) {
-  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);
+  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
+  });
 }
 
 async function runContractRegistersOrThrow(itemsWithContractRegister, runtime, chainState) {
-  await ChainState.materializePageItems(Env.subgraphMode.contents ? itemsWithContractRegister.filter(item => item.kind === 0) : itemsWithContractRegister, ChainState.transactionStore(chainState), ChainState.blockStore(chainState), ChainState.shouldChecksum(chainState));
+  await ChainState.materializePageItems(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,
-      creationRound: tmp
+      registrations: registrations
     };
     let scope = {
       TAG: "ContractRegister",
@@ -103,208 +57,16 @@ async function runContractRegistersOrThrow(itemsWithContractRegister, runtime, c
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       RunScope.resolve(scope);
-      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 ErrorHandling.mkLogAndRaise(RunScope.contractRegisterLogger(run), "Event contractRegister failed, please fix the error to keep the indexer running smoothly", 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;
   }
@@ -327,15 +89,8 @@ async function onQueryResponse(state, param, runtime, stateId, scheduleFetch, sc
   let transactionStore = response.transactionStore;
   let parsedQueueItems = response.parsedQueueItems;
   let knownHeight = response.knownHeight;
-  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) => {
+  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) => {
     if (hasContractRegister(item)) {
       return count + 1 | 0;
     } else {
@@ -346,15 +101,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$1,
-      numEvents: parsedQueueItems$1.length
+      toBlock: latestFetchedBlockNumber,
+      numEvents: parsedQueueItems.length
     });
   } else {
     Logger.trace(ChainState.logger(chainState), "Finished querying", {
       partitionId: query.partitionId,
       fromBlock: query.fromBlock,
-      toBlock: latestFetchedBlockNumber$1,
-      numEvents: parsedQueueItems$1.length,
+      toBlock: latestFetchedBlockNumber,
+      numEvents: parsedQueueItems.length,
       numContractRegisterEvents: numContractRegisterEvents
     });
   }
@@ -363,22 +118,22 @@ async function onQueryResponse(state, param, runtime, stateId, scheduleFetch, sc
   if (typeof reorgResult !== "object") {
     rollbackWithReorgDetectedBlockNumber = undefined;
   } else {
-    let match$1 = reorgResult._0;
-    let scannedBlock = match$1.scannedBlock;
+    let match = reorgResult._0;
+    let scannedBlock = match.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$1.receivedBlock.blockHash
+      receivedBlockHash: match.receivedBlock.blockHash
     });
     ChainState.recordReorgDetected(chainState, scannedBlock.blockNumber);
     rollbackWithReorgDetectedBlockNumber = ChainState.shouldRollbackOnReorg(chainState) ? scannedBlock.blockNumber : undefined;
   }
   if (rollbackWithReorgDetectedBlockNumber !== undefined) {
-    let match$2 = IndexerState.rollbackState(state);
+    let match$1 = IndexerState.rollbackState(state);
     let eventsProcessedDiffByChain;
-    eventsProcessedDiffByChain = typeof match$2 !== "object" || match$2.TAG !== "RollbackReady" ? undefined : match$2.eventsProcessedDiffByChain;
+    eventsProcessedDiffByChain = typeof match$1 !== "object" || match$1.TAG !== "RollbackReady" ? undefined : match$1.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();
@@ -387,86 +142,31 @@ 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$1.length; idx < idx_finish; ++idx) {
-    let item = parsedQueueItems$1[idx];
+  for (let idx = 0, idx_finish = parsedQueueItems.length; idx < idx_finish; ++idx) {
+    let item = parsedQueueItems[idx];
     if (hasContractRegister(item)) {
       itemsWithContractRegister.push(item);
     }
   }
-  let proceed = (newRegistrations, blockRegisterThrough, newItemsOpt, latestFetchedBlockOpt) => {
-    let newItems = newItemsOpt !== undefined ? newItemsOpt : parsedQueueItems$1;
-    let latestFetchedBlock = latestFetchedBlockOpt !== undefined ? latestFetchedBlockOpt : latestFetchedBlockNumber$1;
+  let proceed = newRegistrations => {
     if (!IndexerState.isStale(state, stateId)) {
-      applyQueryResponse(state, chainId, newItems, newRegistrations, knownHeight, latestFetchedBlock, query);
-      if (blockRegisterThrough !== undefined) {
-        ChainState.markBlockRegistered(chainState, blockRegisterThrough);
-      }
+      applyQueryResponse(state, chainId, parsedQueueItems, newRegistrations, knownHeight, latestFetchedBlockNumber, query);
       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([], undefined, undefined, undefined);
+    return proceed([]);
   }
-  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$1) {
-    let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
-    return IndexerState.errorExit(state, ErrorHandling.make(exn$1, ChainState.logger(chainState), undefined));
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return IndexerState.errorExit(state, ErrorHandling.make(exn, ChainState.logger(chainState), undefined));
   }
-  Stdlib_Option.forEach(held$1, held => ChainState.releaseExtraBudget(chainState, held));
-  return proceed(newRegistrations, undefined, undefined, undefined);
+  return proceed(newRegistrations);
 }
 
 function finishWaitingForNewBlock(state, chainId, knownHeight, stateId, scheduleFetch, scheduleProcessing) {
@@ -479,55 +179,11 @@ 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;
@@ -544,47 +200,20 @@ async function fetchChain(state, chainId, runtime, action, stateId, scheduleFetc
         let exn = Primitive_exceptions.internalToException(raw_exn);
         return IndexerState.errorExit(state, ErrorHandling.make(exn, IndexerState.logger(state), undefined));
       }
-    }, knownHeight => SourceManager.waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling, ChainState.chainConfig(chainState).blockThrottle), knownHeight => finishWaitingForNewBlock(state, chainId, knownHeight, stateId, scheduleFetch, scheduleProcessing), action, stateId);
+    }, knownHeight => SourceManager.waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling), knownHeight => finishWaitingForNewBlock(state, chainId, knownHeight, stateId, scheduleFetch, scheduleProcessing), action, stateId);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     return IndexerState.errorExit(state, ErrorHandling.make(exn, IndexerState.logger(state), IndexerState.unexpectedErrorMsg));
   }
 }
 
-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,
 }
-/* Env Not a pure module */
+/* Utils Not a pure module */