envio 3.9.0 → 3.10.0-subgraph

package/src/EventConfigBuilder.res.mjs

@@ -14,6 +14,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 let paramMetaSchema = S$RescriptSchema.recursive(self => S$RescriptSchema.object(s => ({
   name: s.f("name", S$RescriptSchema.string),
@@ -261,17 +262,13 @@ let svmSelectionKinds = [
   "log"
 ];
 
-function quotedJoin(names) {
-  return names.map(name => `"` + name + `"`).join(", ");
-}
-
 function validateFieldsShapeOrThrow(fields, registration, validKeys, shapeNoun) {
   if (typeof fields !== "object" || fields === null || Array.isArray(fields)) {
     Stdlib_JsError.throwWithMessage(`The fields option of ` + registration + ` must be an object of ` + shapeNoun + ` field names.`);
   }
   Object.keys(fields).forEach(key => {
     if (!validKeys.includes(key)) {
-      return Stdlib_JsError.throwWithMessage(`Invalid "` + key + `" key in the fields option of ` + registration + `. Valid keys: ` + quotedJoin(validKeys) + `.`);
+      return Stdlib_JsError.throwWithMessage(`Invalid "` + key + `" key in the fields option of ` + registration + `. Valid keys: ` + Utils.$$Array.quotedJoin(validKeys) + `.`);
     }
   });
 }
@@ -295,7 +292,7 @@ function parseFieldsOrThrow(fields, valid, kind, registration, rejectEmptyOpt) {
     ) : [];
   fields$1.forEach(name => {
     if (!valid.has(name)) {
-      Stdlib_JsError.throwWithMessage(`Invalid "` + name + `" field in the fields.` + kind + ` option of ` + registration + `. Valid ` + kind + ` fields: ` + quotedJoin(Array.from(valid)) + `.`);
+      Stdlib_JsError.throwWithMessage(`Invalid "` + name + `" field in the fields.` + kind + ` option of ` + registration + `. Valid ` + kind + ` fields: ` + Utils.$$Array.quotedJoin(Array.from(valid)) + `.`);
     }
     if (seen.has(name)) {
       Stdlib_JsError.throwWithMessage(`Duplicate "` + name + `" field in the fields.` + kind + ` option of ` + registration + `.`);
@@ -420,7 +417,7 @@ let validSvmLogFields = new Set([
 ]);
 
 function resolveSvmInlineFieldSelection(fields, contractName, eventName) {
-  let registration = `the "` + eventName + `" event registration on contract "` + contractName + `"`;
+  let registration = `the "` + eventName + `" instruction on program "` + contractName + `"`;
   validateFieldsShapeOrThrow(fields, registration, svmSelectionKinds, "instruction, transaction, accountActivity, block and log");
   let accountActivity = selectionList(fields, "accountActivity");
   let log = selectionList(fields, "log");
@@ -436,7 +433,7 @@ function resolveSvmInlineFieldSelection(fields, contractName, eventName) {
   return Internal.makeFieldSelection(blockFields, transactionFields, Primitive_option.some(instructionFields), Primitive_option.some(accountActivityFields), Primitive_option.some(logFields), Svm.eventBlockFieldMask, Svm.eventTransactionFieldMask);
 }
 
-function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, accountFilters, isInner, accountsOpt, argsOpt, definedTypesOpt) {
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, accountsOpt, argsOpt, definedTypesOpt) {
   let accounts = accountsOpt !== undefined ? accountsOpt : [];
   let args = argsOpt !== undefined ? argsOpt : null;
   let definedTypes = definedTypesOpt !== undefined ? definedTypesOpt : null;
@@ -451,16 +448,121 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
     fieldSelection: fieldSelection,
     programId: programId,
     discriminator: discriminator,
-    discriminatorByteLen: discriminatorByteLen,
-    accountFilters: accountFilters,
-    isInner: isInner,
     accounts: accounts,
     args: args,
     definedTypes: definedTypes
   };
 }
 
-function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, fieldSelection, startBlock) {
+let validSvmWhereKeys = [
+  "accounts",
+  "isInner",
+  "block"
+];
+
+let svmBlockFilterSchema = S$RescriptSchema.strict(S$RescriptSchema.object(s => ({
+  slot: s.f("slot", S$RescriptSchema.option(LogSelection.eventBlockRangeSchema))
+})));
+
+function resolveSvmWhereOrThrow(where, contractName, eventName, accountNames) {
+  let invalid = message => Stdlib_JsError.throwWithMessage(`Invalid where configuration for the "` + eventName + `" instruction on program "` + contractName + `". ` + message);
+  let obj;
+  obj = typeof where === "object" && where !== null && !Array.isArray(where) ? where : invalid("Expected an object.");
+  Utils.Dict.forEachWithKey(obj, (param, key) => {
+    if (!validSvmWhereKeys.includes(key)) {
+      return invalid(`Unknown field "` + key + `". Valid fields: ` + Utils.$$Array.quotedJoin(validSvmWhereKeys) + `.`);
+    }
+  });
+  let match = obj["isInner"];
+  let isInner = match !== undefined ? (
+      typeof match === "boolean" ? match : invalid(`The "isInner" filter must be a boolean.`)
+    ) : undefined;
+  let parseGroup = group => Object.entries(group).map(param => {
+    let name = param[0];
+    let position = accountNames.indexOf(name);
+    let position$1 = position !== -1 ? (
+        position >= 10 ? invalid(`Account "` + name + `" is at position ` + position.toString() + `, and only the first ` + (10).toString() + ` accounts of an instruction can be filtered.`) : position
+      ) : (
+        Utils.$$Array.isEmpty(accountNames) ? invalid("The instruction has no named accounts to filter on. Add `accounts` and `args` to it in config.yaml, or attach an IDL.") : invalid(`The instruction has no account named "` + name + `" to filter on. Named accounts: ` + Utils.$$Array.quotedJoin(accountNames) + `.`)
+      );
+    let values = normalizeOrThrow(param[1]);
+    if (Utils.$$Array.isEmpty(values)) {
+      invalid(`The "` + name + `" filter must list at least one pubkey.`);
+    }
+    return {
+      position: position$1,
+      values: values.map(value => {
+        if (typeof value === "string") {
+          if (Core.getAddon().isSvmPubkey(value)) {
+            return value;
+          } else {
+            return invalid(`The "` + name + `" filter value "` + value + `" is not a base58 SVM pubkey.`);
+          }
+        } else {
+          return invalid(`The "` + name + `" filter must list base58 pubkeys as strings.`);
+        }
+      })
+    };
+  });
+  let match$1 = obj["accounts"];
+  let groups;
+  if (match$1 !== undefined) {
+    if (Array.isArray(match$1)) {
+      groups = match$1.map(entry => {
+        if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+          return parseGroup(entry);
+        } else {
+          return invalid(`Each entry in "accounts" must be an object.`);
+        }
+      });
+    } else if (match$1 === null) {
+      groups = invalid(`Expected "accounts" to be an object or an array of objects.`);
+    } else {
+      switch (typeof match$1) {
+        case "object" :
+          groups = [parseGroup(match$1)];
+          break;
+        default:
+          groups = invalid(`Expected "accounts" to be an object or an array of objects.`);
+      }
+    }
+  } else {
+    groups = [];
+  }
+  let accountFilters = groups.some(Utils.$$Array.isEmpty) ? [] : groups;
+  let block = obj["block"];
+  let startBlock;
+  if (block !== undefined) {
+    let filter;
+    try {
+      filter = S$RescriptSchema.parseOrThrow(block, svmBlockFilterSchema);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (exn.RE_EXN_ID === S$RescriptSchema.Raised) {
+        filter = invalid(`The "block" filter is invalid: ` + Utils.prettifyExn(exn._1) + `. Only \`_gte\` is supported on instruction filters — use \`indexer.onSlot\` for \`_lte\` or \`_every\`.`);
+      } else {
+        throw exn;
+      }
+    }
+    let match$2 = filter.slot;
+    startBlock = match$2 !== undefined ? match$2._gte : undefined;
+  } else {
+    startBlock = undefined;
+  }
+  return {
+    accountFilters: accountFilters,
+    isInner: isInner,
+    startBlock: startBlock
+  };
+}
+
+function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, where, fieldSelection, startBlock) {
+  let resolvedWhere = where !== undefined ? resolveSvmWhereOrThrow(where, eventConfig.contractName, eventConfig.name, eventConfig.accounts) : ({
+      accountFilters: [],
+      isInner: undefined,
+      startBlock: undefined
+    });
+  let sb = resolvedWhere.startBlock;
   return {
     index: -1,
     eventConfig: eventConfig,
@@ -469,8 +571,10 @@ function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractR
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
-    startBlock: startBlock,
-    fieldSelection: fieldSelection !== undefined ? fieldSelection : eventConfig.fieldSelection
+    startBlock: sb !== undefined ? sb : startBlock,
+    fieldSelection: fieldSelection !== undefined ? fieldSelection : eventConfig.fieldSelection,
+    accountFilters: resolvedWhere.accountFilters,
+    isInner: resolvedWhere.isInner
   };
 }
 
@@ -542,6 +646,8 @@ function buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contract
   };
 }
 
+let filterableAccountCount = 10;
+
 export {
   paramMetaSchema,
   normalizeOrThrow,
@@ -561,7 +667,6 @@ export {
   rawEventBlockFields,
   evmSelectionKinds,
   svmSelectionKinds,
-  quotedJoin,
   validateFieldsShapeOrThrow,
   selectionList,
   validBlockFields,
@@ -578,6 +683,10 @@ export {
   validSvmLogFields,
   resolveSvmInlineFieldSelection,
   buildSvmInstructionEventConfig,
+  validSvmWhereKeys,
+  svmBlockFilterSchema,
+  filterableAccountCount,
+  resolveSvmWhereOrThrow,
   buildSvmOnEventRegistration,
   buildFuelEventConfig,
   buildFuelOnEventRegistration,

package/src/EventProcessing.res

@@ -51,7 +51,7 @@ let runEventHandlerOrThrow = async (
       isPreload: false,
       chains,
       config,
-      isResolved: false,
+      sync: UserContext.makeSyncState(),
     }
     await handler(
       (
@@ -61,7 +61,7 @@ let runEventHandlerOrThrow = async (
         }: Internal.handlerArgs
       ),
     )
-    contextParams.isResolved = true
+    contextParams.sync.status = Resolved
   } catch {
   | exn =>
     throw(
@@ -102,7 +102,7 @@ let runHandlerOrThrow = async (
         isPreload: false,
         chains,
         config,
-        isResolved: false,
+        sync: UserContext.makeSyncState(),
       }
       await handler(
         Ecosystem.makeOnBlockArgs(
@@ -111,7 +111,7 @@ let runHandlerOrThrow = async (
           ~context=UserContext.getHandlerContext(contextParams),
         ),
       )
-      contextParams.isResolved = true
+      contextParams.sync.status = Resolved
     } catch {
     | exn =>
       throw(
@@ -186,7 +186,7 @@ let preloadBatchOrThrow = async (
                   checkpointId,
                   isPreload: true,
                   chains,
-                  isResolved: false,
+                  sync: UserContext.makeSyncState(),
                   config,
                 }),
               })
@@ -221,7 +221,7 @@ let preloadBatchOrThrow = async (
                   checkpointId,
                   isPreload: true,
                   chains,
-                  isResolved: false,
+                  sync: UserContext.makeSyncState(),
                   config,
                 }),
               )

package/src/EventProcessing.res.mjs

@@ -38,6 +38,7 @@ let ProcessingError = /* @__PURE__ */Primitive_exceptions.create("EventProcessin
 async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState, loadManager, persistence, chains, config) {
   let timeBeforeHandler = Performance.now();
   try {
+    let contextParams_sync = UserContext.makeSyncState();
     let contextParams = {
       item: item,
       checkpointId: checkpointId,
@@ -47,13 +48,13 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState,
       isPreload: false,
       chains: chains,
       config: config,
-      isResolved: false
+      sync: contextParams_sync
     };
     await handler({
       event: Ecosystem.getItemEvent(item, config.ecosystem),
       context: UserContext.getHandlerContext(contextParams)
     });
-    contextParams.isResolved = true;
+    contextParams_sync.status = "Resolved";
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     throw {
@@ -79,6 +80,7 @@ async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager,
     }
   }
   try {
+    let contextParams_sync = UserContext.makeSyncState();
     let contextParams = {
       item: item,
       checkpointId: checkpointId,
@@ -88,10 +90,10 @@ async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager,
       isPreload: false,
       chains: chains,
       config: config,
-      isResolved: false
+      sync: contextParams_sync
     };
     await item.onBlockRegistration.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext(contextParams)));
-    contextParams.isResolved = true;
+    contextParams_sync.status = "Resolved";
     return;
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
@@ -133,7 +135,7 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
                 isPreload: true,
                 chains: chains,
                 config: config,
-                isResolved: false
+                sync: UserContext.makeSyncState()
               })
             }).then(() => IndexerState.endPreloadHandler(indexerState, timerRef, contractName, eventName))));
           } catch (exn) {
@@ -151,7 +153,7 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
             isPreload: true,
             chains: chains,
             config: config,
-            isResolved: false
+            sync: UserContext.makeSyncState()
           })))));
         } catch (exn$1) {
           

package/src/HandlerLoader.res

@@ -77,18 +77,30 @@ let autoLoadFromSrcHandlers = async (~handlers: string) => {
 // `HandlerRegister.finishRegistration`. This loads the user handler files
 // (populating the global `HandlerRegister` registry as a side effect) and
 // returns the resulting per-chain registrations.
+// The subgraph runtime lives in this package but is never exported: it's
+// reached only from here, when the resolved config carries a translated
+// manifest.
+let registerSubgraph: (JSON.t, ~isDev: bool) => promise<unit> = %raw(`(subgraph, isDev) =>
+  import("./subgraph/runtime.ts").then((m) => m.registerSubgraph({ ...subgraph, isDev }))`)
+
 let registerAllHandlers = async (~config: Config.t): HandlerRegister.registrationsByChainId => {
   HandlerRegister.startRegistration(~config)
 
-  // Auto-load all .js files from src/handlers directory
-  await autoLoadFromSrcHandlers(~handlers=config.handlers)
+  switch config.subgraph {
+  // A subgraph project's `src/` holds AssemblyScript mappings, not envio
+  // handlers, so the usual auto-load would import them without a scope.
+  | Some(subgraph) => await registerSubgraph(subgraph, ~isDev=config.isDev)
+  | None =>
+    // Auto-load all .js files from src/handlers directory
+    await autoLoadFromSrcHandlers(~handlers=config.handlers)
 
-  // Load contract-specific handlers
-  let _ = await config.contractHandlers
-  ->Array.map(({name, handler}) => {
-    registerContractHandlers(~contractName=name, ~handler)
-  })
-  ->Promise.all
+    // Load contract-specific handlers
+    let _ = await config.contractHandlers
+    ->Array.map(({name, handler}) => {
+      registerContractHandlers(~contractName=name, ~handler)
+    })
+    ->Promise.all
+  }
 
   HandlerRegister.finishRegistration(~config)
 }

package/src/HandlerLoader.res.mjs

@@ -56,10 +56,18 @@ async function autoLoadFromSrcHandlers(handlers) {
   })));
 }
 
+let registerSubgraph = ((subgraph, isDev) =>
+  import("./subgraph/runtime.ts").then((m) => m.registerSubgraph({ ...subgraph, isDev })));
+
 async function registerAllHandlers(config) {
   HandlerRegister.startRegistration(config);
-  await autoLoadFromSrcHandlers(config.handlers);
-  await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
+  let subgraph = config.subgraph;
+  if (subgraph !== undefined) {
+    await registerSubgraph(subgraph, config.isDev);
+  } else {
+    await autoLoadFromSrcHandlers(config.handlers);
+    await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
+  }
   return HandlerRegister.finishRegistration(config);
 }
 
@@ -67,6 +75,7 @@ export {
   toImportUrl,
   registerContractHandlers,
   autoLoadFromSrcHandlers,
+  registerSubgraph,
   registerAllHandlers,
 }
 /*  Not a pure module */

package/src/HandlerRegister.res

@@ -154,6 +154,7 @@ let buildOnEventRegistrationWith = (
       ~isWildcard,
       ~handler,
       ~contractRegister,
+      ~where,
       ~fieldSelection?,
       ~startBlock?,
     ) :> Internal.onEventRegistration)
@@ -320,7 +321,7 @@ let addOnEventRegistration = (
       )
     | Fuel =>
       JsError.throwWithMessage(
-        `The fields option of the "${eventName}" event registration on contract "${contractName}" is only supported on EVM. Select the fields in your config instead.`,
+        `The fields option of the "${eventName}" event registration on contract "${contractName}" is not supported on Fuel. Select the fields in your config instead.`,
       )
     }
   }
@@ -335,6 +336,21 @@ let addOnEventRegistration = (
       | None => ()
       | Some(eventConfig) =>
         matched := true
+        switch (registration.config.ecosystem.name, fieldSelection) {
+        | (Svm, Some(fieldSelection)) if fieldSelection.instructionFields->Utils.Set.has("args") =>
+          let svmEventConfig =
+            eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+          let declaresArgs = switch svmEventConfig.args {
+          | JSON.Array(args) => args->Array.length > 0
+          | _ => false
+          }
+          if !declaresArgs {
+            JsError.throwWithMessage(
+              `Invalid "args" field in the fields.instruction option of the "${eventName}" instruction on program "${contractName}". The instruction declares no args in config.yaml, so there is nothing to decode. Remove "args" from the selection, or declare the instruction's args.`,
+            )
+          }
+        | _ => ()
+        }
         let reg = buildOnEventRegistrationWith(
           ~config=registration.config,
           ~chainId=chainConfig.id,
@@ -359,17 +375,18 @@ let addOnEventRegistration = (
   if !matched.contents {
     let (contractNames, eventNames) = registration->describeConfigured(~contractName)
     let listOr = (names, empty) =>
-      names->Utils.Array.isEmpty ? empty : names->Array.joinUnsafe(", ")
+      names->Utils.Array.isEmpty ? empty : names->Utils.Array.quotedJoin
+    let {contractNoun, eventNoun} = registration.config.ecosystem
     if eventNames->Utils.Array.isEmpty {
       JsError.throwWithMessage(
-        `Contract "${contractName}" is not configured on any chain, so its handler for "${eventName}" would never run. Add it to your config, or remove the registration. Configured contracts: ${listOr(
+        `${contractNoun->Utils.String.capitalize} "${contractName}" is not configured on any chain, so its handler for "${eventName}" would never run. Add it to your config, or remove the registration. Configured ${contractNoun}s: ${listOr(
             contractNames,
             "none",
           )}.`,
       )
     } else {
       JsError.throwWithMessage(
-        `Event "${eventName}" is not configured on contract "${contractName}", so its handler would never run. Add it to your config, or remove the registration. Configured events on "${contractName}": ${listOr(
+        `${eventNoun->Utils.String.capitalize} "${eventName}" is not configured on ${contractNoun} "${contractName}", so its handler would never run. Add it to your config, or remove the registration. Configured ${eventNoun}s on "${contractName}": ${listOr(
             eventNames,
             "none",
           )}.`,

package/src/HandlerRegister.res.mjs

@@ -102,7 +102,7 @@ function buildOnEventRegistrationWith(config, chainId, eventConfig, isWildcard,
     case "fuel" :
       return EventConfigBuilder.buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock);
     case "svm" :
-      return EventConfigBuilder.buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, fieldSelection, startBlock);
+      return EventConfigBuilder.buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, where, fieldSelection, startBlock);
   }
 }
 
@@ -209,7 +209,7 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
         fieldSelection = EventConfigBuilder.resolveInlineFieldSelection(fields$1, contractName, eventName, registration.config.enableRawEvents);
         break;
       case "fuel" :
-        fieldSelection = Stdlib_JsError.throwWithMessage(`The fields option of the "` + eventName + `" event registration on contract "` + contractName + `" is only supported on EVM. Select the fields in your config instead.`);
+        fieldSelection = Stdlib_JsError.throwWithMessage(`The fields option of the "` + eventName + `" event registration on contract "` + contractName + `" is not supported on Fuel. Select the fields in your config instead.`);
         break;
       case "svm" :
         fieldSelection = EventConfigBuilder.resolveSvmInlineFieldSelection(fields$1, contractName, eventName);
@@ -231,6 +231,22 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
       return;
     }
     matched.contents = true;
+    let match = registration.config.ecosystem.name;
+    switch (match) {
+      case "evm" :
+      case "fuel" :
+        break;
+      case "svm" :
+        if (fieldSelection !== undefined && fieldSelection.instructionFields.has("args")) {
+          let args = eventConfig.args;
+          let declaresArgs;
+          declaresArgs = Array.isArray(args) ? args.length !== 0 : false;
+          if (!declaresArgs) {
+            Stdlib_JsError.throwWithMessage(`Invalid "args" field in the fields.instruction option of the "` + eventName + `" instruction on program "` + contractName + `". The instruction declares no args in config.yaml, so there is nothing to decode. Remove "args" from the selection, or declare the instruction's args.`);
+          }
+        }
+        break;
+    }
     let reg = buildOnEventRegistrationWith(registration.config, chainConfig.id, eventConfig, isWildcard, handler, contractRegister, where, fieldSelection, contract.startBlock);
     getChainRegistrations(registration, chainConfig.id).onEventRegistrations.push(reg);
   });
@@ -243,13 +259,16 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
     if (Utils.$$Array.isEmpty(names)) {
       return empty;
     } else {
-      return names.join(", ");
+      return Utils.$$Array.quotedJoin(names);
     }
   };
+  let match$2 = registration.config.ecosystem;
+  let eventNoun = match$2.eventNoun;
+  let contractNoun = match$2.contractNoun;
   if (Utils.$$Array.isEmpty(eventNames)) {
-    return Stdlib_JsError.throwWithMessage(`Contract "` + contractName + `" is not configured on any chain, so its handler for "` + eventName + `" would never run. Add it to your config, or remove the registration. Configured contracts: ` + listOr(match$1[0], "none") + `.`);
+    return Stdlib_JsError.throwWithMessage(Utils.$$String.capitalize(contractNoun) + ` "` + contractName + `" is not configured on any chain, so its handler for "` + eventName + `" would never run. Add it to your config, or remove the registration. Configured ` + contractNoun + `s: ` + listOr(match$1[0], "none") + `.`);
   } else {
-    return Stdlib_JsError.throwWithMessage(`Event "` + eventName + `" is not configured on contract "` + contractName + `", so its handler would never run. Add it to your config, or remove the registration. Configured events on "` + contractName + `": ` + listOr(eventNames, "none") + `.`);
+    return Stdlib_JsError.throwWithMessage(Utils.$$String.capitalize(eventNoun) + ` "` + eventName + `" is not configured on ` + contractNoun + ` "` + contractName + `", so its handler would never run. Add it to your config, or remove the registration. Configured ` + eventNoun + `s on "` + contractName + `": ` + listOr(eventNames, "none") + `.`);
   }
 }
 

package/src/InMemoryStore.res

@@ -127,15 +127,15 @@ let dropCommittedEffects = (
 
 let prepareRollbackDiff = async (
   state: IndexerState.t,
-  ~rollbackTargetCheckpointId,
+  ~floors: RollbackFloors.t,
   ~rollbackDiffCheckpointId,
-  ~progressBlockNumberByChainId,
+  ~progressedChains,
   ~rolledBackAddresses,
 ) => {
   state->IndexerState.beginRollbackDiff(
-    ~targetCheckpointId=rollbackTargetCheckpointId,
     ~diffCheckpointId=rollbackDiffCheckpointId,
-    ~progressBlockNumberByChainId,
+    ~floors,
+    ~progressedChains,
     ~rolledBackAddresses,
   )
   let persistence = state->IndexerState.persistence
@@ -152,7 +152,7 @@ let prepareRollbackDiff = async (
   ->Array.map(async entityConfig => {
     let (removals, restoredEntities) = await persistence.storage.getRollbackData(
       ~entityConfig,
-      ~rollbackTargetCheckpointId,
+      ~floors,
     )
 
     removals->Array.forEach(({entityId, scope}: Persistence.rollbackRemoval) => {
@@ -215,7 +215,8 @@ let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
         }
       }
 
-      batch.registeredAddresses->Array.pushMany(
+      batch.registeredAddresses
+      ->Array.pushMany(
         chainState
         ->ChainState.drainAddressesForWrite(
           ~toBlockInclusive=progressedChain.progressBlockNumber,
@@ -230,7 +231,8 @@ let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
           },
           checkpointId: checkpointIds->Array.getUnsafe(dc.checkpointIdx),
         }),
-      )->ignore
+      )
+      ->ignore
     }
   })
 }

package/src/InMemoryStore.res.mjs

@@ -106,14 +106,14 @@ function dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromD
   inMemTable.changesCount = inMemTable.changesCount - keysToDelete.length;
 }
 
-async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressBlockNumberByChainId, rolledBackAddresses) {
-  IndexerState.beginRollbackDiff(state, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressBlockNumberByChainId, rolledBackAddresses);
+async function prepareRollbackDiff(state, floors, rollbackDiffCheckpointId, progressedChains, rolledBackAddresses) {
+  IndexerState.beginRollbackDiff(state, rollbackDiffCheckpointId, floors, progressedChains, rolledBackAddresses);
   let persistence = IndexerState.persistence(state);
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
   let deletedEntities = {};
   let setEntities = {};
   await Promise.all(persistence.allEntities.filter(entityConfig => entityConfig.storage.postgres).map(async entityConfig => {
-    let match = await persistence.storage.getRollbackData(entityConfig, rollbackTargetCheckpointId);
+    let match = await persistence.storage.getRollbackData(entityConfig, floors);
     match[0].forEach(param => {
       let entityId = param.entityId;
       Utils.Dict.push(deletedEntities, entityConfig.name, entityId);