envio 3.1.0-rc.1 → 3.1.0

package/src/PgStorage.res

@@ -450,27 +450,64 @@ let chunkArray = (arr: array<'a>, ~chunkSize) => {
   chunks
 }
 
-let removeInvalidUtf8InPlace = entities =>
-  entities->Array.forEach(item => {
-    let dict = item->(Utils.magic: 'a => dict<unknown>)
-    dict->Utils.Dict.forEachWithKey((value, key) => {
-      if value->typeof === #string {
-        let value = value->(Utils.magic: unknown => string)
-
-        dict->Dict.set(
-          key,
-          value
-          ->Utils.String.replaceAll("\x00", "")
-          ->(Utils.magic: string => unknown),
-        )
-      }
-    })
-  })
+// Strips NUL bytes, recursing into nested objects/arrays so a NUL buried
+// inside a jsonb column (an event param object, a json entity field) is
+// removed too — Postgres rejects it in both text (0x00) and jsonb (22P05).
+let rec removeInvalidUtf8DeepInPlace = (value: unknown): unknown => {
+  if value->typeof === #string {
+    value
+    ->(Utils.magic: unknown => string)
+    ->Utils.String.replaceAll("\x00", "")
+    ->(Utils.magic: string => unknown)
+  } else if value->typeof === #object && value !== %raw(`null`) {
+    let dict = value->(Utils.magic: unknown => dict<unknown>)
+    dict->Utils.Dict.forEachWithKey((v, k) => dict->Dict.set(k, removeInvalidUtf8DeepInPlace(v)))
+    value
+  } else {
+    value
+  }
+}
+
+let removeInvalidUtf8InPlace = items =>
+  items->Array.forEach(item =>
+    removeInvalidUtf8DeepInPlace(item->(Utils.magic: 'a => unknown))->ignore
+  )
 
 let pgErrorMessageSchema = S.object(s => s.field("message", S.string))
 
 exception PgEncodingError({table: Table.table})
 
+// Classifies a write failure, parking it in `specificError` so the
+// transaction can unwind and the outer handler can react. Both Postgres
+// encoding failures we recognize are NUL-related — `0x00` in a text column
+// and a NUL rejected by jsonb (22P05) — so they become a PgEncodingError
+// that triggers an escape-and-retry of the offending table, where deep NUL
+// stripping resolves them. We escape lazily on first failure to keep the
+// happy path free of per-item sanitization. The aborted-transaction cascade
+// is ignored so it never masks the original error.
+let classifyWriteError = (~specificError: ref<option<exn>>, ~table: Table.table, ~exn) => {
+  /* Note: Entity History doesn't return StorageError yet, and directly throws JsError */
+  let normalizedExn = switch exn {
+  | JsExn(_) => exn
+  | Persistence.StorageError({reason: exn}) => exn
+  | _ => exn
+  }->JsExn.anyToExnInternal
+
+  switch normalizedExn {
+  | JsExn(error) =>
+    switch error->S.parseOrThrow(pgErrorMessageSchema) {
+    | `current transaction is aborted, commands ignored until end of transaction block` => ()
+    | `invalid byte sequence for encoding "UTF8": 0x00`
+    | `unsupported Unicode escape sequence` =>
+      specificError.contents = Some(PgEncodingError({table: table}))
+    | _ => specificError.contents = Some(exn->Utils.prettifyExn)
+    | exception _ => ()
+    }
+  | S.Raised(_) => throw(normalizedExn) // But rethrow this one, since it's not a PG error
+  | _ => ()
+  }
+}
+
 // WeakMap for caching table batch set queries
 let setQueryCache = Utils.WeakMap.make()
 let setOrThrow = async (sql, ~items, ~table: Table.table, ~itemSchema, ~pgSchema) => {
@@ -712,10 +749,77 @@ let executeSet = (
   }
 }
 
+let convertFieldsToJson = (fields: option<dict<unknown>>) => {
+  switch fields {
+  | None => %raw(`{}`)
+  | Some(fields) =>
+    // Convert bigint fields to string. There are no fields with nested
+    // bigints, so iterating only the top level is safe.
+    fields
+    ->Utils.Dict.mapValues(value =>
+      typeof(value) === #bigint
+        ? value
+          ->(Utils.magic: unknown => bigint)
+          ->BigInt.toString
+          ->(Utils.magic: string => unknown)
+        : value
+    )
+    ->(Utils.magic: dict<unknown> => JSON.t)
+  }
+}
+
+let makeRawEvent = (
+  eventItem: Internal.eventItem,
+  ~config: Config.t,
+): InternalTable.RawEvents.t => {
+  let {event, eventConfig, chain, blockNumber, timestamp: blockTimestamp} = eventItem
+  let {block, transaction, params, logIndex, srcAddress} = event
+  let chainId = chain->ChainMap.Chain.toChainId
+  let eventId = EventUtils.packEventIndex(~logIndex, ~blockNumber)
+  let blockFields =
+    block
+    ->(Utils.magic: Internal.eventBlock => option<dict<unknown>>)
+    ->convertFieldsToJson
+  let transactionFields =
+    transaction
+    ->(Utils.magic: Internal.eventTransaction => option<dict<unknown>>)
+    ->convertFieldsToJson
+
+  blockFields->config.ecosystem.cleanUpRawEventFieldsInPlace
+
+  // Serialize to unknown, because serializing to Js.Json.t fails for Bytes Fuel type, since it has unknown schema
+  let params =
+    params
+    ->S.reverseConvertOrThrow(eventConfig.paramsRawEventSchema)
+    ->(Utils.magic: unknown => JSON.t)
+  let params = if params === %raw(`null`) {
+    // Should probably make the params field nullable
+    // But this is currently needed to make events
+    // with empty params work
+    %raw(`"null"`)
+  } else {
+    params
+  }
+
+  {
+    chainId,
+    eventId,
+    eventName: eventConfig.name,
+    contractName: eventConfig.contractName,
+    blockNumber,
+    logIndex,
+    srcAddress,
+    blockHash: block->config.ecosystem.getId,
+    blockTimestamp,
+    blockFields,
+    transactionFields,
+    params,
+  }
+}
+
 let rec writeBatch = async (
   sql,
   ~batch: Batch.t,
-  ~rawEvents,
   ~pgSchema,
   ~rollback: option<Persistence.rollback>,
   ~isInReorgThreshold,
@@ -725,6 +829,7 @@ let rec writeBatch = async (
   ~updatedEffectsCache,
   ~updatedEntities: array<Persistence.updatedEntity>,
   ~sinkPromise: option<promise<option<exn>>>,
+  ~chainMetaData: option<dict<InternalTable.Chains.metaFields>>,
   ~escapeTables=?,
 ) => {
   try {
@@ -732,18 +837,37 @@ let rec writeBatch = async (
 
     let specificError = ref(None)
 
-    let setRawEvents = executeSet(
-      _,
-      ~dbFunction=(sql, items) => {
-        sql->setOrThrow(
-          ~items,
-          ~table=InternalTable.RawEvents.table,
-          ~itemSchema=InternalTable.RawEvents.schema,
-          ~pgSchema,
-        )
-      },
-      ~items=rawEvents,
-    )
+    let rawEvents = if config.enableRawEvents {
+      let rows = batch.items->Belt.Array.keepMap(item =>
+        switch item {
+        | Internal.Event(_) => Some(item->Internal.castUnsafeEventItem->makeRawEvent(~config))
+        | Internal.Block(_) => None
+        }
+      )
+      switch escapeTables {
+      | Some(tables) if tables->Utils.Set.has(InternalTable.RawEvents.table) =>
+        rows->removeInvalidUtf8InPlace
+      | _ => ()
+      }
+      rows
+    } else {
+      []
+    }
+
+    let setRawEvents = async sql => {
+      try {
+        await sql->executeSet(~dbFunction=(sql, items) => {
+          sql->setOrThrow(
+            ~items,
+            ~table=InternalTable.RawEvents.table,
+            ~itemSchema=InternalTable.RawEvents.schema,
+            ~pgSchema,
+          )
+        }, ~items=rawEvents)
+      } catch {
+      | exn => classifyWriteError(~specificError, ~table=InternalTable.RawEvents.table, ~exn)
+      }
+    }
 
     let setEntities = updatedEntities->Belt.Array.map(({entityConfig, changes}) => {
       let entitiesToSet = []
@@ -883,42 +1007,11 @@ let rec writeBatch = async (
         // might throw PG error, earlier, than the handled error
         // from setOrThrow will be passed through.
         // This is needed for the utf8 encoding fix.
-        | exn => {
-            /* Note: Entity History doesn't return StorageError yet, and directly throws JsError */
-            let normalizedExn = switch exn {
-            | JsExn(_) => exn
-            | Persistence.StorageError({reason: exn}) => exn
-            | _ => exn
-            }->JsExn.anyToExnInternal
-
-            switch normalizedExn {
-            | JsExn(error) =>
-              // Workaround for https://github.com/enviodev/hyperindex/issues/446
-              // We do escaping only when we actually got an error writing for the first time.
-              // This is not perfect, but an optimization to avoid escaping for every single item.
-
-              switch error->S.parseOrThrow(pgErrorMessageSchema) {
-              | `current transaction is aborted, commands ignored until end of transaction block` => ()
-              | `invalid byte sequence for encoding "UTF8": 0x00` =>
-                // Since the transaction is aborted at this point,
-                // we can't simply retry the function with escaped items,
-                // so propagate the error, to restart the whole batch write.
-                // Also, pass the failing table, to escape only its items.
-                // TODO: Ideally all this should be done in the file,
-                // so it'll be easier to work on PG specific logic.
-                specificError.contents = Some(PgEncodingError({table: entityConfig.table}))
-              | _ => specificError.contents = Some(exn->Utils.prettifyExn)
-              | exception _ => ()
-              }
-            | S.Raised(_) => throw(normalizedExn) // But rethrow this one, since it's not a PG error
-            | _ => ()
-            }
-
-            // Improtant: Don't rethrow here, since it'll result in
-            // an unhandled rejected promise error.
-            // That's fine not to throw, since sql->Postgres.beginSql
-            // will fail anyways.
-          }
+        //
+        // Important: Don't rethrow here, since it'll result in an unhandled
+        // rejected promise error. That's fine not to throw, since
+        // sql->Postgres.beginSql will fail anyways.
+        | exn => classifyWriteError(~specificError, ~table=entityConfig.table, ~exn)
         }
       }
     })
@@ -975,6 +1068,16 @@ let rec writeBatch = async (
             setRawEvents,
           ]->Belt.Array.concat(setEntities)
 
+          switch chainMetaData {
+          | Some(chainsData) =>
+            setOperations
+            ->Array.push(sql =>
+              sql->InternalTable.Chains.setMeta(~pgSchema, ~chainsData)->Utils.Promise.ignoreValue
+            )
+            ->ignore
+          | None => ()
+          }
+
           if shouldSaveHistory {
             setOperations->Belt.Array.push(sql =>
               sql->InternalTable.Checkpoints.insert(
@@ -1036,7 +1139,6 @@ let rec writeBatch = async (
     await writeBatch(
       sql,
       ~escapeTables,
-      ~rawEvents,
       ~batch,
       ~pgSchema,
       ~rollback,
@@ -1047,6 +1149,7 @@ let rec writeBatch = async (
       ~allEntities,
       ~updatedEntities,
       ~sinkPromise,
+      ~chainMetaData,
     )
   }
 }
@@ -1631,13 +1734,13 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
 
   let writeBatchMethod = async (
     ~batch,
-    ~rawEvents,
     ~rollback,
     ~isInReorgThreshold,
     ~config,
     ~allEntities,
     ~updatedEffectsCache,
     ~updatedEntities,
+    ~chainMetaData,
   ) => {
     let pgUpdates = []
     let chUpdates = []
@@ -1676,7 +1779,6 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     await writeBatch(
       sql,
       ~batch,
-      ~rawEvents,
       ~pgSchema,
       ~rollback,
       ~isInReorgThreshold,
@@ -1686,6 +1788,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
       ~updatedEffectsCache,
       ~updatedEntities=pgUpdates,
       ~sinkPromise,
+      ~chainMetaData,
     )
     Prometheus.StorageWrite.increment(
       ~storage="postgres",

package/src/PgStorage.res.mjs

@@ -14,6 +14,7 @@ import * as Logging from "./Logging.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import Postgres from "postgres";
 import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as EventUtils from "./EventUtils.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as ChainFetcher from "./ChainFetcher.res.mjs";
@@ -329,19 +330,60 @@ function chunkArray(arr, chunkSize) {
   return chunks;
 }
 
-function removeInvalidUtf8InPlace(entities) {
-  entities.forEach(item => Utils.Dict.forEachWithKey(item, (value, key) => {
-    if (typeof value === "string") {
-      item[key] = value.replaceAll("\x00", "");
-      return;
-    }
-  }));
+function removeInvalidUtf8DeepInPlace(value) {
+  if (typeof value === "string") {
+    return value.replaceAll("\x00", "");
+  } else if (typeof value === "object" && value !== null) {
+    Utils.Dict.forEachWithKey(value, (v, k) => {
+      value[k] = removeInvalidUtf8DeepInPlace(v);
+    });
+    return value;
+  } else {
+    return value;
+  }
+}
+
+function removeInvalidUtf8InPlace(items) {
+  items.forEach(item => {
+    removeInvalidUtf8DeepInPlace(item);
+  });
 }
 
 let pgErrorMessageSchema = S$RescriptSchema.object(s => s.f("message", S$RescriptSchema.string));
 
 let PgEncodingError = /* @__PURE__ */Primitive_exceptions.create("PgStorage.PgEncodingError");
 
+function classifyWriteError(specificError, table, exn) {
+  let normalizedExn = Primitive_exceptions.internalToException(exn.RE_EXN_ID === "JsExn" || exn.RE_EXN_ID !== Persistence.StorageError ? exn : exn.reason);
+  if (normalizedExn.RE_EXN_ID === "JsExn") {
+    let val;
+    try {
+      val = S$RescriptSchema.parseOrThrow(normalizedExn._1, pgErrorMessageSchema);
+    } catch (exn$1) {
+      return;
+    }
+    switch (val) {
+      case "current transaction is aborted, commands ignored until end of transaction block" :
+        return;
+      case "invalid byte sequence for encoding \"UTF8\": 0x00" :
+      case "unsupported Unicode escape sequence" :
+        specificError.contents = {
+          RE_EXN_ID: PgEncodingError,
+          table: table
+        };
+        return;
+      default:
+        specificError.contents = Utils.prettifyExn(exn);
+        return;
+    }
+  } else {
+    if (normalizedExn.RE_EXN_ID !== S$RescriptSchema.Raised) {
+      return;
+    }
+    throw normalizedExn;
+  }
+}
+
 let setQueryCache = new WeakMap();
 
 async function setOrThrow(sql, items, table, itemSchema, pgSchema) {
@@ -509,13 +551,76 @@ function executeSet(sql, items, dbFunction) {
   }
 }
 
-async function writeBatch(sql, batch, rawEvents, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, escapeTables) {
+function convertFieldsToJson(fields) {
+  if (fields !== undefined) {
+    return Utils.Dict.mapValues(fields, value => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      } else {
+        return value;
+      }
+    });
+  } else {
+    return {};
+  }
+}
+
+function makeRawEvent(eventItem, config) {
+  let event = eventItem.event;
+  let block = event.block;
+  let logIndex = event.logIndex;
+  let blockNumber = eventItem.blockNumber;
+  let eventConfig = eventItem.eventConfig;
+  let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
+  let blockFields = convertFieldsToJson(block);
+  let transactionFields = convertFieldsToJson(event.transaction);
+  config.ecosystem.cleanUpRawEventFieldsInPlace(blockFields);
+  let params = S$RescriptSchema.reverseConvertOrThrow(event.params, eventConfig.paramsRawEventSchema);
+  let params$1 = params === null ? "null" : params;
+  return {
+    chain_id: eventItem.chain,
+    event_id: eventId,
+    event_name: eventConfig.name,
+    contract_name: eventConfig.contractName,
+    block_number: blockNumber,
+    log_index: logIndex,
+    src_address: event.srcAddress,
+    block_hash: config.ecosystem.getId(block),
+    block_timestamp: eventItem.timestamp,
+    block_fields: blockFields,
+    transaction_fields: transactionFields,
+    params: params$1
+  };
+}
+
+async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, escapeTables) {
   try {
     let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
     let specificError = {
       contents: undefined
     };
-    let setRawEvents = __x => executeSet(__x, rawEvents, (sql, items) => setOrThrow(sql, items, InternalTable.RawEvents.table, InternalTable.RawEvents.schema, pgSchema));
+    let rawEvents;
+    if (config.enableRawEvents) {
+      let rows = Belt_Array.keepMap(batch.items, item => {
+        if (item.kind === 0) {
+          return makeRawEvent(item, config);
+        }
+      });
+      if (escapeTables !== undefined && Primitive_option.valFromOption(escapeTables).has(InternalTable.RawEvents.table)) {
+        removeInvalidUtf8InPlace(rows);
+      }
+      rawEvents = rows;
+    } else {
+      rawEvents = [];
+    }
+    let setRawEvents = async sql => {
+      try {
+        return await executeSet(sql, rawEvents, (sql, items) => setOrThrow(sql, items, InternalTable.RawEvents.table, InternalTable.RawEvents.schema, pgSchema));
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        return classifyWriteError(specificError, InternalTable.RawEvents.table, exn);
+      }
+    };
     let setEntities = Belt_Array.map(updatedEntities, param => {
       let entityConfig = param.entityConfig;
       let entitiesToSet = [];
@@ -601,33 +706,7 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollback, isInReorgTh
           return;
         } catch (raw_exn) {
           let exn = Primitive_exceptions.internalToException(raw_exn);
-          let normalizedExn = Primitive_exceptions.internalToException(exn.RE_EXN_ID === "JsExn" || exn.RE_EXN_ID !== Persistence.StorageError ? exn : exn.reason);
-          if (normalizedExn.RE_EXN_ID === "JsExn") {
-            let val;
-            try {
-              val = S$RescriptSchema.parseOrThrow(normalizedExn._1, pgErrorMessageSchema);
-            } catch (exn$1) {
-              return;
-            }
-            switch (val) {
-              case "current transaction is aborted, commands ignored until end of transaction block" :
-                return;
-              case "invalid byte sequence for encoding \"UTF8\": 0x00" :
-                specificError.contents = {
-                  RE_EXN_ID: PgEncodingError,
-                  table: entityConfig.table
-                };
-                return;
-              default:
-                specificError.contents = Utils.prettifyExn(exn);
-                return;
-            }
-          } else {
-            if (normalizedExn.RE_EXN_ID !== S$RescriptSchema.Raised) {
-              return;
-            }
-            throw normalizedExn;
-          }
+          return classifyWriteError(specificError, entityConfig.table, exn);
         }
       };
     });
@@ -657,6 +736,9 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollback, isInReorgTh
             }))),
             setRawEvents
           ], setEntities);
+          if (chainMetaData !== undefined) {
+            setOperations.push(sql => InternalTable.Chains.setMeta(sql, pgSchema, chainMetaData));
+          }
           if (shouldSaveHistory) {
             setOperations.push(sql => InternalTable.Checkpoints.insert(sql, pgSchema, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointBlockHashes, batch.checkpointEventsProcessed));
           }
@@ -687,7 +769,7 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollback, isInReorgTh
     if (exn$1.RE_EXN_ID === PgEncodingError) {
       let escapeTables$1 = escapeTables !== undefined ? Primitive_option.valFromOption(escapeTables) : new Set();
       escapeTables$1.add(exn$1.table);
-      return await writeBatch(sql, batch, rawEvents, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, Primitive_option.some(escapeTables$1));
+      return await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, Primitive_option.some(escapeTables$1));
     }
     throw exn$1;
   }
@@ -1042,7 +1124,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true}),
     sql.unsafe(makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true})
   ]);
-  let writeBatchMethod = async (batch, rawEvents, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities) => {
+  let writeBatchMethod = async (batch, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities, chainMetaData) => {
     let pgUpdates = [];
     let chUpdates = [];
     for (let i = 0, i_finish = updatedEntities.length; i < i_finish; ++i) {
@@ -1065,7 +1147,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
       sinkPromise = undefined;
     }
     let primaryTimerRef = Hrtime.makeTimer();
-    await writeBatch(sql, batch, rawEvents, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, pgUpdates, sinkPromise, undefined);
+    await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, pgUpdates, sinkPromise, chainMetaData, undefined);
     return Prometheus.StorageWrite.increment("postgres", Hrtime.toSecondsFloat(Hrtime.timeSince(primaryTimerRef)));
   };
   let close = () => sql.end();
@@ -1162,9 +1244,11 @@ export {
   maxItemsPerQuery,
   makeTableBatchSetQuery,
   chunkArray,
+  removeInvalidUtf8DeepInPlace,
   removeInvalidUtf8InPlace,
   pgErrorMessageSchema,
   PgEncodingError,
+  classifyWriteError,
   setQueryCache,
   setOrThrow,
   makeSchemaTableNamesQuery,
@@ -1174,6 +1258,8 @@ export {
   deleteByIdsOrThrow,
   makeInsertDeleteUpdatesQuery,
   executeSet,
+  convertFieldsToJson,
+  makeRawEvent,
   writeBatch,
   makeGetRollbackRestoredEntitiesQuery,
   makeGetRollbackRemovedIdsQuery,

package/src/RollbackCommit.res

@@ -0,0 +1,32 @@
+// Temporary, internal-only support for the unstable
+// `indexer.~internalAndWillBeRemovedSoon_onRollbackCommit` API. The whole
+// feature lives here plus two call sites: registration in `Main.res` and the
+// fire on a successful rollback write in `InMemoryStore.res`. Delete those
+// together with this module.
+type args = {chainId: int, rollbackToBlock: int}
+type callback = args => promise<unit>
+
+let callbacks: array<callback> = []
+
+let register = (callback: callback) => {
+  callbacks->Array.push(callback)
+  () =>
+    switch callbacks->Array.indexOf(callback) {
+    | -1 => ()
+    | index => callbacks->Array.splice(~start=index, ~remove=1, ~insert=[])
+    }
+}
+
+// Fired after a rollback diff is durably written, once per affected chain.
+// `progressBlockNumberByChainId` is the last valid block per chain, taken from
+// the in-memory store's rollback object. A throwing callback bubbles to the
+// write loop's onError, crashing the indexer like a failed write.
+let fire = async (~progressBlockNumberByChainId: dict<int>) => {
+  let _ = await progressBlockNumberByChainId
+  ->Dict.toArray
+  ->Array.flatMap(((chainIdKey, rollbackToBlock)) => {
+    let args = {chainId: chainIdKey->Int.fromString->Option.getUnsafe, rollbackToBlock}
+    callbacks->Array.map(callback => callback(args))
+  })
+  ->Promise.all
+}

package/src/RollbackCommit.res.mjs

@@ -0,0 +1,35 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+
+let callbacks = [];
+
+function register(callback) {
+  callbacks.push(callback);
+  return () => {
+    let index = callbacks.indexOf(callback);
+    if (index !== -1) {
+      callbacks.splice(index, 1);
+      return;
+    }
+  };
+}
+
+async function fire(progressBlockNumberByChainId) {
+  await Promise.all(Object.entries(progressBlockNumberByChainId).flatMap(param => {
+    let args_chainId = Stdlib_Int.fromString(param[0], undefined);
+    let args_rollbackToBlock = param[1];
+    let args = {
+      chainId: args_chainId,
+      rollbackToBlock: args_rollbackToBlock
+    };
+    return callbacks.map(callback => callback(args));
+  }));
+}
+
+export {
+  callbacks,
+  register,
+  fire,
+}
+/* No side effect */

package/src/TestIndexerProxyStorage.res

@@ -131,13 +131,13 @@ let makeStorage = (proxy: t): Persistence.storage => {
   },
   writeBatch: async (
     ~batch,
-    ~rawEvents as _,
     ~rollback as _,
     ~isInReorgThreshold as _,
     ~config as _,
     ~allEntities as _,
     ~updatedEffectsCache as _,
     ~updatedEntities,
+    ~chainMetaData as _,
   ) => {
     // Encode entities to JSON for serialization across worker boundary
     let serializableEntities = updatedEntities->Array.map((

package/src/TestIndexerProxyStorage.res.mjs

@@ -77,7 +77,7 @@ function makeStorage(proxy) {
     getRollbackTargetCheckpoint: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config."),
     getRollbackProgressDiff: async param => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config."),
     getRollbackData: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config."),
-    writeBatch: async (batch, param, param$1, param$2, param$3, param$4, param$5, updatedEntities) => {
+    writeBatch: async (batch, param, param$1, param$2, param$3, param$4, updatedEntities, param$5) => {
       let serializableEntities = updatedEntities.map(param => {
         let entityConfig = param.entityConfig;
         let encodeChange = change => {