envio 3.9.0 → 3.10.0-subgraph

package/src/IndexerState.res

@@ -355,7 +355,10 @@ let getChainState = (state: t, ~chainId: ChainId.t): ChainState.t =>
     )
   }
 
-let getSafeCheckpointId = (state: t) => state.crossChainState->CrossChainState.getSafeCheckpointId
+let getSafeCheckpointIdByChain = (state: t) =>
+  state.crossChainState->CrossChainState.getSafeCheckpointIdByChain(
+    ~committedCheckpointId=state.committedCheckpointId,
+  )
 
 let createBatch = (
   state: t,
@@ -452,7 +455,14 @@ let entities = (state: t) => state.entities
 // Every in-memory entity table across all scopes, cross-chain first. The size,
 // drop and flush passes walk the whole store this way instead of assuming a
 // single partition.
-let eachEntityTable = (state: t, fn: (~entityConfig: Internal.entityConfig, ~scope: Internal.chainScope, ~table: InMemoryTable.Entity.t) => unit) => {
+let eachEntityTable = (
+  state: t,
+  fn: (
+    ~entityConfig: Internal.entityConfig,
+    ~scope: Internal.chainScope,
+    ~table: InMemoryTable.Entity.t,
+  ) => unit,
+) => {
   let chainStates = state.crossChainState->CrossChainState.chainStates
   state.allEntities->Array.forEach(entityConfig =>
     if entityConfig.crossChain {
@@ -516,6 +526,7 @@ let toMetrics = (state: t): Metrics.t => {
   let chainStates = state.crossChainState->CrossChainState.chainStates
   let sourceRequests = []
   let sourceHeights = []
+  let sourceHeightStreams = []
   chainStates->Utils.Dict.forEach(cs => {
     let sourceManager = cs->ChainState.sourceManager
     sourceManager
@@ -538,6 +549,16 @@ let toMetrics = (state: t): Metrics.t => {
         height: s.height,
       })
     )
+    sourceManager
+    ->SourceManager.getHeightStreamSamples
+    ->Array.forEach(s =>
+      sourceHeightStreams->Array.push({
+        Metrics.source: s.sourceName,
+        chainId: s.chainId,
+        connectCount: s.stream.connectCount,
+        disconnectsByReason: s.stream.disconnectsByReason,
+      })
+    )
   })
   let historyPrunes = []
   state.historyPruneStats->Utils.Dict.forEachWithKey((s, entityName) =>
@@ -600,6 +621,7 @@ let toMetrics = (state: t): Metrics.t => {
     historyPrunes,
     sourceRequests,
     sourceHeights,
+    sourceHeightStreams,
   }
 }
 
@@ -793,6 +815,8 @@ let drainBatchRun = (state: t): Batch.t => {
   }
 }
 
+let pendingRollback = (state: t): option<Persistence.rollback> => state.rollback
+
 // Take the pending rollback diff to write, clearing it from the store.
 let takeRollback = (state: t): option<Persistence.rollback> => {
   let rollback = state.rollback
@@ -812,9 +836,9 @@ let markCommitted = (state: t, ~upToCheckpointId) => {
 // Reset the in-memory tables and arm the rollback diff that the next write commits.
 let beginRollbackDiff = (
   state: t,
-  ~targetCheckpointId,
   ~diffCheckpointId,
-  ~progressBlockNumberByChainId,
+  ~floors,
+  ~progressedChains: array<InternalTable.Chains.progressedChain>,
   ~rolledBackAddresses,
 ) => {
   let perChainEntities = state.allEntities->EntityTables.perChain
@@ -829,10 +853,23 @@ let beginRollbackDiff = (
   | Some({rolledBackAddresses: pending}) => pending->Array.concat(rolledBackAddresses)
   | None => rolledBackAddresses
   }
+  // Same for the chains: this rollback recomputes progress from the checkpoints,
+  // so a chain the pending diff already moved can land on exactly the block it
+  // is now at and go unreported here. Its stored progress still needs
+  // correcting, so the pending rows carry over — this rollback's row for a
+  // chain wins, being the later reading of the same chain state.
+  let progressedChains = switch state.rollback {
+  | Some({progressedChains: pending}) =>
+    let byChainId = Dict.make()
+    pending->Array.forEach(chain => byChainId->ChainId.Dict.set(chain.chainId, chain))
+    progressedChains->Array.forEach(chain => byChainId->ChainId.Dict.set(chain.chainId, chain))
+    byChainId->Dict.valuesToArray
+  | None => progressedChains
+  }
   state.rollback = Some({
-    targetCheckpointId,
     diffCheckpointId,
-    progressBlockNumberByChainId,
+    floors,
+    progressedChains,
     rolledBackAddresses,
   })
 }

package/src/IndexerState.res.mjs

@@ -159,8 +159,8 @@ function getChainState(state, chainId) {
   }
 }
 
-function getSafeCheckpointId(state) {
-  return CrossChainState.getSafeCheckpointId(state.crossChainState);
+function getSafeCheckpointIdByChain(state) {
+  return CrossChainState.getSafeCheckpointIdByChain(state.crossChainState, state.committedCheckpointId);
 }
 
 function createBatch(state, processedCheckpointId, batchSizeTarget, isRollback) {
@@ -392,6 +392,7 @@ function toMetrics(state) {
   let chainStates = CrossChainState.chainStates(state.crossChainState);
   let sourceRequests = [];
   let sourceHeights = [];
+  let sourceHeightStreams = [];
   Utils.Dict.forEach(chainStates, cs => {
     let sourceManager = ChainState.sourceManager(cs);
     SourceManager.getRequestStatSamples(sourceManager).forEach(s => {
@@ -410,6 +411,14 @@ function toMetrics(state) {
         height: s.height
       });
     });
+    SourceManager.getHeightStreamSamples(sourceManager).forEach(s => {
+      sourceHeightStreams.push({
+        source: s.sourceName,
+        chainId: s.chainId,
+        connectCount: s.stream.connectCount,
+        disconnectsByReason: s.stream.disconnectsByReason
+      });
+    });
   });
   let historyPrunes = [];
   Utils.Dict.forEachWithKey(state.historyPruneStats, (s, entityName) => {
@@ -464,7 +473,8 @@ function toMetrics(state) {
     })),
     historyPrunes: historyPrunes,
     sourceRequests: sourceRequests,
-    sourceHeights: sourceHeights
+    sourceHeights: sourceHeights,
+    sourceHeightStreams: sourceHeightStreams
   };
 }
 
@@ -658,6 +668,10 @@ function drainBatchRun(state) {
   };
 }
 
+function pendingRollback(state) {
+  return state.rollback;
+}
+
 function takeRollback(state) {
   let rollback = state.rollback;
   state.rollback = undefined;
@@ -668,18 +682,32 @@ function markCommitted(state, upToCheckpointId) {
   state.committedCheckpointId = upToCheckpointId;
 }
 
-function beginRollbackDiff(state, targetCheckpointId, diffCheckpointId, progressBlockNumberByChainId, rolledBackAddresses) {
+function beginRollbackDiff(state, diffCheckpointId, floors, progressedChains, rolledBackAddresses) {
   let perChainEntities = EntityTables.perChain(state.allEntities);
   state.entities = EntityTables.make(EntityTables.crossChain(state.allEntities));
   Utils.Dict.forEach(CrossChainState.chainStates(state.crossChainState), cs => ChainState.resetEntities(cs, perChainEntities));
   EffectState.resetForRollback(state.effectState);
   let match = state.rollback;
   let rolledBackAddresses$1 = match !== undefined ? match.rolledBackAddresses.concat(rolledBackAddresses) : rolledBackAddresses;
+  let match$1 = state.rollback;
+  let progressedChains$1;
+  if (match$1 !== undefined) {
+    let byChainId = {};
+    match$1.progressedChains.forEach(chain => {
+      byChainId[chain.chainId] = chain;
+    });
+    progressedChains.forEach(chain => {
+      byChainId[chain.chainId] = chain;
+    });
+    progressedChains$1 = Object.values(byChainId);
+  } else {
+    progressedChains$1 = progressedChains;
+  }
   state.rollback = {
-    targetCheckpointId: targetCheckpointId,
     diffCheckpointId: diffCheckpointId,
+    floors: floors,
     rolledBackAddresses: rolledBackAddresses$1,
-    progressBlockNumberByChainId: progressBlockNumberByChainId
+    progressedChains: progressedChains$1
   };
 }
 
@@ -766,7 +794,7 @@ export {
   markProcessingStalledOnFetch,
   recordProcessedBatch,
   createBatch,
-  getSafeCheckpointId,
+  getSafeCheckpointIdByChain,
   config,
   persistence,
   allEntities,
@@ -812,6 +840,7 @@ export {
   recordRollbackSuccess,
   queueProcessedBatch,
   drainBatchRun,
+  pendingRollback,
   takeRollback,
   markCommitted,
   beginRollbackDiff,

package/src/IndexerState.resi

@@ -1,7 +1,6 @@
 // The indexer state. `t` is opaque: other modules read it through the accessors
 // and change it only through the transitions and setters exposed here.
 
-
 type rollbackState =
   | NoRollback
   | ReorgDetected({chainId: ChainId.t, blockNumber: int})
@@ -67,7 +66,7 @@ let createBatch: (
   ~batchSizeTarget: int,
   ~isRollback: bool,
 ) => Batch.t
-let getSafeCheckpointId: t => option<Internal.checkpointId>
+let getSafeCheckpointIdByChain: t => array<(ChainId.t, option<Internal.checkpointId>)>
 
 // Accessors.
 let config: t => Config.t
@@ -136,13 +135,14 @@ let recordRollbackSuccess: (t, ~timeSeconds: float, ~rollbackedProcessedEvents:
 // Store domain operations.
 let queueProcessedBatch: (t, ~batch: Batch.t) => unit
 let drainBatchRun: t => Batch.t
+let pendingRollback: t => option<Persistence.rollback>
 let takeRollback: t => option<Persistence.rollback>
 let markCommitted: (t, ~upToCheckpointId: Internal.checkpointId) => unit
 let beginRollbackDiff: (
   t,
-  ~targetCheckpointId: Internal.checkpointId,
   ~diffCheckpointId: Internal.checkpointId,
-  ~progressBlockNumberByChainId: dict<int>,
+  ~floors: RollbackFloors.t,
+  ~progressedChains: array<InternalTable.Chains.progressedChain>,
   ~rolledBackAddresses: array<AddressRows.key>,
 ) => unit
 let recordWriteFailure: (t, exn) => unit

package/src/Internal.res

@@ -573,15 +573,6 @@ type svmInstructionEventConfig = {
   programId: SvmTypes.Pubkey.t,
   /** Hex-encoded discriminator. `None` matches every instruction in the program. */
   discriminator: option<string>,
-  /** Length of the discriminator in bytes (0 / 1 / 2 / 4 / 8). Drives the
-   `dN` selector at query time and the dispatch-key precomputation in the
-   router. */
-  discriminatorByteLen: int,
-  /** Disjunctive normal form: outer array is OR of AND-groups, inner array is
-   AND across positions. Empty outer array means "no account filter". */
-  accountFilters: array<svmAccountFilterGroup>,
-  /** `None` matches both outer and inner (CPI-invoked) instructions. */
-  isInner: option<bool>,
   /** Positional account names from the Borsh schema, in declared order.
    `[]` means no schema is attached for this instruction. */
   accounts: array<string>,
@@ -597,10 +588,11 @@ type svmInstructionEventConfig = {
 // Per-(event, chain) registration produced when user handler code registers an
 // event (`onEvent`) or a dynamic contract registers. References its definition
 // by value as `.eventConfig` and adds the handler binding plus the
-// registration/`where`-derived fetch state. Not `private`: Fuel/SVM
-// registrations add no ecosystem-specific fields (so they're bare aliases that
-// must stay directly constructable), and the evm→base cast in sources is sound
-// by ecosystem homogeneity — an EVM chain only ever holds `evmOnEventRegistration`s.
+// registration/`where`-derived fetch state. Not `private`: Fuel registrations
+// add no ecosystem-specific fields (so the alias must stay directly
+// constructable), and the ecosystem→base casts in sources are sound by
+// ecosystem homogeneity — an EVM chain only ever holds
+// `evmOnEventRegistration`s.
 type onEventRegistration = {
   // Chain-scoped sequential index — the registration's position in the
   // chain's onEventRegistrations array, assigned when registration finishes
@@ -639,11 +631,18 @@ type evmOnEventRegistration = {
   resolvedWhere: resolvedWhere,
 }
 
-// Fuel and SVM registrations add no ecosystem-specific fetch state (their
-// filters are config-derived and live on the definition), so they're bare
-// aliases of the base registration.
+// Fuel registrations add no ecosystem-specific fetch state, so it's a bare
+// alias of the base registration.
 type fuelOnEventRegistration = onEventRegistration
-type svmOnEventRegistration = onEventRegistration
+
+type svmOnEventRegistration = {
+  ...onEventRegistration,
+  /** Disjunctive normal form: outer array is OR of AND-groups, inner array is
+   AND across positions. Empty outer array means "no account filter". */
+  accountFilters: array<svmAccountFilterGroup>,
+  /** `None` matches both outer and inner (CPI-invoked) instructions. */
+  isInner: option<bool>,
+}
 
 type svmProgramConfig = {
   name: string,

package/src/Metrics.res

@@ -98,6 +98,13 @@ type sourceHeightMetrics = {
   height: int,
 }
 
+type sourceHeightStreamMetrics = {
+  source: string,
+  chainId: ChainId.t,
+  connectCount: int,
+  disconnectsByReason: array<(string, int)>,
+}
+
 type t = {
   startTime: Date.t,
   // Wall clock when this snapshot was built, so a scrape can be dated.
@@ -124,6 +131,7 @@ type t = {
   historyPrunes: array<historyPruneMetrics>,
   sourceRequests: array<sourceRequestMetrics>,
   sourceHeights: array<sourceHeightMetrics>,
+  sourceHeightStreams: array<sourceHeightStreamMetrics>,
 }
 
 // Prometheus floats keep at most 3 decimals; integral values render without a
@@ -220,13 +228,23 @@ let renderMetrics = (b: builder, metrics: t) => {
     metrics.storageWrites->Array.map(s => (`{storage="${s.storage->escapeLabelValue}"}`, s))
   let historyPrunes =
     metrics.historyPrunes->Array.map(s => (`{entity="${s.entity->escapeLabelValue}"}`, s))
+  // Every per-source series shares this label set: a scrape whose labels
+  // disagree between two of them is one nothing can join on.
+  let sourceLabels = (~source, ~chainId, ~extra: option<(string, string)>=?) => {
+    let pair = `{source="${source->escapeLabelValue}",chainId="${chainId->ChainId.toString}"`
+    switch extra {
+    | Some((name, value)) => `${pair},${name}="${value->escapeLabelValue}"}`
+    | None => pair ++ "}"
+    }
+  }
+
   // Two sources can share a name (e.g. primary and fallback RPC urls on the
   // same host), so aggregate by label set — duplicate samples would make
   // Prometheus reject the scrape.
   let sourceRequests = {
     let byLabels: dict<sourceRequestMetrics> = Dict.make()
     metrics.sourceRequests->Array.forEach(s => {
-      let labels = `{source="${s.source->escapeLabelValue}",chainId="${s.chainId->ChainId.toString}",method="${s.method->escapeLabelValue}"}`
+      let labels = sourceLabels(~source=s.source, ~chainId=s.chainId, ~extra=("method", s.method))
       switch byLabels->Utils.Dict.dangerouslyGetNonOption(labels) {
       | Some(existing) =>
         byLabels->Dict.set(
@@ -241,7 +259,7 @@ let renderMetrics = (b: builder, metrics: t) => {
   let sources = {
     let byLabels: dict<int> = Dict.make()
     metrics.sourceHeights->Array.forEach(s => {
-      let labels = `{source="${s.source->escapeLabelValue}",chainId="${s.chainId->ChainId.toString}"}`
+      let labels = sourceLabels(~source=s.source, ~chainId=s.chainId)
       switch byLabels->Utils.Dict.dangerouslyGetNonOption(labels) {
       | Some(existing) if existing >= s.height => ()
       | _ => byLabels->Dict.set(labels, s.height)
@@ -250,6 +268,34 @@ let renderMetrics = (b: builder, metrics: t) => {
     byLabels->Dict.toArray
   }
 
+  // Zero connects is the one count worth rendering flat: it is a stream that
+  // has never come up, which the disconnects say nothing about — retries at a
+  // connection that never opened are not disconnections — and which is
+  // otherwise indistinguishable from a chain that was never configured to
+  // stream at all.
+  let heightStreamConnects = {
+    let byLabels: dict<int> = Dict.make()
+    metrics.sourceHeightStreams->Array.forEach(s =>
+      byLabels->Utils.Dict.incrementBy(
+        sourceLabels(~source=s.source, ~chainId=s.chainId),
+        s.connectCount,
+      )
+    )
+    byLabels->Dict.toArray
+  }
+  let heightStreamDisconnects = {
+    let byLabels: dict<int> = Dict.make()
+    metrics.sourceHeightStreams->Array.forEach(s =>
+      s.disconnectsByReason->Array.forEach(((reason, count)) =>
+        byLabels->Utils.Dict.incrementBy(
+          sourceLabels(~source=s.source, ~chainId=s.chainId, ~extra=("reason", reason)),
+          count,
+        )
+      )
+    )
+    byLabels->Dict.toArray
+  }
+
   b->single(
     ~name="envio_process_start_time_seconds",
     ~help="Start time of the process since unix epoch in seconds.",
@@ -463,6 +509,24 @@ let renderMetrics = (b: builder, metrics: t) => {
     ~entries=sourceRequests,
     ~value=s => s.seconds !== 0. ? Some(s.seconds) : None,
   )
+  if heightStreamConnects->Array.length > 0 {
+    b->series(
+      ~name="envio_source_height_stream_connects_total",
+      ~help="The number of times a source's height subscription connected. Compare against the disconnects total, which is absent until the first disconnect and counts as zero while it is: one more connect than disconnects means the stream is up, and equal counts mean it is down and the indexer is polling instead. Zero connects means the stream has not come up, which is the normal reading for a chain that is still backfilling: subscriptions are only opened once a chain reaches the head.",
+      ~kind="counter",
+      ~entries=heightStreamConnects,
+      ~value=count => count->Int.toFloat,
+    )
+  }
+  if heightStreamDisconnects->Array.length > 0 {
+    b->series(
+      ~name="envio_source_height_stream_disconnects_total",
+      ~help="The number of times a source's height subscription lost a connection, by reason. Failed retries are not counted, so this is outages rather than their length. A rotated disconnect is a connection that served its time; unsubscribed is the source being benched; every other reason ended a connection early.",
+      ~kind="counter",
+      ~entries=heightStreamDisconnects,
+      ~value=count => count->Int.toFloat,
+    )
+  }
   b->series(
     ~name="envio_source_known_height",
     ~help="The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.",
@@ -706,10 +770,12 @@ let renderMetrics = (b: builder, metrics: t) => {
     ~help="The number of address registrations per contract on chain, static and dynamic. An address shared by N contracts counts N times.",
     ~kind="gauge",
     ~entries=metrics.chains->Array.flatMap(m =>
-      m.addressesByContract->Array.map(((contract, count)) => (
-        `{chainId="${m.chainId->ChainId.toString}",contract="${contract->escapeLabelValue}"}`,
-        count,
-      ))
+      m.addressesByContract->Array.map(
+        ((contract, count)) => (
+          `{chainId="${m.chainId->ChainId.toString}",contract="${contract->escapeLabelValue}"}`,
+          count,
+        ),
+      )
     ),
     ~value=count => count->Int.toFloat,
   )

package/src/Metrics.res.mjs

@@ -80,9 +80,20 @@ function renderMetrics(b, metrics) {
     `{entity="` + escapeLabelValue(s.entity) + `"}`,
     s
   ]);
+  let sourceLabels = (source, chainId, extra) => {
+    let pair = `{source="` + escapeLabelValue(source) + `",chainId="` + ChainId.toString(chainId) + `"`;
+    if (extra !== undefined) {
+      return pair + `,` + extra[0] + `="` + escapeLabelValue(extra[1]) + `"}`;
+    } else {
+      return pair + "}";
+    }
+  };
   let byLabels = {};
   metrics.sourceRequests.forEach(s => {
-    let labels = `{source="` + escapeLabelValue(s.source) + `",chainId="` + ChainId.toString(s.chainId) + `",method="` + escapeLabelValue(s.method) + `"}`;
+    let labels = sourceLabels(s.source, s.chainId, [
+      "method",
+      s.method
+    ]);
     let existing = byLabels[labels];
     if (existing !== undefined) {
       byLabels[labels] = {
@@ -99,7 +110,7 @@ function renderMetrics(b, metrics) {
   let sourceRequests = Object.entries(byLabels);
   let byLabels$1 = {};
   metrics.sourceHeights.forEach(s => {
-    let labels = `{source="` + escapeLabelValue(s.source) + `",chainId="` + ChainId.toString(s.chainId) + `"}`;
+    let labels = sourceLabels(s.source, s.chainId, undefined);
     let existing = byLabels$1[labels];
     if (existing !== undefined && existing >= s.height) {
       return;
@@ -109,6 +120,17 @@ function renderMetrics(b, metrics) {
     }
   });
   let sources = Object.entries(byLabels$1);
+  let byLabels$2 = {};
+  metrics.sourceHeightStreams.forEach(s => Utils.Dict.incrementBy(byLabels$2, sourceLabels(s.source, s.chainId, undefined), s.connectCount));
+  let heightStreamConnects = Object.entries(byLabels$2);
+  let byLabels$3 = {};
+  metrics.sourceHeightStreams.forEach(s => {
+    s.disconnectsByReason.forEach(param => Utils.Dict.incrementBy(byLabels$3, sourceLabels(s.source, s.chainId, [
+      "reason",
+      param[0]
+    ]), param[1]));
+  });
+  let heightStreamDisconnects = Object.entries(byLabels$3);
   single(b, "envio_process_start_time_seconds", "Start time of the process since unix epoch in seconds.", "gauge", metrics.startTime.getTime() / 1000);
   single(b, "envio_process_metric_time_seconds", "The time these metrics were collected. Use it to tell how fresh a snapshot is, or to measure rates between two snapshots.", "gauge", metrics.metricTime.getTime() / 1000);
   single(b, "envio_process_elapsed_seconds", "How long the indexer has been running. Divide a cumulative seconds metric by this to get the share of the run it took, eg envio_processing_seconds for time spent in event handlers.", "gauge", metrics.elapsedSeconds);
@@ -154,6 +176,12 @@ function renderMetrics(b, metrics) {
       return s.seconds;
     }
   });
+  if (heightStreamConnects.length !== 0) {
+    series(b, "envio_source_height_stream_connects_total", "The number of times a source's height subscription connected. Compare against the disconnects total, which is absent until the first disconnect and counts as zero while it is: one more connect than disconnects means the stream is up, and equal counts mean it is down and the indexer is polling instead. Zero connects means the stream has not come up, which is the normal reading for a chain that is still backfilling: subscriptions are only opened once a chain reaches the head.", "counter", heightStreamConnects, count => count);
+  }
+  if (heightStreamDisconnects.length !== 0) {
+    series(b, "envio_source_height_stream_disconnects_total", "The number of times a source's height subscription lost a connection, by reason. Failed retries are not counted, so this is outages rather than their length. A rotated disconnect is a connection that served its time; unsubscribed is the source being benched; every other reason ended a connection early.", "counter", heightStreamDisconnects, count => count);
+  }
   series(b, "envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", "gauge", sources, height => height);
   seriesOpt(b, "envio_reorg_detected_total", "Total number of reorgs detected", "counter", chains, m => {
     if (m.reorgCount > 0) {

package/src/Persistence.res

@@ -59,14 +59,20 @@ type updatedEffectCache = {
 }
 
 type rollback = {
-  targetCheckpointId: Internal.checkpointId,
   diffCheckpointId: Internal.checkpointId,
+  // How far back the deletes reach on each chain, travelling with the diff so
+  // the write leaves an untouched sibling's rows alone.
+  floors: RollbackFloors.t,
   // The address registrations the rollback dropped, as the chains' address
   // stores resolved them. Deleted by primary key in the same transaction.
   rolledBackAddresses: array<AddressRows.key>,
-  // Last valid block per chain affected by the rollback. Read by
-  // `RollbackCommit.fire` once the diff is durably written.
-  progressBlockNumberByChainId: dict<int>,
+  // Where the rollback left every chain it moved. Written with the diff rather
+  // than waiting for a batch of those chains' own: the batch that carries the
+  // diff can belong to a chain the rollback never touched, and a chain whose
+  // stored progress outlived the checkpoints backing it would resume past
+  // blocks it never re-indexed. Also what `RollbackCommit.fire` reports once
+  // the diff is durably written.
+  progressedChains: array<InternalTable.Chains.progressedChain>,
 }
 
 // One flush group: the changes an entity accumulated within a single chain
@@ -101,7 +107,16 @@ type storage = {
     ~contractMapping: ContractMapping.t,
     ~envioInfo: JSON.t,
   ) => promise<initialState>,
-  resumeInitialState: unit => promise<initialState>,
+  // `throwIfIncompatible` gets what the storage holds before any sink is
+  // resumed, so a config the stored one rules out is reported as such rather
+  // than as the sink tripping over tables it never created.
+  resumeInitialState: (
+    ~entities: array<Internal.entityConfig>,
+    ~throwIfIncompatible: (
+      ~storedEnvioInfo: option<JSON.t>,
+      ~storedContractMapping: ContractMapping.t,
+    ) => unit,
+  ) => promise<initialState>,
   // Returns rows matching the filter.
   // Field values are serialized and rows parsed with the table's field schemas.
   @raises("StorageError")
@@ -131,13 +146,13 @@ type storage = {
   // Update chain metadata
   setChainMeta: dict<InternalTable.Chains.metaFields> => promise<unknown>,
   // Prune old checkpoints
-  pruneStaleCheckpoints: (~safeCheckpointId: Internal.checkpointId) => promise<unit>,
+  pruneStaleCheckpoints: (~safeCheckpoints: CheckpointBounds.t) => promise<unit>,
   // Prune stale entity history
   pruneStaleEntityHistory: (
     ~entityName: string,
     ~entityIndex: int,
     ~chainIdColumn: option<string>,
-    ~safeCheckpointId: Internal.checkpointId,
+    ~safeCheckpoints: CheckpointBounds.t,
   ) => promise<unit>,
   // Get rollback target checkpoint
   getRollbackTargetCheckpoint: (
@@ -146,7 +161,7 @@ type storage = {
   ) => promise<option<Internal.checkpointId>>,
   // Get rollback progress diff
   getRollbackProgressDiff: (
-    ~rollbackTargetCheckpointId: Internal.checkpointId,
+    ~floors: RollbackFloors.t,
   ) => promise<
     array<{
       "chain_id": ChainId.t,
@@ -159,7 +174,7 @@ type storage = {
   // before handing them back.
   getRollbackData: (
     ~entityConfig: Internal.entityConfig,
-    ~rollbackTargetCheckpointId: Internal.checkpointId,
+    ~floors: RollbackFloors.t,
   ) => promise<(array<rollbackRemoval>, array<Internal.entity>)>,
   // Write batch to storage
   writeBatch: (
@@ -262,27 +277,18 @@ let init = {
           }
         ) {
           Logging.info(`Found existing indexer storage. Resuming indexing state...`)
-          let initialState = await persistence.storage.resumeInitialState()
-          let changedPaths = switch initialState.envioInfo {
-          | None => ["storage was initialized by an older envio version"]
-          | Some(stored) => Config.diffPaths(~stored, ~current=envioInfo)
-          }
-          let hasClickhouse = switch envioInfo {
-          | Object(d) =>
-            switch d->Dict.get("storage") {
-            | Some(Object(s)) =>
-              switch s->Dict.get("clickhouse") {
-              | Some(Boolean(true)) => true
-              | _ => false
-              }
-            | _ => false
-            }
-          | _ => false
-          }
-          Config.throwIfIncompatible(changedPaths, ~resetCommand, ~runCommand, ~hasClickhouse)
-          if !(initialState.contractMapping->ContractMapping.isEqual(contractMapping)) {
-            Config.throwIfIncompatible(["contracts"], ~resetCommand, ~runCommand, ~hasClickhouse)
-          }
+          let initialState = await persistence.storage.resumeInitialState(
+            ~entities=persistence.allEntities,
+            ~throwIfIncompatible=(~storedEnvioInfo, ~storedContractMapping) =>
+              Config.throwIfResumeIncompatible(
+                ~storedEnvioInfo,
+                ~storedContractMapping,
+                ~envioInfo,
+                ~contractMapping,
+                ~resetCommand,
+                ~runCommand,
+              ),
+          )
           persistence.storageStatus = Ready(initialState)
           let progress = Dict.make()
           initialState.chains->Array.forEach(c => {

package/src/Persistence.res.mjs

@@ -5,7 +5,6 @@ import * as Logging from "./Logging.res.mjs";
 import * as EntityHistory from "./db/EntityHistory.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as ContractMapping from "./ContractMapping.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 let StorageError = /* @__PURE__ */Primitive_exceptions.create("Persistence.StorageError");
@@ -61,25 +60,7 @@ async function init(persistence, chainConfigs, contractMapping, envioInfo, reset
       tmp = typeof match !== "object" ? false : match.TAG === "Initializing";
       if (tmp) {
         Logging.info(`Found existing indexer storage. Resuming indexing state...`);
-        let initialState$1 = await persistence.storage.resumeInitialState();
-        let stored = initialState$1.envioInfo;
-        let changedPaths = stored !== undefined ? Config.diffPaths(stored, envioInfo) : ["storage was initialized by an older envio version"];
-        let hasClickhouse;
-        if (typeof envioInfo === "object" && envioInfo !== null && !Array.isArray(envioInfo)) {
-          let match$1 = envioInfo["storage"];
-          if (typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
-            let match$2 = match$1["clickhouse"];
-            hasClickhouse = match$2 === true;
-          } else {
-            hasClickhouse = false;
-          }
-        } else {
-          hasClickhouse = false;
-        }
-        Config.throwIfIncompatible(changedPaths, resetCommand, runCommand, hasClickhouse);
-        if (!ContractMapping.isEqual(initialState$1.contractMapping, contractMapping)) {
-          Config.throwIfIncompatible(["contracts"], resetCommand, runCommand, hasClickhouse);
-        }
+        let initialState$1 = await persistence.storage.resumeInitialState(persistence.allEntities, (storedEnvioInfo, storedContractMapping) => Config.throwIfResumeIncompatible(storedEnvioInfo, storedContractMapping, envioInfo, contractMapping, resetCommand, runCommand));
         persistence.storageStatus = {
           TAG: "Ready",
           _0: initialState$1