envio 3.15.0 → 3.16.0

package/src/IndexerState.res

@@ -108,6 +108,12 @@ type t = {
   // in-process test runner injects a callback that resolves its run promise
   // instead, so a caught-up run doesn't kill the test process.
   onExit: option<unit => unit>,
+  // Told, in the processing pass that gets it there, that a run holding its
+  // realtime transitions has gone as far as it can on its own. The test
+  // runner's stand-in supervisor releases from it, so the release lands at a
+  // point in the indexer's own progress rather than on a timer.
+  onArrivedAtHead: option<unit => unit>,
+  mutable reportedArrivalAtHead: bool,
   // Set once on any fatal error. Every loop checks it to stop iterating and
   // every launch skips when it's set, so a single failure quiesces the indexer.
   mutable isStopped: bool,
@@ -157,10 +163,13 @@ let make = (
   ~exitAfterFirstEventBlock=false,
   ~onError: ErrorHandling.t => unit,
   ~onExit=?,
+  ~onArrivedAtHead=?,
+  ~clock=Clock.real,
 ) => {
   let chainMetaThrottler = {
     let intervalMillis = Env.ThrottleWrites.chainMetadataIntervalMillis
     Throttler.make(
+      ~clock,
       ~intervalMillis,
       ~logger=logger->Logger.withFields({
         "context": "Throttler for chain metadata writes",
@@ -175,7 +184,7 @@ let make = (
     persistence,
     allEntities: persistence.allEntities,
     entities: EntityTables.make(persistence.allEntities->EntityTables.crossChain),
-    effectState: EffectState.make(),
+    effectState: EffectState.make(~clock, ()),
     rollback: None,
     committedFrontier,
     processedFrontier: committedFrontier->Frontier.copy,
@@ -205,6 +214,8 @@ let make = (
     exitAfterFirstEventBlock,
     onError,
     onExit,
+    onArrivedAtHead,
+    reportedArrivalAtHead: false,
     isStopped: false,
     epoch: 0,
     simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config),
@@ -225,12 +236,13 @@ let make = (
 }
 
 // Check if progress is past the reorg threshold (safe block).
-// A chain is in reorg threshold when progressBlockNumber > sourceBlockNumber - maxReorgDepth.
-// This matches the logic in InternalTable.Checkpoints.makeGetReorgCheckpointsQuery.
+// A chain is in reorg threshold once its progress passes the safe block,
+// sourceBlockNumber - maxReorgDepth - 1. This matches the reorg checkpoints
+// query in packages/cli/src/postgres/internal.rs.
 let isProgressInReorgThreshold = (~progressBlockNumber, ~sourceBlockNumber, ~maxReorgDepth) => {
   maxReorgDepth > 0 &&
   sourceBlockNumber > 0 &&
-  progressBlockNumber > sourceBlockNumber - maxReorgDepth
+  progressBlockNumber > sourceBlockNumber - maxReorgDepth - 1
 }
 
 let makeFromDbState = (
@@ -249,6 +261,7 @@ let makeFromDbState = (
   ~holdRealtime=false,
   ~onError,
   ~onExit=?,
+  ~onArrivedAtHead=?,
 ) => {
   let isInReorgThreshold = if initialState.cleanRun {
     false
@@ -303,6 +316,8 @@ let makeFromDbState = (
     ~exitAfterFirstEventBlock,
     ~onError,
     ~onExit?,
+    ~onArrivedAtHead?,
+    ~clock=?sourceTiming->Option.flatMap(timing => timing.clock),
   )
   state.crossChainState->CrossChainState.markCaughtUpOnResume
   initialState.cache->Utils.Dict.forEach(({effectName, count, scope}) => {
@@ -559,6 +574,15 @@ let isHoldingRealtime = (state: t) => state.crossChainState->CrossChainState.isH
 
 let hasArrivedAtHead = (state: t) => state.crossChainState->CrossChainState.hasArrivedAtHead
 
+let reportArrivalAtHead = (state: t) =>
+  switch state.onArrivedAtHead {
+  | Some(onArrivedAtHead)
+    if !state.reportedArrivalAtHead && state->isHoldingRealtime && state->hasArrivedAtHead =>
+    state.reportedArrivalAtHead = true
+    onArrivedAtHead()
+  | _ => ()
+  }
+
 let releaseRealtime = (state: t) => {
   state.crossChainState->CrossChainState.releaseRealtime
   // Every chain is parked at the head with no batch coming, so nothing would

package/src/IndexerState.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Env from "./Env.res.mjs";
 import * as Batch from "./Batch.res.mjs";
+import * as Clock from "./Clock.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logger from "./Logger.res.mjs";
@@ -26,25 +27,26 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
-function make(config, logger, persistence, chainStates, isRealtime, targetBufferSizeOpt, holdRealtimeOpt, committedFrontierOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit) {
+function make(config, logger, persistence, chainStates, isRealtime, targetBufferSizeOpt, holdRealtimeOpt, committedFrontierOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit, onArrivedAtHead, clockOpt) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : CrossChainState.calculateTargetBufferSize();
   let holdRealtime = holdRealtimeOpt !== undefined ? holdRealtimeOpt : false;
   let committedFrontier = committedFrontierOpt !== undefined ? committedFrontierOpt : Frontier.empty();
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
+  let clock = clockOpt !== undefined ? clockOpt : Clock.real;
   let intervalMillis = Env.ThrottleWrites.chainMetadataIntervalMillis;
   let chainMetaThrottler = Throttler.make(intervalMillis, Logger.withFields(logger, {
     context: "Throttler for chain metadata writes",
     intervalMillis: intervalMillis
-  }));
+  }), clock);
   return {
     config: config,
     logger: logger,
     persistence: persistence,
     allEntities: persistence.allEntities,
     entities: EntityTables.make(EntityTables.crossChain(persistence.allEntities)),
-    effectState: EffectState.make(),
+    effectState: EffectState.make(clock, undefined),
     rollback: undefined,
     committedFrontier: committedFrontier,
     processedFrontier: Frontier.copy(committedFrontier),
@@ -68,6 +70,8 @@ function make(config, logger, persistence, chainStates, isRealtime, targetBuffer
     exitAfterFirstEventBlock: exitAfterFirstEventBlock,
     onError: onError,
     onExit: onExit,
+    onArrivedAtHead: onArrivedAtHead,
+    reportedArrivalAtHead: false,
     isStopped: false,
     epoch: 0,
     scheduleProcessing: () => {},
@@ -88,7 +92,7 @@ function make(config, logger, persistence, chainStates, isRealtime, targetBuffer
   };
 }
 
-function makeFromDbState(config, logger, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, sourceTiming, targetBufferSizeOpt, holdRealtimeOpt, onError, onExit) {
+function makeFromDbState(config, logger, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, sourceTiming, targetBufferSizeOpt, holdRealtimeOpt, onError, onExit, onArrivedAtHead) {
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
@@ -99,7 +103,7 @@ function makeFromDbState(config, logger, persistence, initialState, registration
       let sourceBlockNumber = resumedChainState.sourceBlockNumber;
       let maxReorgDepth = resumedChainState.maxReorgDepth;
       if (maxReorgDepth > 0 && sourceBlockNumber > 0) {
-        return progressBlockNumber > (sourceBlockNumber - maxReorgDepth | 0);
+        return progressBlockNumber > ((sourceBlockNumber - maxReorgDepth | 0) - 1 | 0);
       } else {
         return false;
       }
@@ -111,7 +115,7 @@ function makeFromDbState(config, logger, persistence, initialState, registration
     let chainConfig = ChainMap.get(config.chainMap, chainId);
     chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, initialState.contractMapping, registrationsByChainId, logger, sourceTiming);
   });
-  let state = make(config, logger, persistence, chainStates, isRealtime, targetBufferSize, holdRealtime, initialState.checkpointFrontier, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit);
+  let state = make(config, logger, persistence, chainStates, isRealtime, targetBufferSize, holdRealtime, initialState.checkpointFrontier, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit, onArrivedAtHead, Stdlib_Option.flatMap(sourceTiming, timing => timing.clock));
   CrossChainState.markCaughtUpOnResume(state.crossChainState);
   Utils.Dict.forEach(initialState.cache, param => {
     let count = param.count;
@@ -401,6 +405,14 @@ function hasArrivedAtHead(state) {
   return CrossChainState.hasArrivedAtHead(state.crossChainState);
 }
 
+function reportArrivalAtHead(state) {
+  let onArrivedAtHead = state.onArrivedAtHead;
+  if (onArrivedAtHead !== undefined && !state.reportedArrivalAtHead && CrossChainState.isHoldingRealtime(state.crossChainState) && CrossChainState.hasArrivedAtHead(state.crossChainState)) {
+    state.reportedArrivalAtHead = true;
+    return onArrivedAtHead();
+  }
+}
+
 function releaseRealtime(state) {
   CrossChainState.releaseRealtime(state.crossChainState);
   state.scheduleProcessing();
@@ -917,6 +929,7 @@ export {
   bindScheduleProcessing,
   isHoldingRealtime,
   hasArrivedAtHead,
+  reportArrivalAtHead,
   releaseRealtime,
   markReady,
   reportFinished,

package/src/IndexerState.resi

@@ -24,6 +24,8 @@ let make: (
   ~exitAfterFirstEventBlock: bool=?,
   ~onError: ErrorHandling.t => unit,
   ~onExit: unit => unit=?,
+  ~onArrivedAtHead: unit => unit=?,
+  ~clock: Clock.t=?,
 ) => t
 
 let makeFromDbState: (
@@ -40,6 +42,7 @@ let makeFromDbState: (
   ~holdRealtime: bool=?,
   ~onError: ErrorHandling.t => unit,
   ~onExit: unit => unit=?,
+  ~onArrivedAtHead: unit => unit=?,
 ) => t
 
 let unexpectedErrorMsg: string
@@ -106,6 +109,7 @@ let shouldFinalizeIndexes: t => bool
 let bindScheduleProcessing: (t, unit => unit) => unit
 let isHoldingRealtime: t => bool
 let hasArrivedAtHead: t => bool
+let reportArrivalAtHead: t => unit
 // The supervisor's go-ahead for a process driving part of a split run.
 let releaseRealtime: t => unit
 let markReady: (t, ~readyAt: Date.t) => unit

package/src/Internal.res

@@ -950,55 +950,6 @@ module EffectCache = {
     | CrossChain => cacheTablePrefix ++ effectName
     | Chain(chainId) => `envio_${chainId->ChainId.toString}_effect_${effectName}`
     }
-
-  // Only accepts a canonical decimal chain id ("7", not "007" or "1foo") —
-  // the schema's parser follows parseFloat semantics and accepts both.
-  let parseChainId = str =>
-    switch try Some(str->ChainId.normalizeOrThrow) catch {
-    | _ => None
-    } {
-    | Some(chainId) if chainId->ChainId.toString === str => Some(chainId)
-    | _ => None
-    }
-
-  let chainScopedRe = /^envio_([0-9]+)_effect_(.+)$/
-  let crossChainRe = /^envio_effect_(.+)$/
-
-  // Inverse of toTableName. Returns None for any table name that isn't a cache
-  // table. Chain-scoped is tried first: the `_effect_` separator keeps effect
-  // names that themselves start with digits unambiguous.
-  let fromTableName = (tableName): option<(string, chainScope)> =>
-    switch RegExp.exec(chainScopedRe, tableName) {
-    | Some(result) =>
-      switch (
-        RegExp.Result.matches(result)->Array.get(0),
-        RegExp.Result.matches(result)->Array.get(1),
-      ) {
-      | (Some(Some(chainIdStr)), Some(Some(effectName))) =>
-        switch parseChainId(chainIdStr) {
-        | Some(chainId) => Some((effectName, Chain(chainId)))
-        | None => None
-        }
-      | _ => None
-      }
-    | None =>
-      switch RegExp.exec(crossChainRe, tableName) {
-      | Some(result) =>
-        switch RegExp.Result.matches(result)->Array.get(0) {
-        | Some(Some(effectName)) => Some((effectName, CrossChain))
-        | _ => None
-        }
-      | None => None
-      }
-    }
-
-  // Relative posix path within .envio/cache. Chain-scoped caches live one
-  // directory level deep, named by chain id.
-  let toCachePath = (~effectName, ~scope) =>
-    switch scope {
-    | CrossChain => effectName ++ ".tsv"
-    | Chain(chainId) => `${chainId->ChainId.toString}/${effectName}.tsv`
-    }
 }
 
 let cacheOutputSchema = S.json(~validate=false)->(Utils.magic: S.t<JSON.t> => S.t<effectOutput>)

package/src/Internal.res.mjs

@@ -240,87 +240,8 @@ function toTableName(effectName, scope) {
   }
 }
 
-function parseChainId(str) {
-  let chainId;
-  try {
-    chainId = Primitive_option.some(ChainId.normalizeOrThrow(str));
-  } catch (exn) {
-    chainId = undefined;
-  }
-  if (chainId === undefined) {
-    return;
-  }
-  let chainId$1 = Primitive_option.valFromOption(chainId);
-  if (ChainId.toString(chainId$1) === str) {
-    return Primitive_option.some(chainId$1);
-  }
-}
-
-let chainScopedRe = /^envio_([0-9]+)_effect_(.+)$/;
-
-let crossChainRe = /^envio_effect_(.+)$/;
-
-function fromTableName(tableName) {
-  let result = chainScopedRe.exec(tableName);
-  if (result == null) {
-    let result$1 = crossChainRe.exec(tableName);
-    if (result$1 == null) {
-      return;
-    }
-    let match = result$1.slice(1)[0];
-    if (match === undefined) {
-      return;
-    }
-    let effectName = Primitive_option.valFromOption(match);
-    if (effectName !== undefined) {
-      return [
-        effectName,
-        "crossChain"
-      ];
-    } else {
-      return;
-    }
-  }
-  let match$1 = result.slice(1)[0];
-  let match$2 = result.slice(1)[1];
-  if (match$1 === undefined) {
-    return;
-  }
-  let chainIdStr = Primitive_option.valFromOption(match$1);
-  if (chainIdStr === undefined) {
-    return;
-  }
-  if (match$2 === undefined) {
-    return;
-  }
-  let effectName$1 = Primitive_option.valFromOption(match$2);
-  if (effectName$1 === undefined) {
-    return;
-  }
-  let chainId = parseChainId(chainIdStr);
-  if (chainId !== undefined) {
-    return [
-      effectName$1,
-      Primitive_option.valFromOption(chainId)
-    ];
-  }
-}
-
-function toCachePath(effectName, scope) {
-  if (scope === "crossChain") {
-    return effectName + ".tsv";
-  } else {
-    return ChainId.toString(scope) + `/` + effectName + `.tsv`;
-  }
-}
-
 let EffectCache = {
-  toTableName: toTableName,
-  parseChainId: parseChainId,
-  chainScopedRe: chainScopedRe,
-  crossChainRe: crossChainRe,
-  fromTableName: fromTableName,
-  toCachePath: toCachePath
+  toTableName: toTableName
 };
 
 let cacheOutputSchema = S$RescriptSchema.json(false);

package/src/LoadLayer.res

@@ -16,7 +16,12 @@ let loadById = (
   ~entityId,
 ) => {
   let inMemTable = indexerState->InMemoryStore.getInMemTable(~entityConfig, ~scope)
-  switch inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(entityId) {
+  // The ids here are typed as strings but hold whatever scalar the id is.
+  let entityIdToKey =
+    inMemTable.entityIdToKey->(Utils.magic: (EntityId.t => string) => string => string)
+  switch inMemTable.latestEntityChangeById->Utils.Dict.dangerouslyGetNonOption(
+    entityIdToKey(entityId),
+  ) {
   // A row already in memory is final, so even a grouped call skips the load
   // manager: grouping it would only resolve it a tick later to the same value.
   | Some(change) => Promise.resolve(change->InMemoryTable.Entity.mapChangeToEntity)
@@ -53,14 +58,14 @@ let loadById = (
       //Set the entity in the in memory store
       for idx in 0 to dbEntities->Array.length - 1 {
         let entity = dbEntities->Array.getUnsafe(idx)
-        entitiesMap->Dict.set(entity.id, entity)
+        entitiesMap->Dict.set(entityIdToKey(entity.id), entity)
       }
       let committedCheckpointId = indexerState->IndexerState.committedCheckpointIdFor(~scope)
       idsToLoad->Array.forEach(entityId => {
         inMemTable->InMemoryTable.Entity.initValue(
           ~committedCheckpointId,
-          ~key=entityId,
-          ~entity=entitiesMap->Utils.Dict.dangerouslyGetNonOption(entityId),
+          ~entityId=entityId->EntityId.unsafeOfString,
+          ~entity=entitiesMap->Utils.Dict.dangerouslyGetNonOption(entityIdToKey(entityId)),
         )
       })
 
@@ -77,7 +82,7 @@ let loadById = (
       ~key,
       ~load,
       ~shouldGroup,
-      ~hasher=LoadManager.noopHasher,
+      ~hasher=entityIdToKey,
       ~getUnsafeInMemory=inMemTable->InMemoryTable.Entity.getUnsafe,
       ~hasInMemory=hash => inMemTable.latestEntityChangeById->Dict.has(hash),
       ~input=entityId,
@@ -140,7 +145,7 @@ let rec executeWithRateLimit = (
     }
 
   | Some(state) =>
-    let now = Date.now()
+    let now = state.clock.now()
 
     // Check if we need to reset the window
     if now >= state.windowStartTime +. state.durationMs->Int.toFloat {
@@ -188,7 +193,8 @@ let rec executeWithRateLimit = (
       | None =>
         millisUntilReset :=
           (state.windowStartTime +. state.durationMs->Int.toFloat -. now)->Float.toInt
-        let p = Utils.delay(millisUntilReset.contents)
+        let p =
+          state.clock->Clock.delay(~label="effect rate limit window", millisUntilReset.contents)
         state.nextWindowPromise = Some(p)
         p
       }
@@ -387,7 +393,7 @@ let loadByParsedFilter = (
         entities->Array.forEach(entity => {
           inMemTable->InMemoryTable.Entity.initValue(
             ~committedCheckpointId,
-            ~key=entity.id,
+            ~entityId=entity.id->EntityId.unsafeOfString,
             ~entity=Some(entity),
           )
         })

package/src/LoadLayer.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Clock from "./Clock.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Logger from "./Logger.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
@@ -27,7 +28,8 @@ function scopeKeySuffix(scope) {
 
 function loadById(loadManager, persistence, entityConfig, scope, indexerState, shouldGroup, entityId) {
   let inMemTable = InMemoryStore.getInMemTable(indexerState, entityConfig, scope);
-  let change = inMemTable.latestEntityChangeById[entityId];
+  let entityIdToKey = inMemTable.entityIdToKey;
+  let change = inMemTable.latestEntityChangeById[entityIdToKey(entityId)];
   if (change !== undefined) {
     return Promise.resolve(InMemoryTable.Entity.mapChangeToEntity(change));
   }
@@ -50,13 +52,13 @@ function loadById(loadManager, persistence, entityConfig, scope, indexerState, s
     let entitiesMap = {};
     for (let idx = 0, idx_finish = dbEntities.length; idx < idx_finish; ++idx) {
       let entity = dbEntities[idx];
-      entitiesMap[entity.id] = entity;
+      entitiesMap[entityIdToKey(entity.id)] = entity;
     }
     let committedCheckpointId = IndexerState.committedCheckpointIdFor(indexerState, scope);
-    idsToLoad.forEach(entityId => InMemoryTable.Entity.initValue(inMemTable, committedCheckpointId, entityId, entitiesMap[entityId]));
+    idsToLoad.forEach(entityId => InMemoryTable.Entity.initValue(inMemTable, committedCheckpointId, entityId, entitiesMap[entityIdToKey(entityId)]));
     return IndexerState.endStorageLoad(indexerState, timerRef, storageName, key, idsToLoad.length, dbEntities.length);
   };
-  return LoadManager.call(loadManager, entityId, key, load, LoadManager.noopHasher, shouldGroup, hash => hash in inMemTable.latestEntityChangeById, InMemoryTable.Entity.getUnsafe(inMemTable));
+  return LoadManager.call(loadManager, entityId, key, load, entityIdToKey, shouldGroup, hash => hash in inMemTable.latestEntityChangeById, InMemoryTable.Entity.getUnsafe(inMemTable));
 }
 
 function callEffect(effect, arg, inMemTable, timerRef, onError) {
@@ -69,7 +71,7 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
   let promises = [];
   let state = inMemTable.rateLimitState;
   if (state !== undefined) {
-    let now = Date.now();
+    let now = state.clock.now();
     if (now >= state.windowStartTime + state.durationMs) {
       state.availableCalls = state.callsPerDuration;
       state.windowStartTime = now;
@@ -98,7 +100,7 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
         nextWindowPromise = p;
       } else {
         millisUntilReset.contents = state.windowStartTime + state.durationMs - now | 0;
-        let p$1 = Utils.delay(millisUntilReset.contents);
+        let p$1 = Clock.delay(state.clock, "effect rate limit window", millisUntilReset.contents);
         state.nextWindowPromise = p$1;
         nextWindowPromise = p$1;
       }

package/src/Main.res.mjs

@@ -413,7 +413,7 @@ async function startIndexer(config, logger, persistence, resetOpt, isTestOpt, ex
     Metrics.startRuntimeCollectors();
     Server.startServer(logger, getMetrics, envioVersion, () => Persistence.getInitializedStorageOrThrow(persistence$1).dumpEffectCache().then(prim => {}), Metrics.collectRuntime, isDevelopmentMode);
   }
-  let state = IndexerState.makeFromDbState(config$2, logger, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, Stdlib_Option.mapOr(Worker.config, false, worker => worker.holdRealtime), onError, undefined);
+  let state = IndexerState.makeFromDbState(config$2, logger, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, Stdlib_Option.mapOr(Worker.config, false, worker => worker.holdRealtime), onError, undefined, undefined);
   if (shouldUseTui) {
     Tui.start(config$2, logger, () => IndexerState.toMetrics(state));
   }

package/src/Persistence.res

@@ -117,8 +117,6 @@ type storage = {
   // carries a matching row — storage doesn't interpret it.
   initialize: (
     ~chainConfigs: array<Config.chain>=?,
-    ~entities: array<Internal.entityConfig>=?,
-    ~enums: array<Table.enumConfig<Table.enum>>=?,
     ~contractMapping: ContractMapping.t,
     ~envioInfo: JSON.t,
   ) => promise<initialState>,
@@ -129,16 +127,11 @@ type storage = {
   // Brings an initialized storage a chain it doesn't have yet: its row, its
   // partitions and its config addresses, as `initialize` would have created
   // them. The chains already there are left untouched.
-  addChain: (
-    ~chainConfig: Config.chain,
-    ~entities: array<Internal.entityConfig>,
-    ~contractMapping: ContractMapping.t,
-  ) => promise<unit>,
+  addChain: (~chainConfig: Config.chain, ~contractMapping: ContractMapping.t) => promise<unit>,
   // `chainIds` is what this run drives. An isolated run resumes a subset of
   // the stored chains, and ClickHouse's resume trims past each resumed chain's
   // checkpoint, so chains a sibling process is still writing must stay out.
   resumeInitialState: (
-    ~entities: array<Internal.entityConfig>,
     ~chainIds: array<ChainId.t>,
     ~contractMapping: ContractMapping.t,
   ) => promise<initialState>,
@@ -159,19 +152,12 @@ type storage = {
   // never runs `finalizeBackfill`: an index dropped or invalidated while it was
   // down would otherwise never be rebuilt. Best-effort, and safe to run with
   // indexing live.
-  ensureSchemaIndexes: (
-    ~entities: array<Internal.entityConfig>,
-    ~chainIds: array<ChainId.t>,
-  ) => promise<unit>,
+  ensureSchemaIndexes: (~chainIds: array<ChainId.t>) => promise<unit>,
   // Creates every index the schema promises for the given chains, then stamps
   // `ready_at` on them. Called once those chains finish backfill. The indexes
   // are committed one at a time so a failure part way through doesn't undo the
   // ones already built; `ready_at` is only written once they all verify.
-  finalizeBackfill: (
-    ~entities: array<Internal.entityConfig>,
-    ~chainIds: array<ChainId.t>,
-    ~readyAt: Date.t,
-  ) => promise<unit>,
+  finalizeBackfill: (~chainIds: array<ChainId.t>, ~readyAt: Date.t) => promise<unit>,
   // This is to download cache from the database to .envio/cache
   dumpEffectCache: unit => promise<unit>,
   reset: unit => promise<unit>,
@@ -190,7 +176,6 @@ type storage = {
   getRollbackTargetCheckpoint: (
     ~reorgChainId: ChainId.t,
     ~lastKnownValidBlockNumber: int,
-    ~sequence: CheckpointSequence.t,
   ) => promise<option<Internal.checkpointId>>,
   // Get rollback progress diff
   getRollbackProgressDiff: (
@@ -214,7 +199,6 @@ type storage = {
     ~batch: Batch.t,
     ~rollback: option<rollback>,
     ~config: Config.t,
-    ~allEntities: array<Internal.entityConfig>,
     ~updatedEffectsCache: array<updatedEffectCache>,
     ~updatedEntities: array<updatedEntity>,
     // Addresses this batch registered, with the checkpoint that covers them.
@@ -339,8 +323,6 @@ let init = {
             throw(Refused(Config.setUpMeanwhileMessage))
           }
           let initialState = await persistence.storage.initialize(
-            ~entities=persistence.allEntities,
-            ~enums=persistence.allEnums,
             ~chainConfigs,
             ~contractMapping,
             ~envioInfo,
@@ -397,13 +379,11 @@ let init = {
               )->Array.getUnsafe(0)
             await persistence.storage.addChain(
               ~chainConfig,
-              ~entities=persistence.allEntities,
               ~contractMapping=stored.contractMapping,
             )
           }
           if resume {
             let initialState = await persistence.storage.resumeInitialState(
-              ~entities=persistence.allEntities,
               ~chainIds=chainConfigs->Array.map(chain => chain.id),
               ~contractMapping=stored.contractMapping,
             )

package/src/Persistence.res.mjs

@@ -94,7 +94,7 @@ async function init(persistence, logger, chainConfigs, contractMapping, envioInf
           Error: new Error()
         };
       }
-      let initialState = await persistence.storage.initialize(chainConfigs$1, persistence.allEntities, persistence.allEnums, contractMapping, envioInfo);
+      let initialState = await persistence.storage.initialize(chainConfigs$1, contractMapping, envioInfo);
       Logger.info(logger, `The indexer storage is ready. Starting indexing!`, undefined);
       persistence.storageStatus = {
         TAG: "Ready",
@@ -136,11 +136,11 @@ async function init(persistence, logger, chainConfigs, contractMapping, envioInf
               chainId: chainConfig.id
             });
             let chainConfig$1 = (await StartBlockResolver.resolveAllOrThrow([chainConfig], logger, lowercaseAddresses, startBlockRetry, sourceTiming))[0];
-            await persistence.storage.addChain(chainConfig$1, persistence.allEntities, stored.contractMapping);
+            await persistence.storage.addChain(chainConfig$1, stored.contractMapping);
           }
         }
         if (resume) {
-          let initialState$1 = await persistence.storage.resumeInitialState(persistence.allEntities, chainConfigs.map(chain => chain.id), stored.contractMapping);
+          let initialState$1 = await persistence.storage.resumeInitialState(chainConfigs.map(chain => chain.id), stored.contractMapping);
           persistence.storageStatus = {
             TAG: "Ready",
             _0: initialState$1

package/src/Rollback.res

@@ -130,7 +130,6 @@ and executeRollback = async (
     switch await (state->IndexerState.persistence).storage.getRollbackTargetCheckpoint(
       ~reorgChainId=reorgChain,
       ~lastKnownValidBlockNumber=rollbackTargetBlockNumber,
-      ~sequence=(state->IndexerState.config).checkpointSequence,
     ) {
     | Some(checkpointId) => checkpointId
     | None => 0n

package/src/Rollback.res.mjs

@@ -42,7 +42,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
   Logger.info(logger, "Started rollback on reorg", undefined);
   ChainState.setRollbackTargetBlock(IndexerState.getChainState(state, reorgChain), rollbackTargetBlockNumber);
   await Writing.flush(state);
-  let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber, IndexerState.config(state).checkpointSequence);
+  let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber);
   let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
   let config = IndexerState.config(state);
   let next = RollbackFloors.make(config.checkpointSequence, ChainMap.keys(config.chainMap), reorgChain, rollbackTargetCheckpointId, rollbackTargetBlockNumber);

package/src/SafeCheckpointTracking.res

@@ -16,9 +16,7 @@ let make = (
 ) => {
   if maxReorgDepth > 0 && shouldRollbackOnReorg {
     let checkpointIds = Utils.Array.jsArrayCreate(chainReorgCheckpoints->Array.length)
-    let checkpointBlockNumbers = Utils.Array.jsArrayCreate(
-      chainReorgCheckpoints->Array.length,
-    )
+    let checkpointBlockNumbers = Utils.Array.jsArrayCreate(chainReorgCheckpoints->Array.length)
     chainReorgCheckpoints->Array.forEachWithIndex((checkpoint, idx) => {
       checkpointIds->Array.setUnsafe(idx, checkpoint.checkpointId)
       checkpointBlockNumbers->Array.setUnsafe(idx, checkpoint.blockNumber)
@@ -36,7 +34,9 @@ let make = (
 let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int): option<
   Internal.checkpointId,
 > => {
-  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth
+  // The first block reorg detection compares is itself reorgable, so the safe
+  // block is the one below it.
+  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth - 1
 
   switch safeCheckpointTracking.checkpointIds {
   | [] => None

package/src/SafeCheckpointTracking.res.mjs

@@ -20,7 +20,7 @@ function make(maxReorgDepth, shouldRollbackOnReorg, chainReorgCheckpoints) {
 }
 
 function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
-  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0;
+  let safeBlockNumber = (sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0) - 1 | 0;
   let match = safeCheckpointTracking.checkpointIds;
   if (match.length === 0) {
     return;