envio 3.15.0 → 3.16.0

package/src/Supervisor.res

@@ -374,74 +374,93 @@ let releaseIfAtHead = group =>
     )
   }
 
-// The run's chains as an unsplit indexer reports them before it has fetched
-// anything: at their configured blocks, with nothing indexed. A display draws
-// these for a worker it hasn't heard from yet.
-let configuredChains = (config: Config.t): array<Metrics.chainMetrics> =>
+// The run's chains as a worker reports them before it has fetched anything:
+// where `ChainState.makeFromDbState` resumes them. A display draws these for a
+// worker it hasn't heard from yet, and its first sight of a chain is what it
+// measures the sync pace from, so a resumed chain drawn from its start block
+// would pass the earlier runs' progress off as this one's.
+let resumedChains = (config: Config.t, ~resumed: array<Persistence.initialChainState>): array<
+  Metrics.chainMetrics,
+> =>
   config.chainMap
   ->ChainMap.values
   ->Array.map((chain): Metrics.chainMetrics => {
-    chainId: chain.id,
-    poweredByHyperSync: switch chain.sourceConfig {
-    | EvmSourceConfig({hypersync}) => hypersync->Option.isSome
-    | FuelSourceConfig(_) | SvmSourceConfig(_) => true
-    | SimulateSourceConfig(_) | CustomSources(_) => false
-    },
-    firstEventBlockNumber: None,
-    latestProcessedBlock: None,
-    timestampCaughtUpToHeadOrEndblock: None,
-    numEventsProcessed: 0.,
-    latestFetchedBlockNumber: 0,
-    knownHeight: 0,
-    numBatchesFetched: 0,
-    // A chain resolves `start_block: latest` against its own head as it starts,
-    // which is a worker's to do and no supervisor's to guess.
-    startBlock: switch chain.startBlock {
-    | Block(block) => block
-    | Latest => 0
-    },
-    endBlock: chain.endBlock,
-    numAddresses: 0,
-    addressesByContract: [],
-    isReady: false,
-    sourceBlockNumber: 0,
-    progressBlockNumber: -1,
-    progressLatencyMs: None,
-    progressBlockTime: None,
-    concurrency: 0,
-    partitionsCount: 0,
-    bufferSize: 0,
-    bufferBlockNumber: -1,
-    idleSeconds: 0.,
-    waitingForNewBlockSeconds: 0.,
-    queryingSeconds: 0.,
-    blockRangeFetchSeconds: 0.,
-    blockRangeParseSeconds: 0.,
-    blockRangeFetchCount: 0.,
-    blockRangeFetchedEvents: 0.,
-    blockRangeFetchedBlocks: 0.,
-    reorgCount: 0,
-    reorgDetectedBlock: None,
-    rollbackTargetBlock: None,
-    rateLimitTimeMs: 0.,
-    rateLimitResetInMs: None,
+    let row = resumed->Array.find(row => row.id == chain.id)
+    let startBlock = row->Option.mapOr(chain->Config.startBlockOrZero, row => row.startBlock)
+    let endBlock = row->Option.mapOr(chain.endBlock, row => row.endBlock)
+    let progressBlockNumber = switch row {
+    | Some({progressBlockNumber}) if progressBlockNumber >= 0 => progressBlockNumber
+    | _ => startBlock - 1
+    }
+    let sourceBlockNumber = row->Option.mapOr(0, row => row.sourceBlockNumber)
+    let timestampCaughtUpToHeadOrEndblock =
+      row->Option.flatMap(row => row.timestampCaughtUpToHeadOrEndblock)
+    let metrics: Metrics.chainMetrics = {
+      chainId: chain.id,
+      poweredByHyperSync: switch chain.sourceConfig {
+      | EvmSourceConfig({hypersync}) => hypersync->Option.isSome
+      | FuelSourceConfig(_) | SvmSourceConfig(_) => true
+      | SimulateSourceConfig(_) | CustomSources(_) => false
+      },
+      firstEventBlockNumber: row->Option.flatMap(row => row.firstEventBlockNumber),
+      latestProcessedBlock: progressBlockNumber === -1 ? None : Some(progressBlockNumber),
+      timestampCaughtUpToHeadOrEndblock,
+      numEventsProcessed: row->Option.mapOr(0., row => row.numEventsProcessed),
+      latestFetchedBlockNumber: Pervasives.max(progressBlockNumber, 0),
+      knownHeight: sourceBlockNumber,
+      numBatchesFetched: 0,
+      startBlock,
+      endBlock,
+      numAddresses: 0,
+      addressesByContract: [],
+      isReady: timestampCaughtUpToHeadOrEndblock->Option.isSome,
+      sourceBlockNumber,
+      progressBlockNumber,
+      progressLatencyMs: None,
+      progressBlockTime: row->Option.flatMap(row => row.progressBlockTime),
+      concurrency: 0,
+      partitionsCount: 0,
+      bufferSize: 0,
+      bufferBlockNumber: progressBlockNumber,
+      idleSeconds: 0.,
+      waitingForNewBlockSeconds: 0.,
+      queryingSeconds: 0.,
+      blockRangeFetchSeconds: 0.,
+      blockRangeParseSeconds: 0.,
+      blockRangeFetchCount: 0.,
+      blockRangeFetchedEvents: 0.,
+      blockRangeFetchedBlocks: 0.,
+      reorgCount: 0,
+      reorgDetectedBlock: None,
+      rollbackTargetBlock: None,
+      rateLimitTimeMs: 0.,
+      rateLimitResetInMs: None,
+    }
+    switch (metrics->Metrics.hasProcessedToEndblock, endBlock) {
+    | (true, Some(endBlock)) => {...metrics, knownHeight: endBlock}
+    | _ => metrics
+    }
   })
 
 // Per worker rather than all or nothing: a worker done within its first report
 // interval is heard from only as it exits, and a display holding just its
 // siblings' finished chains would read as synced while it still indexes.
-let displayedSnapshots = (running: array<running>, ~config, ~empty: Metrics.t) => {
-  let configured = configuredChains(config)
+let displayedSnapshots = (
+  running: array<running>,
+  ~resumedChains: array<Metrics.chainMetrics>,
+  ~empty: Metrics.t,
+) =>
   running->Array.map(r =>
     switch r.snapshot {
     | Some(snapshot) => snapshot
     | None => {
         ...empty,
-        chains: configured->Array.filter(chain => r.worker.chainIds->Array.includes(chain.chainId)),
+        chains: resumedChains->Array.filter(chain =>
+          r.worker.chainIds->Array.includes(chain.chainId)
+        ),
       }
     }
   )
-}
 
 // Runs the group: creates the schema for every chain, forks a worker per plan
 // entry, and serves the run's metrics, console and display from what they
@@ -481,10 +500,9 @@ let run = async (~config: Config.t, ~logger, ~workers: array<worker>, ~reset) =>
   let shouldUseTui = Tui.shouldUse()
   // A run that resumed with every chain already caught up owes nobody a wait:
   // its workers start realtime and there is no barrier to open.
+  let resumed = (persistence->Persistence.getInitializedState).chains
   let holdRealtime =
-    (persistence->Persistence.getInitializedState).chains->Array.some(chain =>
-      chain.timestampCaughtUpToHeadOrEndblock->Option.isNone
-    )
+    resumed->Array.some(chain => chain.timestampCaughtUpToHeadOrEndblock->Option.isNone)
   let group = {running: [], stopping: false, holdingRealtime: holdRealtime}
   group.running =
     workers->Array.mapWithIndex((worker, workerIndex) =>
@@ -534,8 +552,9 @@ let run = async (~config: Config.t, ~logger, ~workers: array<worker>, ~reset) =>
   )
 
   if shouldUseTui {
+    let resumedChains = resumedChains(config, ~resumed)
     Tui.start(~config, ~logger, ~getMetrics=() =>
-      group.running->displayedSnapshots(~config, ~empty=[]->merge)->merge
+      group.running->displayedSnapshots(~resumedChains, ~empty=[]->merge)->merge
     )
   }
 

package/src/Supervisor.res.mjs

@@ -22,6 +22,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Child_process from "child_process";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as CrossChainState from "./CrossChainState.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
@@ -313,8 +314,20 @@ function releaseIfAtHead(group) {
   }
 }
 
-function configuredChains(config) {
+function resumedChains(config, resumed) {
   return ChainMap.values(config.chainMap).map(chain => {
+    let row = resumed.find(row => Primitive_object.equal(row.id, chain.id));
+    let startBlock = Stdlib_Option.mapOr(row, Config.startBlockOrZero(chain), row => row.startBlock);
+    let endBlock = Stdlib_Option.mapOr(row, chain.endBlock, row => row.endBlock);
+    let progressBlockNumber;
+    if (row !== undefined) {
+      let progressBlockNumber$1 = row.progressBlockNumber;
+      progressBlockNumber = progressBlockNumber$1 >= 0 ? progressBlockNumber$1 : startBlock - 1 | 0;
+    } else {
+      progressBlockNumber = startBlock - 1 | 0;
+    }
+    let sourceBlockNumber = Stdlib_Option.mapOr(row, 0, row => row.sourceBlockNumber);
+    let timestampCaughtUpToHeadOrEndblock = Stdlib_Option.flatMap(row, row => row.timestampCaughtUpToHeadOrEndblock);
     let match = chain.sourceConfig;
     let tmp;
     switch (match.TAG) {
@@ -330,32 +343,37 @@ function configuredChains(config) {
         tmp = false;
         break;
     }
-    let block = chain.startBlock;
-    let tmp$1;
-    tmp$1 = block === "latest" ? 0 : block;
-    return {
-      chainId: chain.id,
+    let metrics_chainId = chain.id;
+    let metrics_firstEventBlockNumber = Stdlib_Option.flatMap(row, row => row.firstEventBlockNumber);
+    let metrics_latestProcessedBlock = progressBlockNumber === -1 ? undefined : progressBlockNumber;
+    let metrics_numEventsProcessed = Stdlib_Option.mapOr(row, 0, row => row.numEventsProcessed);
+    let metrics_latestFetchedBlockNumber = Primitive_int.max(progressBlockNumber, 0);
+    let metrics_addressesByContract = [];
+    let metrics_isReady = Stdlib_Option.isSome(timestampCaughtUpToHeadOrEndblock);
+    let metrics_progressBlockTime = Stdlib_Option.flatMap(row, row => row.progressBlockTime);
+    let metrics = {
+      chainId: metrics_chainId,
       poweredByHyperSync: tmp,
-      firstEventBlockNumber: undefined,
-      latestProcessedBlock: undefined,
-      timestampCaughtUpToHeadOrEndblock: undefined,
-      numEventsProcessed: 0,
-      latestFetchedBlockNumber: 0,
-      knownHeight: 0,
+      firstEventBlockNumber: metrics_firstEventBlockNumber,
+      latestProcessedBlock: metrics_latestProcessedBlock,
+      timestampCaughtUpToHeadOrEndblock: timestampCaughtUpToHeadOrEndblock,
+      numEventsProcessed: metrics_numEventsProcessed,
+      latestFetchedBlockNumber: metrics_latestFetchedBlockNumber,
+      knownHeight: sourceBlockNumber,
       numBatchesFetched: 0,
-      startBlock: tmp$1,
-      endBlock: chain.endBlock,
+      startBlock: startBlock,
+      endBlock: endBlock,
       numAddresses: 0,
-      addressesByContract: [],
-      isReady: false,
-      sourceBlockNumber: 0,
-      progressBlockNumber: -1,
+      addressesByContract: metrics_addressesByContract,
+      isReady: metrics_isReady,
+      sourceBlockNumber: sourceBlockNumber,
+      progressBlockNumber: progressBlockNumber,
       progressLatencyMs: undefined,
-      progressBlockTime: undefined,
+      progressBlockTime: metrics_progressBlockTime,
       concurrency: 0,
       partitionsCount: 0,
       bufferSize: 0,
-      bufferBlockNumber: -1,
+      bufferBlockNumber: progressBlockNumber,
       idleSeconds: 0,
       waitingForNewBlockSeconds: 0,
       queryingSeconds: 0,
@@ -370,18 +388,27 @@ function configuredChains(config) {
       rateLimitTimeMs: 0,
       rateLimitResetInMs: undefined
     };
+    let match$1 = Metrics.hasProcessedToEndblock(metrics);
+    if (!match$1) {
+      return metrics;
+    }
+    if (endBlock === undefined) {
+      return metrics;
+    }
+    let newrecord = {...metrics};
+    newrecord.knownHeight = endBlock;
+    return newrecord;
   });
 }
 
-function displayedSnapshots(running, config, empty) {
-  let configured = configuredChains(config);
+function displayedSnapshots(running, resumedChains, empty) {
   return running.map(r => {
     let snapshot = r.snapshot;
     if (snapshot !== undefined) {
       return snapshot;
     }
     let newrecord = {...empty};
-    newrecord.chains = configured.filter(chain => r.worker.chainIds.includes(chain.chainId));
+    newrecord.chains = resumedChains.filter(chain => r.worker.chainIds.includes(chain.chainId));
     return newrecord;
   });
 }
@@ -402,7 +429,8 @@ async function run(config, logger, workers, reset) {
     maxConnections: Env.Db.maxConnections
   });
   let shouldUseTui = Tui.shouldUse(undefined, undefined);
-  let holdRealtime = Persistence.getInitializedState(persistence).chains.some(chain => Stdlib_Option.isNone(chain.timestampCaughtUpToHeadOrEndblock));
+  let resumed = Persistence.getInitializedState(persistence).chains;
+  let holdRealtime = resumed.some(chain => Stdlib_Option.isNone(chain.timestampCaughtUpToHeadOrEndblock));
   let group = {
     running: [],
     stopping: false,
@@ -421,7 +449,8 @@ async function run(config, logger, workers, reset) {
     runtime
   ]))), config.isDev);
   if (shouldUseTui) {
-    Tui.start(config, logger, () => merge(displayedSnapshots(group.running, config, merge([]))));
+    let resumedChains$1 = resumedChains(config, resumed);
+    Tui.start(config, logger, () => merge(displayedSnapshots(group.running, resumedChains$1, merge([]))));
   }
   process.on("SIGTERM", () => stop(group));
   process.on("SIGINT", () => stop(group));
@@ -465,7 +494,7 @@ export {
   awaitExit,
   isRunAtHead,
   releaseIfAtHead,
-  configuredChains,
+  resumedChains,
   displayedSnapshots,
   run,
 }

package/src/TestIndexer.res

@@ -53,11 +53,13 @@ let renderRows = (rows: array<AddressRows.row>, ~config: Config.t) =>
 
 // Rows of a per-chain entity are keyed per (chain, id): the same id exists
 // independently on every chain.
-let rowKey = (~scope: Internal.chainScope, ~entityId: EntityId.t) =>
+let rowKey = (~table: Table.table, ~scope: Internal.chainScope, ~entityId: EntityId.t) => {
+  let entityKey = table.entityIdToKey(entityId)
   switch scope {
-  | CrossChain => entityId->EntityId.toKey
-  | Chain(chainId) => `${chainId->ChainId.toString}|${entityId->EntityId.toKey}`
+  | CrossChain => entityKey
+  | Chain(chainId) => `${chainId->ChainId.toString}|${entityKey}`
   }
+}
 
 let readChainId = (entity: Internal.entity, ~field: Table.field): option<ChainId.t> =>
   entity
@@ -158,19 +160,18 @@ let handleWriteBatch = (
       switch change {
       | Set({entityId, entity, checkpointId}) =>
         // The store keeps decoded entities so load comparisons (bigint /
-        // BigDecimal) work on real values. Ids are keyed by their string form
-        // since they may be string/int/bigint.
+        // BigDecimal) work on real values.
         let storedEntity = switch (chainIdField, scope->Internal.chainScopeChainId) {
         | (Some(field), Some(chainId)) =>
           entity->Internal.stampChainId(~fieldName=field.fieldName, ~chainId)
         | _ => entity
         }
-        entityDict->Dict.set(rowKey(~scope, ~entityId), storedEntity)
+        entityDict->Dict.set(rowKey(~table=entityConfig.table, ~scope, ~entityId), storedEntity)
         // The change already carries the checkpoint's chainId, so the entity
         // inside it stays unstamped.
         entityChangeFor(checkpointId).sets->Array.push(entity->Utils.magic)->ignore
       | Delete({entityId, checkpointId}) =>
-        Dict.delete(entityDict->Obj.magic, rowKey(~scope, ~entityId))
+        Dict.delete(entityDict->Obj.magic, rowKey(~table=entityConfig.table, ~scope, ~entityId))
         entityChangeFor(checkpointId).deleted->Array.push(entityId)->ignore
       }
     }
@@ -433,10 +434,15 @@ let getEntityFromState = (
     )
   }
   let entityDict = state.entities->Dict.get(entityConfig.name)->Option.getOr(Dict.make())
+  let {entityIdToKey} = entityConfig.table
+  let key = entityIdToKey(entityId->EntityId.unsafeOfString)
   switch entityConfig.table->Table.getChainIdField {
-  | None => entityDict->Dict.get(entityId)->Option.map(copyEntity)
+  | None => entityDict->Dict.get(key)->Option.map(copyEntity)
   | Some(field) =>
-    let matches = entityDict->Dict.valuesToArray->Array.filter(entity => entity.id === entityId)
+    let matches =
+      entityDict
+      ->Dict.valuesToArray
+      ->Array.filter(entity => entityIdToKey(entity.id->EntityId.unsafeOfString) === key)
     switch matches {
     | [] => None
     | [entity] => Some(copyEntity(entity))
@@ -508,7 +514,7 @@ let makeEntitySet = (~state: testIndexerState, ~entityConfig: Internal.entityCon
       }
     }
     entityDict->Dict.set(
-      rowKey(~scope, ~entityId=entity.id->EntityId.unsafeOfString),
+      rowKey(~table=entityConfig.table, ~scope, ~entityId=entity.id->EntityId.unsafeOfString),
       copyEntity(entity),
     )
   }
@@ -568,13 +574,7 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
   // The runner injects the config-derived initial state by setting
   // `persistence.storageStatus = Ready(...)` directly, bypassing `Persistence.init`,
   // so none of these is reached.
-  initialize: async (
-    ~chainConfigs as _=?,
-    ~entities as _=?,
-    ~enums as _=?,
-    ~contractMapping as _,
-    ~envioInfo as _,
-  ) =>
+  initialize: async (~chainConfigs as _=?, ~contractMapping as _, ~envioInfo as _) =>
     JsError.throwWithMessage(
       "TestIndexer: initialize should not be called; the initial state is derived from config.",
     ),
@@ -582,11 +582,11 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     JsError.throwWithMessage(
       "TestIndexer: readStoredConfig should not be called; the initial state is derived from config.",
     ),
-  addChain: async (~chainConfig as _, ~entities as _, ~contractMapping as _) =>
+  addChain: async (~chainConfig as _, ~contractMapping as _) =>
     JsError.throwWithMessage(
       "TestIndexer: addChain should not be called; the initial state is derived from config.",
     ),
-  resumeInitialState: async (~entities as _, ~chainIds as _, ~contractMapping as _) =>
+  resumeInitialState: async (~chainIds as _, ~contractMapping as _) =>
     JsError.throwWithMessage(
       "TestIndexer: resumeInitialState should not be called; the initial state is derived from config.",
     ),
@@ -596,13 +596,12 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     ->(Utils.magic: array<Internal.entity> => array<unknown>),
   // The in-memory storage has no indexes to build, and it's always ready.
   ensureQueryIndexes: async (~entityConfig as _, ~scope as _, ~filters as _) => (),
-  ensureSchemaIndexes: async (~entities as _, ~chainIds as _) => (),
-  finalizeBackfill: async (~entities as _, ~chainIds as _, ~readyAt as _) => (),
+  ensureSchemaIndexes: async (~chainIds as _) => (),
+  finalizeBackfill: async (~chainIds as _, ~readyAt as _) => (),
   writeBatch: async (
     ~batch,
     ~rollback as _,
     ~config,
-    ~allEntities as _,
     ~updatedEffectsCache as _,
     ~updatedEntities,
     ~registeredAddresses,
@@ -623,11 +622,7 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
   setChainMeta: async _ => Obj.magic(),
   pruneStaleCheckpoints: async (~safeCheckpoints as _) => (),
   pruneStaleEntityHistory: async (~entityConfig as _, ~safeCheckpoints as _) => (),
-  getRollbackTargetCheckpoint: async (
-    ~reorgChainId as _,
-    ~lastKnownValidBlockNumber as _,
-    ~sequence as _,
-  ) =>
+  getRollbackTargetCheckpoint: async (~reorgChainId as _, ~lastKnownValidBlockNumber as _) =>
     JsError.throwWithMessage(
       "TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable.",
     ),

package/src/TestIndexer.res.mjs

@@ -7,7 +7,6 @@ import * as Config from "./Config.res.mjs";
 import * as Logger from "./Logger.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
-import * as EntityId from "./EntityId.res.mjs";
 import * as Frontier from "./db/Frontier.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
@@ -39,11 +38,12 @@ function renderRows(rows, config) {
   return AddressRows.render(rows, config.ecosystem.name, !config.lowercaseAddresses);
 }
 
-function rowKey(scope, entityId) {
+function rowKey(table, scope, entityId) {
+  let entityKey = table.entityIdToKey(entityId);
   if (scope === "crossChain") {
-    return EntityId.toKey(entityId);
+    return entityKey;
   } else {
-    return ChainId.toString(scope) + `|` + EntityId.toKey(entityId);
+    return ChainId.toString(scope) + `|` + entityKey;
   }
 }
 
@@ -126,12 +126,12 @@ function handleWriteBatch(state, config, updatedEntities, registeredAddresses, c
         let entity = change.entity;
         let match = Internal.chainScopeChainId(scope);
         let storedEntity = chainIdField !== undefined && match !== undefined ? Internal.stampChainId(entity, chainIdField.fieldName, Primitive_option.valFromOption(match)) : entity;
-        entityDict[rowKey(scope, change.entityId)] = storedEntity;
+        entityDict[rowKey(entityConfig.table, scope, change.entityId)] = storedEntity;
         entityChangeFor(change.checkpointId).sets.push(entity);
         return;
       }
       let entityId = change.entityId;
-      Stdlib_Dict.$$delete(entityDict, rowKey(scope, entityId));
+      Stdlib_Dict.$$delete(entityDict, rowKey(entityConfig.table, scope, entityId));
       entityChangeFor(change.checkpointId).deleted.push(entityId);
     };
     param.changes.forEach(processChange);
@@ -304,11 +304,14 @@ function getEntityFromState(state, entityConfig, entityId, methodName) {
     Stdlib_JsError.throwWithMessage(`Cannot call ` + entityConfig.name + `.` + methodName + `() while indexer.process() is running. ` + "Wait for process() to complete before accessing entities directly.");
   }
   let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
+  let match = entityConfig.table;
+  let entityIdToKey = match.entityIdToKey;
+  let key = entityIdToKey(entityId);
   let field = Table.getChainIdField(entityConfig.table);
   if (field === undefined) {
-    return Stdlib_Option.map(entityDict[entityId], copyEntity);
+    return Stdlib_Option.map(entityDict[key], copyEntity);
   }
-  let matches = Object.values(entityDict).filter(entity => entity.id === entityId);
+  let matches = Object.values(entityDict).filter(entity => entityIdToKey(entity.id) === key);
   let len = matches.length;
   if (len !== 1) {
     if (len === 0) {
@@ -358,7 +361,7 @@ function makeEntitySet(state, entityConfig) {
     } else {
       scope = "crossChain";
     }
-    entityDict[rowKey(scope, entity.id)] = Utils.Dict.shallowCopy(entity);
+    entityDict[rowKey(entityConfig.table, scope, entity.id)] = Utils.Dict.shallowCopy(entity);
   };
 }
 
@@ -388,23 +391,23 @@ function makeInMemoryStorage(state) {
     name: "test-inmemory",
     entityStoreName: param => "test-inmemory",
     holding: async () => "Initialized",
-    initialize: async (param, param$1, param$2, param$3, param$4) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
+    initialize: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
     readStoredConfig: async () => Stdlib_JsError.throwWithMessage("TestIndexer: readStoredConfig should not be called; the initial state is derived from config."),
-    addChain: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: addChain should not be called; the initial state is derived from config."),
-    resumeInitialState: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
+    addChain: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: addChain should not be called; the initial state is derived from config."),
+    resumeInitialState: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
     loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
     ensureQueryIndexes: async (param, param$1, param$2) => {},
-    ensureSchemaIndexes: async (param, param$1) => {},
-    finalizeBackfill: async (param, param$1, param$2) => {},
+    ensureSchemaIndexes: async param => {},
+    finalizeBackfill: async (param, param$1) => {},
     dumpEffectCache: async () => {},
     reset: async () => {},
     setChainMeta: async param => {},
     pruneStaleCheckpoints: async param => {},
     pruneStaleEntityHistory: async (param, param$1) => {},
-    getRollbackTargetCheckpoint: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
+    getRollbackTargetCheckpoint: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackProgressDiff: async param => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackData: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
-    writeBatch: async (batch, param, config, param$1, param$2, updatedEntities, registeredAddresses, param$3, param$4) => handleWriteBatch(state, config, updatedEntities, registeredAddresses, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
+    writeBatch: async (batch, param, config, param$1, updatedEntities, registeredAddresses, param$2, param$3) => handleWriteBatch(state, config, updatedEntities, registeredAddresses, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
     close: async () => {}
   };
 }
@@ -648,7 +651,7 @@ function createTestIndexer() {
           let indexerState = IndexerState.makeFromDbState(runConfig, logger$1, persistence, initialState, registrationsByChainId, undefined, undefined, exitAfterFirstEventBlock, undefined, undefined, undefined, errHandler => {
             ErrorHandling.log(errHandler);
             reject(ErrorHandling.toExn(errHandler));
-          }, () => resolve());
+          }, () => resolve(), undefined);
           indexerStateRef.contents = Primitive_option.some(indexerState);
           IndexerLoop.start(indexerState);
         });

package/src/Throttler.res

@@ -5,27 +5,30 @@ type t = {
   mutable scheduled: option<unit => promise<unit>>,
   intervalMillis: float,
   logger: Logger.t,
+  clock: Clock.t,
 }
 
-let make = (~intervalMillis: int, ~logger) => {
-  lastRunTimeMillis: 0.,
+let make = (~intervalMillis: int, ~logger, ~clock=Clock.real) => {
+  // A clock reads from its own origin, which the first run must not wait on.
+  lastRunTimeMillis: -.(intervalMillis->Int.toFloat),
   isRunning: false,
   isAwaitingInterval: false,
   scheduled: None,
   intervalMillis: intervalMillis->Int.toFloat,
   logger,
+  clock,
 }
 
 let rec startInternal = (throttler: t) => {
   switch throttler {
   | {scheduled: Some(fn), isRunning: false, isAwaitingInterval: false} =>
-    let timeSinceLastRun = Date.now() -. throttler.lastRunTimeMillis
+    let timeSinceLastRun = throttler.clock.now() -. throttler.lastRunTimeMillis
 
     //Only execute if we are passed the interval
     if timeSinceLastRun >= throttler.intervalMillis {
       throttler.isRunning = true
       throttler.scheduled = None
-      throttler.lastRunTimeMillis = Date.now()
+      throttler.lastRunTimeMillis = throttler.clock.now()
 
       // Defer off the schedule call so work queued before it (e.g. a batch) runs first.
       NodeJs.setImmediate(() => {
@@ -45,10 +48,14 @@ let rec startInternal = (throttler: t) => {
     } else {
       //Store isAwaitingInterval in state so that timers don't continuously get created
       throttler.isAwaitingInterval = true
-      let _ = setTimeout(() => {
-        throttler.isAwaitingInterval = false
-        throttler->startInternal
-      }, Int.fromFloat(throttler.intervalMillis -. timeSinceLastRun))
+      let _ = throttler.clock.setTimeout(
+        ~label="throttled write",
+        () => {
+          throttler.isAwaitingInterval = false
+          throttler->startInternal
+        },
+        Int.fromFloat(throttler.intervalMillis -. timeSinceLastRun),
+      )
     }
   | _ => ()
   }

package/src/Throttler.res.mjs

@@ -1,16 +1,19 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Clock from "./Clock.res.mjs";
 import * as Logger from "./Logger.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function make(intervalMillis, logger) {
+function make(intervalMillis, logger, clockOpt) {
+  let clock = clockOpt !== undefined ? clockOpt : Clock.real;
   return {
-    lastRunTimeMillis: 0,
+    lastRunTimeMillis: - intervalMillis,
     isRunning: false,
     isAwaitingInterval: false,
     scheduled: undefined,
     intervalMillis: intervalMillis,
-    logger: logger
+    logger: logger,
+    clock: clock
   };
 }
 
@@ -27,11 +30,11 @@ function startInternal(throttler) {
   if (fn === undefined) {
     return;
   }
-  let timeSinceLastRun = Date.now() - throttler.lastRunTimeMillis;
+  let timeSinceLastRun = throttler.clock.now() - throttler.lastRunTimeMillis;
   if (timeSinceLastRun >= throttler.intervalMillis) {
     throttler.isRunning = true;
     throttler.scheduled = undefined;
-    throttler.lastRunTimeMillis = Date.now();
+    throttler.lastRunTimeMillis = throttler.clock.now();
     setImmediate(() => {
       (async () => {
         try {
@@ -46,7 +49,7 @@ function startInternal(throttler) {
     });
   } else {
     throttler.isAwaitingInterval = true;
-    setTimeout(() => {
+    throttler.clock.setTimeout("throttled write", () => {
       throttler.isAwaitingInterval = false;
       startInternal(throttler);
     }, throttler.intervalMillis - timeSinceLastRun | 0);

package/src/Throttler.resi

@@ -15,7 +15,7 @@ Does NOT queue scheduled functions but rather overwrites them
 The logger will be used to log any errors that occur in the scheduled
 functions.
 */
-let make: (~intervalMillis: int, ~logger: Logger.t) => t
+let make: (~intervalMillis: int, ~logger: Logger.t, ~clock: Clock.t=?) => t
 
 /**
 Schedules a function to be run on a throttler, overwriting any