envio 3.5.0-alpha.3 → 3.5.0-rc.0

package/src/FetchState.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as Js_math from "@rescript/runtime/lib/es6/Js_math.js";
 import * as Logging from "./Logging.res.mjs";
 import * as AddressSet from "./sources/AddressSet.res.mjs";
@@ -14,6 +15,38 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
+function deriveSelectionStartBlock(onEventRegistrations) {
+  let earliest;
+  let idx = 0;
+  let unrestricted = Utils.$$Array.isEmpty(onEventRegistrations);
+  while (!unrestricted && idx < onEventRegistrations.length) {
+    let startBlock = onEventRegistrations[idx].startBlock;
+    if (startBlock !== undefined) {
+      let current = earliest;
+      if (!(current !== undefined && current <= startBlock)) {
+        earliest = startBlock;
+      }
+    } else {
+      unrestricted = true;
+    }
+    idx = idx + 1 | 0;
+  };
+  if (unrestricted) {
+    return;
+  } else {
+    return earliest;
+  }
+}
+
+function makeSelection(onEventRegistrations, dependsOnAddresses, clientFilteredContracts) {
+  return {
+    onEventRegistrations: onEventRegistrations,
+    dependsOnAddresses: dependsOnAddresses,
+    clientFilteredContracts: clientFilteredContracts,
+    startBlock: deriveSelectionStartBlock(onEventRegistrations)
+  };
+}
+
 function withAddresses(p, addresses) {
   return {
     id: p.id,
@@ -30,6 +63,26 @@ function withAddresses(p, addresses) {
   };
 }
 
+function narrowSelectionToRange(selection, toBlock) {
+  if (toBlock === undefined) {
+    return selection;
+  }
+  let inRange = selection.onEventRegistrations.filter(reg => {
+    let startBlock = reg.startBlock;
+    if (startBlock !== undefined) {
+      return startBlock <= toBlock;
+    } else {
+      return true;
+    }
+  });
+  let length = inRange.length;
+  if (length !== 0 && length !== selection.onEventRegistrations.length) {
+    return makeSelection(inRange, selection.dependsOnAddresses, selection.clientFilteredContracts);
+  } else {
+    return selection;
+  }
+}
+
 function densityItemsTarget(density, fromBlock, toBlock, chainTargetBlock) {
   return Primitive_int.max(1, Math.ceil(((Stdlib_Option.getOr(toBlock, chainTargetBlock) - fromBlock | 0) + 1 | 0) * density) | 0);
 }
@@ -46,6 +99,10 @@ function getTrustedDensity(p) {
   return p.eventDensity;
 }
 
+function isFetching(p) {
+  return p.mutPendingQueries.some(pq => pq.fetchedBlock === undefined);
+}
+
 function getMinQueryRange(partitions) {
   let min = 0;
   for (let i = 0, i_finish = partitions.length; i < i_finish; ++i) {
@@ -282,7 +339,7 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
     let p = partitions[idx];
     let mergeBlock = p.mergeBlock;
     if (mergeBlock !== undefined) {
-      if (p.latestFetchedBlock.blockNumber < mergeBlock) {
+      if (p.latestFetchedBlock.blockNumber < mergeBlock || isFetching(p)) {
         newPartitions.push(p);
       }
     } else if (p.dynamicContract !== undefined && p.selection.dependsOnAddresses) {
@@ -379,6 +436,21 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
                 latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
               });
               return;
+            } else if (isFetching(p)) {
+              anchored.push({
+                id: p.id,
+                latestFetchedBlock: p.latestFetchedBlock,
+                selection: p.selection,
+                addresses: p.addresses,
+                mergeBlock: p.latestFetchedBlock.blockNumber,
+                dynamicContract: p.dynamicContract,
+                mutPendingQueries: p.mutPendingQueries,
+                sourceRangeCapacity: p.sourceRangeCapacity,
+                prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+                eventDensity: p.eventDensity,
+                latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
+              });
+              return;
             } else {
               return;
             }
@@ -505,7 +577,9 @@ function handleQueryResponseForPartition(optimizedPartitions, p, query, knownHei
   }
   let updatedLatestFetchedBlock = latestFetchedBlock$1;
   let mergeBlock = p.mergeBlock;
-  let partitionReachedMergeBlock = mergeBlock !== undefined ? updatedLatestFetchedBlock.blockNumber >= mergeBlock : false;
+  let partitionReachedMergeBlock = (
+    mergeBlock !== undefined ? updatedLatestFetchedBlock.blockNumber >= mergeBlock : false
+  ) && !isFetching(p);
   if (partitionReachedMergeBlock) {
     Utils.Dict.deleteInPlace(mutEntities, p.id);
     return make(Object.values(mutEntities), optimizedPartitions.maxAddrInPartition, optimizedPartitions.nextPartitionIndex, optimizedPartitions.dynamicContracts, optimizedPartitions.clientFilteredContracts);
@@ -572,12 +646,9 @@ function handleQueryResponseForPartition(optimizedPartitions, p, query, knownHei
 }
 
 function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount, latestFetchedBlock) {
-  let p = optimizedPartitions.entities[query.partitionId];
-  if (p !== undefined) {
-    return handleQueryResponseForPartition(optimizedPartitions, p, query, knownHeight, itemsCount, latestFetchedBlock);
-  } else {
-    return optimizedPartitions;
-  }
+  let partitionId = query.partitionId;
+  let p = optimizedPartitions.entities[partitionId];
+  return handleQueryResponseForPartition(optimizedPartitions, p !== undefined ? p : Stdlib_JsError.throwWithMessage(`Unexpected case: Couldn't find partition ` + partitionId), query, knownHeight, itemsCount, latestFetchedBlock);
 }
 
 function getLatestFullyFetchedBlock(optimizedPartitions) {
@@ -836,16 +907,42 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   let absorbedPartitions = [];
   let strippedFrontiers = [];
   let anchoredContracts$1 = anchoredContracts(partitions);
+  let retire = p => ({
+    id: p.id,
+    latestFetchedBlock: p.latestFetchedBlock,
+    selection: p.selection,
+    addresses: p.addresses,
+    mergeBlock: p.latestFetchedBlock.blockNumber,
+    dynamicContract: p.dynamicContract,
+    mutPendingQueries: p.mutPendingQueries,
+    sourceRangeCapacity: p.sourceRangeCapacity,
+    prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+    eventDensity: p.eventDensity,
+    latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
+  });
+  let absorb = p => {
+    absorbedPartitions.push(p);
+    if (isFetching(p)) {
+      kept.push(retire(p));
+      return;
+    }
+  };
   partitions.forEach(p => {
     if (!p.selection.dependsOnAddresses) {
       if (p.mergeBlock !== undefined) {
         backfills.push(p);
+        if (isFetching(p)) {
+          kept.push(retire(p));
+          return;
+        } else {
+          return;
+        }
       } else if (Stdlib_Option.isNone(standingRef.contents)) {
         standingRef.contents = p;
+        return;
       } else {
-        absorbedPartitions.push(p);
+        return absorb(p);
       }
-      return;
     }
     let contractNames = p.addresses.contractNames();
     let serverSideNames = contractNames.filter(c => !clientFilteredContracts.has(c));
@@ -856,11 +953,13 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
     let contractName = p.dynamicContract;
     if (contractName !== undefined ? anchoredContracts$1.has(contractName) : false) {
       kept.push(p);
+      return;
     } else if (Utils.$$Array.isEmpty(serverSideNames)) {
-      absorbedPartitions.push(p);
+      return absorb(p);
     } else {
       strippedFrontiers.push(p.latestFetchedBlock);
       kept.push(withAddresses(p, p.addresses.filterByContracts(serverSideNames)));
+      return;
     }
   });
   let standing = standingRef.contents;
@@ -900,19 +999,16 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
     }
   });
   addRegs(normalSelection.onEventRegistrations.filter(reg => clientFilteredContracts.has(reg.eventConfig.contractName)));
-  let newSelection_onEventRegistrations = Object.values(regByIndex);
-  let newSelection_clientFilteredContracts = Array.from(clientFilteredContracts);
-  let newSelection = {
-    onEventRegistrations: newSelection_onEventRegistrations,
-    dependsOnAddresses: false,
-    clientFilteredContracts: newSelection_clientFilteredContracts
-  };
+  let newSelection = makeSelection(Object.values(regByIndex), false, Array.from(clientFilteredContracts));
   let standing$2 = standingRef.contents;
   if (standing$2 !== undefined) {
     let standingOut;
     if (selectionChanged) {
       let id = nextPartitionIndexRef.contents.toString();
       nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+      if (isFetching(standing$2)) {
+        kept.push(retire(standing$2));
+      }
       standingOut = {
         id: id,
         latestFetchedBlock: standing$2.latestFetchedBlock,
@@ -974,6 +1070,43 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   return kept;
 }
 
+function warnAddressRegistration(chainId, contractAddress, params, message) {
+  Logging.childWarn(Logging.createChild({
+    chainId: chainId,
+    contractAddress: contractAddress,
+    details: params
+  }), message);
+}
+
+function warnRejectedRegistration(verdict, chainId, contractAddress, contractName) {
+  if (typeof verdict !== "object") {
+    return warnAddressRegistration(chainId, contractAddress, {
+      contractName: contractName
+    }, `Skipping contract registration: Not a valid address for this chain's ecosystem.`);
+  }
+  switch (verdict.TAG) {
+    case "Added" :
+    case "NoEvents" :
+      return;
+    case "Duplicate" :
+      let existingEffectiveStartBlock = verdict.existingEffectiveStartBlock;
+      let effectiveStartBlock = verdict.effectiveStartBlock;
+      if (existingEffectiveStartBlock > effectiveStartBlock) {
+        return warnAddressRegistration(chainId, contractAddress, {
+          existingBlockNumber: existingEffectiveStartBlock,
+          newBlockNumber: effectiveStartBlock
+        }, `Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.`);
+      } else {
+        return;
+      }
+    case "Conflict" :
+      return warnAddressRegistration(chainId, contractAddress, {
+        existingContractType: verdict.existingContractName,
+        newContractType: contractName
+      }, `Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`);
+  }
+}
+
 function createPartitions(registeringSetsByContract, addressStore, dynamicContracts, clientFilteredContracts, normalSelection, maxAddrInPartition, nextPartitionIndex, existingPartitions, progressBlockNumber, knownHeight) {
   let nextPartitionIndexRef = {
     contents: nextPartitionIndex
@@ -1117,25 +1250,17 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
   }
   let idCursor = addressStore.nextId();
   let verdicts = AddressStore.registerBatch(addressStore, registrations);
-  let warn = (contractAddress, params, message) => Logging.childWarn(Logging.createChild({
-    chainId: fetchState.chainId,
-    contractAddress: contractAddress,
-    details: params
-  }), message);
   let registeringContractNames = [];
   let hasNoEventsUpdatesRef = false;
   for (let idx = 0, idx_finish = verdicts.length; idx < idx_finish; ++idx) {
     let registration = registrations[idx];
-    let contractAddress = registration.address;
-    let match = verdicts[idx];
+    let verdict = verdicts[idx];
     let keep;
-    if (typeof match !== "object") {
-      warn(contractAddress, {
-        contractName: registration.contractName
-      }, `Skipping contract registration: Not a valid address for this chain's ecosystem.`);
-      keep = false;
+    let exit = 0;
+    if (typeof verdict !== "object") {
+      exit = 1;
     } else {
-      switch (match.TAG) {
+      switch (verdict.TAG) {
         case "Added" :
           if (!registeringContractNames.includes(registration.contractName)) {
             registeringContractNames.push(registration.contractName);
@@ -1144,31 +1269,19 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
           break;
         case "NoEvents" :
           hasNoEventsUpdatesRef = true;
-          warn(contractAddress, {
+          warnAddressRegistration(fetchState.chainId, registration.address, {
             contractName: registration.contractName
           }, `Persisting contract registration without fetching: Contract doesn't have any events to fetch. It'll be picked up on restart if you add events for the contract.`);
           keep = true;
           break;
-        case "Duplicate" :
-          let existingEffectiveStartBlock = match.existingEffectiveStartBlock;
-          let effectiveStartBlock = match.effectiveStartBlock;
-          if (existingEffectiveStartBlock > effectiveStartBlock) {
-            warn(contractAddress, {
-              existingBlockNumber: existingEffectiveStartBlock,
-              newBlockNumber: effectiveStartBlock
-            }, `Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.`);
-          }
-          keep = false;
-          break;
-        case "Conflict" :
-          warn(contractAddress, {
-            existingContractType: match.existingContractName,
-            newContractType: registration.contractName
-          }, `Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`);
-          keep = false;
-          break;
+        default:
+          exit = 1;
       }
     }
+    if (exit === 1) {
+      warnRejectedRegistration(verdict, fetchState.chainId, registration.address, registration.contractName);
+      keep = false;
+    }
     if (!keep) {
       sourceIndexes[idx] = -1 - sourceIndexes[idx] | 0;
     }
@@ -1191,8 +1304,8 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
       dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
       for (let idx$3 = 0, idx_finish$2 = mutExistingPartitions.length; idx$3 < idx_finish$2; ++idx$3) {
         let p = mutExistingPartitions[idx$3];
-        let match$1 = p.addresses.countFor(contractName);
-        if (match$1 !== 0 && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
+        let match = p.addresses.countFor(contractName);
+        if (match !== 0 && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
           let allPartitionContractNames = p.addresses.contractNames();
           if (allPartitionContractNames.length !== 1) {
             let isFetching = p.mutPendingQueries.length !== 0;
@@ -1389,11 +1502,19 @@ function walkPartitionPending(p, partitionId, inFlightCount, candidates, headBlo
     }
     pqIdx = pqIdx + 1 | 0;
   };
+  let startBlock = p.selection.startBlock;
+  let cursor$1;
+  if (startBlock !== undefined && startBlock > cursor) {
+    let reachable = Utils.$$Math.minOptInt(headBlockNumber, queryEndBlock);
+    cursor$1 = reachable !== undefined && startBlock <= reachable ? startBlock : cursor;
+  } else {
+    cursor$1 = cursor;
+  }
   if (canContinue) {
     return {
       partitionId: partitionId,
       p: p,
-      cursor: cursor,
+      cursor: cursor$1,
       chunksUsedThisCall: chunksUsedThisCall,
       inFlightCount: inFlightCount,
       queryEndBlock: queryEndBlock,
@@ -1653,10 +1774,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
     partitions.push({
       id: partitions.length.toString(),
       latestFetchedBlock: latestFetchedBlock,
-      selection: {
-        onEventRegistrations: notDependingOnAddresses,
-        dependsOnAddresses: false
-      },
+      selection: makeSelection(notDependingOnAddresses, false, undefined),
       addresses: addressStore.emptySet(),
       mergeBlock: undefined,
       dynamicContract: undefined,
@@ -1667,15 +1785,15 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
       latestSourceRangeCapacityUpdateBlock: 0
     });
   }
-  let normalSelection = {
-    onEventRegistrations: normalRegistrations,
-    dependsOnAddresses: true
-  };
+  let normalSelection = makeSelection(normalRegistrations, true, undefined);
   AddressStore.registerBatch(addressStore, addresses.map(contract => ({
     address: contract.address,
     contractName: contract.contractName,
     registrationBlock: contract.registrationBlock
-  })));
+  }))).forEach((verdict, idx) => {
+    let contract = addresses[idx];
+    warnRejectedRegistration(verdict, chainId, contract.address, contract.contractName);
+  });
   let dynamicContracts = new Set();
   let clientFilteredContracts = new Set();
   let registeringSetsByContract = {};
@@ -1703,7 +1821,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
   }
   let optimizedPartitions = createPartitions(registeringSetsByContract, addressStore, dynamicContracts, clientFilteredContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber, knownHeight);
   if (optimizedPartitions.idsInAscOrder.length === 0 && Utils.$$Array.isEmpty(onBlockRegistrations)) {
-    Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + chainId.toString() + `. ` + (`addresses=` + addresses.length.toString() + `, `) + (`onEventRegistrations=` + onEventRegistrations.length.toString() + `, `) + (`normalRegistrations=` + normalRegistrations.length.toString() + `. `) + `Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.`);
+    Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + ChainId.toString(chainId) + `. ` + (`addresses=` + addresses.length.toString() + `, `) + (`onEventRegistrations=` + onEventRegistrations.length.toString() + `, `) + (`normalRegistrations=` + normalRegistrations.length.toString() + `. `) + `Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.`);
   }
   let buffer = [];
   let latestOnBlockBlockNumber;
@@ -2020,10 +2138,14 @@ let maxChainConcurrency = Env.maxChainConcurrency;
 let chunkRangeGrowthFactor = 1.8;
 
 export {
+  deriveSelectionStartBlock,
+  makeSelection,
   withAddresses,
+  narrowSelectionToRange,
   densityItemsTarget,
   getMinHistoryRange,
   getTrustedDensity,
+  isFetching,
   getMinQueryRange,
   OptimizedPartitions,
   bufferBlockNumber,
@@ -2038,6 +2160,8 @@ export {
   addClientFilteredContract,
   claimedFetchedBlock,
   collapseClientFilteredContracts,
+  warnAddressRegistration,
+  warnRejectedRegistration,
   createPartitions,
   registerDynamicContracts,
   handleQueryResult,

package/src/FinalizeBackfill.res

@@ -1,11 +1,12 @@
-// The FinalizingIndexes phase. Runs once, from the processing loop, when every
+// The FinalizingIndexes phase. Reached from the processing loop when every
 // chain has caught up: processing is already paused (the loop awaits this),
-// pending writes are flushed, then storage creates every missing schema-defined
-// index and stamps `ready_at` in one transaction. A failure rolls back both, so
-// the next batch simply retries — the indexer never reports ready with an index
-// the schema promised still missing.
+// pending writes are flushed, then storage builds every missing schema-defined
+// index and, once they all verify, commits `ready_at`. A failure part-way
+// leaves the indexes built so far in place and reaches the processing loop's
+// error boundary; the retry only owes what's left. Either way the indexer never
+// reports ready with an index the schema promised still missing.
 
-let run = async (state: IndexerState.t) => {
+let runOnce = async (state: IndexerState.t) => {
   Logging.info(
     "All chains are caught up. Finalizing the indexer before switching to realtime: flushing pending writes, then creating the indexes the schema promises.",
   )
@@ -28,7 +29,33 @@ let run = async (state: IndexerState.t) => {
       ~readyAt,
     )
 
+    // Only after the commit: in-memory readiness must never run ahead of the
+    // `ready_at` a restart would read back.
     state->IndexerState.markReady(~readyAt)
     Logging.info("The indexer is ready. Switching to realtime indexing.")
   }
 }
+
+// Several paths reach the phase — a processed batch, a tick that progressed
+// nothing — and a height update can bring another one round while the first is
+// still building. They all join the in-flight run rather than starting a second
+// pass over the same indexes.
+let run = (state: IndexerState.t) =>
+  switch state->IndexerState.finalizeFiber {
+  | Some(fiber) => fiber
+  | None =>
+    let fiber = runOnce(state)->Promise.finally(() => state->IndexerState.endFinalizeFiber)
+    state->IndexerState.beginFinalizeFiber(fiber)
+    fiber
+  }
+
+// An indexer resumed already ready never reaches `run`, so nothing above would
+// notice an index the schema promises being dropped or invalidated while it was
+// down — `ensureQueryIndexes` only covers what a getWhere actually asks for.
+// Best-effort and not awaited by the loop: indexing is already live and correct
+// without the index, just slower.
+let repairSchemaIndexes = (state: IndexerState.t) => {
+  let persistence = state->IndexerState.persistence
+  let storage = persistence->Persistence.getInitializedStorageOrThrow
+  storage.ensureSchemaIndexes(~entities=persistence.allEntities)
+}

package/src/FinalizeBackfill.res.mjs

@@ -6,7 +6,7 @@ import * as ChainState from "./ChainState.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 
-async function run(state) {
+async function runOnce(state) {
   Logging.info("All chains are caught up. Finalizing the indexer before switching to realtime: flushing pending writes, then creating the indexes the schema promises.");
   await Writing.flush(state);
   if (IndexerState.hasFailedWrite(state)) {
@@ -20,7 +20,25 @@ async function run(state) {
   return Logging.info("The indexer is ready. Switching to realtime indexing.");
 }
 
+function run(state) {
+  let fiber = IndexerState.finalizeFiber(state);
+  if (fiber !== undefined) {
+    return fiber;
+  }
+  let fiber$1 = runOnce(state).finally(() => IndexerState.endFinalizeFiber(state));
+  IndexerState.beginFinalizeFiber(state, fiber$1);
+  return fiber$1;
+}
+
+function repairSchemaIndexes(state) {
+  let persistence = IndexerState.persistence(state);
+  let storage = Persistence.getInitializedStorageOrThrow(persistence);
+  return storage.ensureSchemaIndexes(persistence.allEntities);
+}
+
 export {
+  runOnce,
   run,
+  repairSchemaIndexes,
 }
 /* Logging Not a pure module */

package/src/HandlerRegister.res

@@ -82,8 +82,8 @@ let startRegistration = (~config: Config.t) => {
   }
 }
 
-let getChainRegistrations = (r: activeRegistration, ~chainId: int): chainRegistrations => {
-  let key = chainId->Int.toString
+let getChainRegistrations = (r: activeRegistration, ~chainId: ChainId.t): chainRegistrations => {
+  let key = chainId->ChainId.toString
   switch r.registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(key) {
   | Some(existing) => existing
   | None =>
@@ -98,7 +98,7 @@ let getChainRegistrations = (r: activeRegistration, ~chainId: int): chainRegistr
 
 let buildOnEventRegistrationWith = (
   ~config: Config.t,
-  ~chainId: int,
+  ~chainId: ChainId.t,
   ~eventConfig: Internal.eventConfig,
   ~isWildcard: bool,
   ~handler: option<Internal.handler>,
@@ -342,10 +342,10 @@ let setContractRegister = (~contractName, ~eventName, contractRegister, ~eventOp
 }
 
 // Raw onEvent registrations stored for a chain (empty if the chain has none).
-let storedOnEventRegistrations = (r: activeRegistration, ~chainId: int): array<
+let storedOnEventRegistrations = (r: activeRegistration, ~chainId: ChainId.t): array<
   Internal.onEventRegistration,
 > =>
-  switch r.registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(chainId->Int.toString) {
+  switch r.registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(chainId->ChainId.toString) {
   | Some(chainRegs) => chainRegs.onEventRegistrations
   | None => []
   }
@@ -373,7 +373,7 @@ let isWildcard = (~contractName, ~eventName) =>
 // item still produces an item to run.
 let getSimulateOnEventRegistrations = (
   ~config: Config.t,
-  ~chainId: int,
+  ~chainId: ChainId.t,
   ~eventConfig: Internal.eventConfig,
 ): array<Internal.onEventRegistration> => {
   let stored = switch getActiveRegistration() {
@@ -412,7 +412,7 @@ let finishRegistration = (~config: Config.t): registrationsByChainId => {
       ->ChainMap.values
       ->Array.forEach(chainConfig => {
         let chainId = chainConfig.id
-        let key = chainId->Int.toString
+        let key = chainId->ChainId.toString
 
         let builtRegs = mergeRegistrations(r->storedOnEventRegistrations(~chainId), ~config)
         let registeredKeys = Utils.Set.make()
@@ -638,7 +638,7 @@ let registerOnBlock = (
     ->ChainMap.values
     ->Array.forEach(chainConfig => {
       let chainId = chainConfig.id
-      let chainObj = chainsDict->Dict.getUnsafe(chainId->Int.toString)
+      let chainObj = chainsDict->Dict.getUnsafe(chainId->ChainId.toString)
 
       // Predicate returns `true` → match with no filter; `false` → skip;
       // any plain object → structured filter. `undefined`/`null` returns

package/src/HandlerRegister.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
@@ -54,7 +55,7 @@ function startRegistration(config) {
 }
 
 function getChainRegistrations(r, chainId) {
-  let key = chainId.toString();
+  let key = ChainId.toString(chainId);
   let existing = r.registrationsByChainId[key];
   if (existing !== undefined) {
     return existing;
@@ -220,7 +221,7 @@ function setContractRegister(contractName, eventName, contractRegister, eventOpt
 }
 
 function storedOnEventRegistrations(r, chainId) {
-  let chainRegs = r.registrationsByChainId[chainId.toString()];
+  let chainRegs = r.registrationsByChainId[ChainId.toString(chainId)];
   if (chainRegs !== undefined) {
     return chainRegs.onEventRegistrations;
   } else {
@@ -270,7 +271,7 @@ function finishRegistration(config) {
   let registrationsByChainId = {};
   ChainMap.values(config.chainMap).forEach(chainConfig => {
     let chainId = chainConfig.id;
-    let key = chainId.toString();
+    let key = ChainId.toString(chainId);
     let builtRegs = mergeRegistrations(storedOnEventRegistrations(r, chainId), config);
     let registeredKeys = new Set();
     builtRegs.forEach(reg => {
@@ -385,7 +386,7 @@ function registerOnBlock(name, where, handler, getChainsObject) {
     };
     ChainMap.values(config.chainMap).forEach(chainConfig => {
       let chainId = chainConfig.id;
-      let chainObj = chainsDict[chainId.toString()];
+      let chainObj = chainsDict[ChainId.toString(chainId)];
       let result = where$1 !== undefined ? where$1({
           chain: chainObj
         }) : true;

package/src/HandlerRegister.resi

@@ -26,7 +26,7 @@ let isWildcard: (~contractName: string, ~eventName: string) => bool
 let isDroppedByWhere: (~config: Config.t, Internal.onEventRegistration) => bool
 let getSimulateOnEventRegistrations: (
   ~config: Config.t,
-  ~chainId: int,
+  ~chainId: ChainId.t,
   ~eventConfig: Internal.eventConfig,
 ) => array<Internal.onEventRegistration>
 

package/src/InMemoryStore.res

@@ -108,7 +108,11 @@ let prepareRollbackDiff = async (
   let deletedEntities = Dict.make()
   let setEntities = Dict.make()
 
+  // Rollback data comes from Postgres entity history, which is kept only for
+  // Postgres-backed entities. ClickHouse-only entities have no history to
+  // restore from, so a reorg leaves them un-reverted in the sink.
   let _ = await persistence.allEntities
+  ->Array.filter(entityConfig => entityConfig.storage.postgres)
   ->Array.map(async entityConfig => {
     let entityTable = state->getInMemTable(~entityConfig)
 

package/src/InMemoryStore.res.mjs

@@ -86,7 +86,7 @@ async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDi
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
   let deletedEntities = {};
   let setEntities = {};
-  await Promise.all(persistence.allEntities.map(async entityConfig => {
+  await Promise.all(persistence.allEntities.filter(entityConfig => entityConfig.storage.postgres).map(async entityConfig => {
     let entityTable = getInMemTable(state, entityConfig);
     let match = await persistence.storage.getRollbackData(entityConfig, rollbackTargetCheckpointId);
     match[0].forEach(entityId => {