envio 3.9.0 → 3.10.0

package/src/Sink.res

@@ -1,44 +1,56 @@
 type t = {
   name: string,
-  initialize: (
-    ~chainConfigs: array<Config.chain>=?,
-    ~entities: array<Internal.entityConfig>=?,
-    ~enums: array<Table.enumConfig<Table.enum>>=?,
+  initialize: (~entities: array<Internal.entityConfig>) => promise<unit>,
+  resume: (
+    ~checkpointId: Internal.checkpointId,
+    ~chains: array<Persistence.initialChainState>,
+    ~entities: array<Internal.entityConfig>,
   ) => promise<unit>,
-  resume: (~checkpointId: Internal.checkpointId) => promise<unit>,
   writeBatch: (
     ~batch: Batch.t,
     ~updatedEntities: array<Persistence.updatedEntity>,
   ) => promise<unit>,
 }
 
-let makeClickHouse = (~host, ~database, ~username, ~password, ~chainIdMode: ChainId.mode=Int32): t => {
-  let client = ClickHouse.createClient({
-    url: host,
-    username,
-    password,
-  })
-
-  // Don't pass database to the client; it would fail if the database doesn't
-  // exist yet. Each query qualifies the name explicitly or runs USE first.
-
-  let cache = Dict.make()
+let makeClickHouse = (
+  ~host,
+  ~database,
+  ~username,
+  ~password,
+  ~chainIdMode: ChainId.mode=Int32,
+): t => {
+  let sink = ClickHouse.makeSink(~host, ~username, ~password, ~database, ~chainIdMode)
+  let registry = ClickHouse.makeRegistry()
+  let mirrored = (entities: array<Internal.entityConfig>) =>
+    entities->Array.filter(e => e.storage.clickhouse)
 
   {
     name: "clickhouse",
-    initialize: (~chainConfigs as _=[], ~entities=[], ~enums=[]) => {
-      ClickHouse.initialize(client, ~database, ~entities, ~enums, ~chainIdMode)
+    initialize: (~entities) => {
+      ClickHouse.initialize(sink, ~entities=mirrored(entities))
     },
-    resume: (~checkpointId) => {
-      ClickHouse.resume(client, ~database, ~checkpointId)
+    resume: (~checkpointId, ~chains, ~entities) => {
+      ClickHouse.resume(sink, ~checkpointId, ~chains, ~entities=mirrored(entities))
     },
     writeBatch: async (~batch, ~updatedEntities) => {
-      await Promise.all(
-        updatedEntities->Array.map(({entityConfig, scope, changes}) => {
-          ClickHouse.setUpdatesOrThrow(client, ~cache, ~changes, ~entityConfig, ~scope, ~database)
-        }),
-      )->Utils.Promise.ignoreValue
-      await ClickHouse.setCheckpointsOrThrow(client, ~batch, ~database)
+      // Staging reads JS values, so it holds the isolate and runs here. The
+      // encode and the round trips happen in Rust, which also keeps the
+      // checkpoints behind the rows they cover.
+      let entities = []
+      let checkpoints = try {
+        updatedEntities->Array.forEach(({entityConfig, scope, changes}) =>
+          switch ClickHouse.stageUpdatesOrThrow(sink, ~registry, ~changes, ~entityConfig, ~scope) {
+          | Some(handle) => entities->Array.push(handle)
+          | None => ()
+          }
+        )
+        ClickHouse.stageCheckpointsOrThrow(sink, ~registry, ~batch)
+      } catch {
+      | exn =>
+        sink->ClickHouseSink.discard(entities)
+        throw(exn)
+      }
+      await ClickHouse.writeStagedOrThrow(sink, ~entities, ~checkpoints)
     },
   }
 }

package/src/Sink.res.mjs

@@ -1,28 +1,33 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as ClickHouse from "./bindings/ClickHouse.res.mjs";
-import * as Client from "@clickhouse/client";
 
 function makeClickHouse(host, database, username, password, chainIdModeOpt) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
-  let client = Client.createClient({
-    url: host,
-    username: username,
-    password: password
-  });
-  let cache = {};
+  let sink = ClickHouse.makeSink(host, username, password, database, chainIdMode);
+  let registry = ClickHouse.makeRegistry();
+  let mirrored = entities => entities.filter(e => e.storage.clickhouse);
   return {
     name: "clickhouse",
-    initialize: ($staropt$star, $staropt$star$1, $staropt$star$2) => {
-      $staropt$star !== undefined;
-      let entities = $staropt$star$1 !== undefined ? $staropt$star$1 : [];
-      let enums = $staropt$star$2 !== undefined ? $staropt$star$2 : [];
-      return ClickHouse.initialize(client, database, entities, enums, chainIdMode);
-    },
-    resume: checkpointId => ClickHouse.resume(client, database, checkpointId),
+    initialize: entities => ClickHouse.initialize(sink, mirrored(entities)),
+    resume: (checkpointId, chains, entities) => ClickHouse.resume(sink, checkpointId, chains, mirrored(entities)),
     writeBatch: async (batch, updatedEntities) => {
-      await Promise.all(updatedEntities.map(param => ClickHouse.setUpdatesOrThrow(client, cache, param.changes, param.entityConfig, param.scope, database)));
-      return await ClickHouse.setCheckpointsOrThrow(client, batch, database);
+      let entities = [];
+      let checkpoints;
+      try {
+        updatedEntities.forEach(param => {
+          let handle = ClickHouse.stageUpdatesOrThrow(sink, registry, param.changes, param.entityConfig, param.scope);
+          if (handle !== undefined) {
+            entities.push(handle);
+            return;
+          }
+        });
+        checkpoints = ClickHouse.stageCheckpointsOrThrow(sink, registry, batch);
+      } catch (exn) {
+        sink.discard(entities);
+        throw exn;
+      }
+      return await ClickHouse.writeStagedOrThrow(sink, entities, checkpoints);
     }
   };
 }

package/src/TestIndexer.res

@@ -589,7 +589,7 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     JsError.throwWithMessage(
       "TestIndexer: initialize should not be called; the initial state is derived from config.",
     ),
-  resumeInitialState: async () =>
+  resumeInitialState: async (~entities as _, ~throwIfIncompatible as _) =>
     JsError.throwWithMessage(
       "TestIndexer: resumeInitialState should not be called; the initial state is derived from config.",
     ),
@@ -625,22 +625,22 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
   dumpEffectCache: async () => (),
   reset: async () => (),
   setChainMeta: async _ => Obj.magic(),
-  pruneStaleCheckpoints: async (~safeCheckpointId as _) => (),
+  pruneStaleCheckpoints: async (~safeCheckpoints as _) => (),
   pruneStaleEntityHistory: async (
     ~entityName as _,
     ~entityIndex as _,
     ~chainIdColumn as _,
-    ~safeCheckpointId as _,
+    ~safeCheckpoints as _,
   ) => (),
   getRollbackTargetCheckpoint: async (~reorgChainId as _, ~lastKnownValidBlockNumber as _) =>
     JsError.throwWithMessage(
       "TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable.",
     ),
-  getRollbackProgressDiff: async (~rollbackTargetCheckpointId as _) =>
+  getRollbackProgressDiff: async (~floors as _) =>
     JsError.throwWithMessage(
       "TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable.",
     ),
-  getRollbackData: async (~entityConfig as _, ~rollbackTargetCheckpointId as _) =>
+  getRollbackData: async (~entityConfig as _, ~floors as _) =>
     JsError.throwWithMessage(
       "TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable.",
     ),

package/src/TestIndexer.res.mjs

@@ -385,7 +385,7 @@ function makeInMemoryStorage(state) {
     name: "test-inmemory",
     isInitialized: async () => true,
     initialize: async (param, param$1, param$2, param$3, param$4) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
-    resumeInitialState: async () => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
+    resumeInitialState: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
     loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
     ensureQueryIndexes: async (param, param$1) => {},
     ensureSchemaIndexes: async param => {},

package/src/Utils.res

@@ -18,6 +18,33 @@ external importPathWithJson: (
   "default": JSON.t,
 }> = "import"
 
+// Half the delay fixed, half spread across it. Every indexer pointed at one
+// provider loses its stream, or gives up on a quiet chain, in the same instant
+// that provider blinks, and putting them all back on the same schedule is how a
+// blip becomes a stampede.
+let jitter = delay => delay / 2 + (Math.random() *. (delay / 2)->Int.toFloat)->Float.toInt
+
+// Clearing a pending timer and forgetting it are one action. A ref left holding
+// a spent id reads as a timer still pending, and the next clear looks like it
+// did something.
+let clearTimeoutRef = timeoutId => {
+  switch timeoutId.contents {
+  | Some(id) => clearTimeout(id)
+  | None => ()
+  }
+  timeoutId := None
+}
+
+// Keeps the doubling from overflowing on something that has been failing for
+// days. Every caller's delay reaches its cap long before this.
+let maxBackoffExponent = 20
+
+let expBackoff = (~base, ~exp, ~maxMillis) =>
+  Pervasives.min(
+    base * Math.pow(2.0, ~exp=Pervasives.min(exp, maxBackoffExponent)->Int.toFloat)->Float.toInt,
+    maxMillis,
+  )
+
 let delay = milliseconds =>
   Promise.make((resolve, _) => {
     let _interval = setTimeout(_ => {
@@ -97,6 +124,15 @@ module Dict = {
   @get_index
   external dangerouslyGetNonOption: (dict<'a>, string) => option<'a> = ""
 
+  let incrementBy = (dict, key, count) =>
+    dict->Dict.set(
+      key,
+      switch dict->dangerouslyGetNonOption(key) {
+      | Some(current) => current + count
+      | None => count
+      },
+    )
+
   let getOrInsertEmptyDict = (dict, key) => {
     switch dict->dangerouslyGetNonOption(key) {
     | Some(d) => d
@@ -253,6 +289,10 @@ module Array = {
 
   let immutableEmpty: array<unknown> = []
 
+  /** Render names for an error message: `"a", "b"`. */
+  let quotedJoin = (names: array<string>) =>
+    names->Array.map(name => `"${name}"`)->Array.joinUnsafe(", ")
+
   @send
   external forEachAsync: (array<'a>, 'a => promise<unit>) => unit = "forEach"
 
@@ -491,9 +531,120 @@ let unwrapResultExn = res =>
 
 external queueMicrotask: (unit => unit) => unit = "queueMicrotask"
 
+module Bytes = {
+  let asUint8Array: unknown => option<Uint8Array.t> = %raw(`(value) =>
+    value instanceof Uint8Array
+      ? value.constructor === Uint8Array
+        ? value
+        : new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+      : undefined`)
+
+  let toHex = (bytes: Uint8Array.t) =>
+    NodeJs.Buffer.fromArrayBuffer(
+      bytes->TypedArray.buffer,
+      ~byteOffset=bytes->TypedArray.byteOffset,
+      ~length=bytes->TypedArray.byteLength,
+    )->NodeJs.Buffer.toHex
+
+  @get_index external byteAt: (Uint8Array.t, int) => int = ""
+
+  // A bytea[] parameter as the array literal Postgres parses itself. postgres.js
+  // serializes an array parameter with the element serializer of the type the
+  // server describes, and the bytea one expects a Uint8Array — yet it types the
+  // array after its first element, so an array of Uint8Arrays binds as a single
+  // bytea. Text binds untyped and reaches the server's array parser as it is.
+  //
+  // Nests, since an `in` filter over a list column carries one array per
+  // candidate value. A sub-array is written unquoted, which is how Postgres
+  // spells a dimension rather than an element.
+  let rec toPgArrayLiteral = (values: array<unknown>) =>
+    "{" ++
+    values
+    ->Array.map(value =>
+      switch value->(magic: unknown => Nullable.t<unknown>)->Nullable.toOption {
+      | None => "NULL"
+      | Some(value) =>
+        switch value->asUint8Array {
+        | Some(bytes) => `"\\\\x${bytes->toHex}"`
+        | None =>
+          if value->Array.isArray {
+            value->(magic: unknown => array<unknown>)->toPgArrayLiteral
+          } else {
+            JsError.throwWithMessage("Expected Uint8Array")
+          }
+        }
+      }
+    )
+    ->Array.join(",") ++ "}"
+
+  // Bytewise, the order Postgres sorts a bytea in.
+  let compare = (a: Uint8Array.t, b: Uint8Array.t) => {
+    let aLength = a->TypedArray.length
+    let bLength = b->TypedArray.length
+    let rec loop = index =>
+      if index === aLength || index === bLength {
+        Int.compare(aLength, bLength)
+      } else {
+        switch Int.compare(a->byteAt(index), b->byteAt(index)) {
+        | 0. => loop(index + 1)
+        | order => order
+        }
+      }
+    loop(0)
+  }
+}
+
 module Schema = {
   let variantTag = S.union([S.string, S.object(s => s.field("TAG", S.string))])
 
+  // A ReScript `option` is `undefined` at runtime, so `S.null`'s serializer
+  // treats only `undefined` as the empty case — a genuine `null`, which a JS
+  // handler writes for a field it doesn't set, reaches the value serializer
+  // and crashes it (`null.toString()` for a BigInt column). Collapse both to
+  // `None` before the value serializer sees them.
+  //
+  // Revisit on the Sury v11 migration: if its nullable handles a `null` value
+  // on the serialize side, this wrapper goes away.
+  let nullTolerant = schema =>
+    S.null(schema)->S.transform(_ => {
+      parser: value => value,
+      serializer: value => value->(magic: option<'a> => Nullable.t<'a>)->Nullable.toOption,
+    })
+
+  // Postgres hands a bytea back as a Buffer, while handlers are promised the
+  // plain Uint8Array of the entity type — Buffer's `slice` and `toString` behave
+  // differently.
+  let bytes = S.custom("Bytes", s => {
+    parser: unknown =>
+      switch unknown->Bytes.asUint8Array {
+      | Some(bytes) => bytes
+      | None => s.fail("Expected Uint8Array")
+      },
+    serializer: (bytes: Uint8Array.t) => bytes,
+  })
+
+  // A bytea[] value: a list column, or the values an `in` filter compares
+  // against — one array per candidate when the column is itself a list, which
+  // the literal writer nests. Only a column is ever read back, so the parser
+  // takes the one level a bytea[] column returns.
+  let bytesArray = S.custom("BytesArray", s => {
+    parser: unknown =>
+      if unknown->Array.isArray {
+        unknown
+        ->(magic: unknown => array<unknown>)
+        ->Array.map(item =>
+          switch item->Bytes.asUint8Array {
+          | Some(bytes) => bytes
+          | None => s.fail("Expected Uint8Array")
+          }
+        )
+      } else {
+        s.fail("Expected array of Uint8Array")
+      },
+    serializer: (values: array<Uint8Array.t>) =>
+      values->(magic: array<Uint8Array.t> => array<unknown>)->Bytes.toPgArrayLiteral,
+  })
+
   // Don't use S.unknown, since it's not serializable to json
   // In a nutshell, this is completely unsafe.
   let dbDate =
@@ -501,6 +652,19 @@ module Schema = {
     ->(magic: S.t<JSON.t> => S.t<Date.t>)
     ->S.preprocess(_ => {serializer: date => date->magic->Date.toISOString})
 
+  // JSON `null` is a document, and Postgres stores it as one. Reaching the
+  // ClickHouse sink as a JS `null` it would instead read as a field the handler
+  // never set, which a String column has no way to hold — so it travels as the
+  // text it would have been serialized to. Every other document is left for the
+  // sink to serialize.
+  let clickHouseJson = S.json(~validate=false)->S.preprocess(_ => {
+    serializer: value =>
+      switch value->(magic: unknown => Nullable.t<unknown>)->Nullable.toOption {
+      | None => "null"->magic
+      | Some(json) => json
+      },
+  })
+
   // ClickHouse expects timestamps as numbers (milliseconds), not ISO strings
   let clickHouseDate =
     S.json(~validate=false)
@@ -761,6 +925,12 @@ let prettifyExn = exn => {
   }
 }
 
+let exnMessage = exn =>
+  switch exn->JsExn.anyToExnInternal {
+  | JsExn(jsExn) => jsExn->JsExn.message
+  | _ => None
+  }
+
 module EnvioPackage = {
   type t = {version: string}
 

package/src/Utils.res.mjs

@@ -3,6 +3,8 @@ import packageJson from '../package.json' with { type: 'json' }
 
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_BigInt from "@rescript/runtime/lib/es6/Stdlib_BigInt.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
@@ -14,6 +16,22 @@ import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
+function jitter(delay) {
+  return (delay / 2 | 0) + (Math.random() * (delay / 2 | 0) | 0) | 0;
+}
+
+function clearTimeoutRef(timeoutId) {
+  let id = timeoutId.contents;
+  if (id !== undefined) {
+    clearTimeout(Primitive_option.valFromOption(id));
+  }
+  timeoutId.contents = undefined;
+}
+
+function expBackoff(base, exp, maxMillis) {
+  return Primitive_int.min(base * (Math.pow(2.0, Primitive_int.min(exp, 20)) | 0) | 0, maxMillis);
+}
+
 function delay(milliseconds) {
   return new Promise((resolve, param) => {
     setTimeout(() => resolve(), milliseconds);
@@ -61,6 +79,11 @@ let Option = {
   getExn: getExn
 };
 
+function incrementBy(dict, key, count) {
+  let current = dict[key];
+  dict[key] = current !== undefined ? current + count | 0 : count;
+}
+
 function getOrInsertEmptyDict(dict, key) {
   let d = dict[key];
   if (d !== undefined) {
@@ -169,6 +192,7 @@ let shallowCopy = ((dict) => ({...dict}));
 
 let Dict = {
   $$delete: Stdlib_Dict.$$delete,
+  incrementBy: incrementBy,
   getOrInsertEmptyDict: getOrInsertEmptyDict,
   push: push,
   pushMany: pushMany,
@@ -211,6 +235,10 @@ let UnsafeIntOperators = {};
 
 let immutableEmpty = [];
 
+function quotedJoin(names) {
+  return names.map(name => `"` + name + `"`).join(", ");
+}
+
 function mergeSorted(f, xs, ys) {
   if (xs.length === 0) {
     return ys;
@@ -393,6 +421,7 @@ let $$Array$1 = {
   partition: Stdlib_Array.partition,
   unzip: Stdlib_Array.unzip,
   immutableEmpty: immutableEmpty,
+  quotedJoin: quotedJoin,
   mergeSorted: mergeSorted,
   clearInPlace: clearInPlace$1,
   setIndexImmutable: setIndexImmutable,
@@ -462,15 +491,120 @@ function unwrapResultExn(res) {
   throw res._0;
 }
 
+let asUint8Array = ((value) =>
+    value instanceof Uint8Array
+      ? value.constructor === Uint8Array
+        ? value
+        : new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+      : undefined);
+
+function toHex(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("hex");
+}
+
+function toPgArrayLiteral(values) {
+  return "{" + values.map(value => {
+    if (value == null) {
+      return "NULL";
+    }
+    let bytes = asUint8Array(value);
+    if (bytes !== undefined) {
+      return `"\\\\x` + toHex(bytes) + `"`;
+    } else if (Array.isArray(value)) {
+      return toPgArrayLiteral(value);
+    } else {
+      return Stdlib_JsError.throwWithMessage("Expected Uint8Array");
+    }
+  }).join(",") + "}";
+}
+
+function compare(a, b) {
+  let aLength = a.length;
+  let bLength = b.length;
+  let _index = 0;
+  while (true) {
+    let index = _index;
+    if (index === aLength || index === bLength) {
+      return Primitive_int.compare(aLength, bLength);
+    }
+    let order = Primitive_int.compare(a[index], b[index]);
+    if (order !== 0) {
+      return order;
+    }
+    _index = index + 1 | 0;
+    continue;
+  };
+}
+
+let Bytes = {
+  asUint8Array: asUint8Array,
+  toHex: toHex,
+  toPgArrayLiteral: toPgArrayLiteral,
+  compare: compare
+};
+
 let variantTag = S$RescriptSchema.union([
   S$RescriptSchema.string,
   S$RescriptSchema.object(s => s.f("TAG", S$RescriptSchema.string))
 ]);
 
+function nullTolerant(schema) {
+  return S$RescriptSchema.transform(S$RescriptSchema.$$null(schema), param => ({
+    p: value => value,
+    s: value => {
+      if (value == null) {
+        return;
+      } else {
+        return Primitive_option.some(value);
+      }
+    }
+  }));
+}
+
+let bytes = S$RescriptSchema.custom("Bytes", s => ({
+  p: unknown => {
+    let bytes = asUint8Array(unknown);
+    if (bytes !== undefined) {
+      return bytes;
+    } else {
+      return s.fail("Expected Uint8Array", undefined);
+    }
+  },
+  s: bytes => bytes
+}));
+
+let bytesArray = S$RescriptSchema.custom("BytesArray", s => ({
+  p: unknown => {
+    if (Array.isArray(unknown)) {
+      return unknown.map(item => {
+        let bytes = asUint8Array(item);
+        if (bytes !== undefined) {
+          return bytes;
+        } else {
+          return s.fail("Expected Uint8Array", undefined);
+        }
+      });
+    } else {
+      return s.fail("Expected array of Uint8Array", undefined);
+    }
+  },
+  s: toPgArrayLiteral
+}));
+
 let dbDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), param => ({
   s: date => date.toISOString()
 }));
 
+let clickHouseJson = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), param => ({
+  s: value => {
+    if (value == null) {
+      return "null";
+    } else {
+      return value;
+    }
+  }
+}));
+
 let clickHouseDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), param => ({
   s: date => date.getTime()
 }));
@@ -506,7 +640,11 @@ function coerceToJsonPgType(schema) {
 
 let Schema = {
   variantTag: variantTag,
+  nullTolerant: nullTolerant,
+  bytes: bytes,
+  bytesArray: bytesArray,
   dbDate: dbDate,
+  clickHouseJson: clickHouseJson,
   clickHouseDate: clickHouseDate,
   coerceToJsonPgType: coerceToJsonPgType
 };
@@ -640,6 +778,13 @@ function prettifyExn(exn) {
   }
 }
 
+function exnMessage(exn) {
+  let jsExn = Primitive_exceptions.internalToException(exn);
+  if (jsExn.RE_EXN_ID === "JsExn") {
+    return Stdlib_JsExn.message(jsExn._1);
+  }
+}
+
 let value;
 
 try {
@@ -695,7 +840,13 @@ let $$Promise$1 = {
   isCatchable: isCatchable
 };
 
+let maxBackoffExponent = 20;
+
 export {
+  jitter,
+  clearTimeoutRef,
+  maxBackoffExponent,
+  expBackoff,
   delay,
   $$Object,
   $$Error,
@@ -708,6 +859,7 @@ export {
   Url,
   Result,
   unwrapResultExn,
+  Bytes,
   Schema,
   getVariantsTags,
   $$Set,
@@ -717,6 +869,7 @@ export {
   $$Proxy,
   Hash,
   prettifyExn,
+  exnMessage,
   EnvioPackage,
   $$BigInt,
   $$Promise$1 as $$Promise,

package/src/Writing.res

@@ -158,8 +158,8 @@ let runOneWrite = async (state: IndexerState.t) => {
     state->IndexerState.markCommitted(~upToCheckpointId)
 
     switch rollback {
-    | Some({progressBlockNumberByChainId}) if RollbackCommit.callbacks->Utils.Array.notEmpty =>
-      await RollbackCommit.fire(~progressBlockNumberByChainId)
+    | Some({progressedChains}) if RollbackCommit.callbacks->Utils.Array.notEmpty =>
+      await RollbackCommit.fire(~progressedChains)
     | _ => ()
     }
 

package/src/Writing.res.mjs

@@ -130,7 +130,7 @@ async function runOneWrite(state) {
   ]);
   IndexerState.markCommitted(state, upToCheckpointId);
   if (rollback !== undefined && Utils.$$Array.notEmpty(RollbackCommit.callbacks)) {
-    await RollbackCommit.fire(rollback.progressBlockNumberByChainId);
+    await RollbackCommit.fire(rollback.progressedChains);
   }
   return await PruneStaleHistory.runForced(state, pruneTargets);
 }