envio 3.7.0 → 3.9.0-resolvers.0

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),
@@ -238,7 +239,7 @@ let alwaysIncludedBlockFields = [
 function resolveFieldSelection(blockFields, transactionFields, globalBlockFieldsSet, globalTransactionFieldsSet) {
   let selectedBlockFields = blockFields !== undefined ? new Set(alwaysIncludedBlockFields.concat(blockFields)) : globalBlockFieldsSet;
   let selectedTransactionFields = transactionFields !== undefined ? new Set(transactionFields) : globalTransactionFieldsSet;
-  return Internal.makeFieldSelection(selectedBlockFields, selectedTransactionFields, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
+  return Internal.makeFieldSelection(selectedBlockFields, selectedTransactionFields, undefined, undefined, undefined, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
 }
 
 let internalBlockFields = ["number"];
@@ -248,53 +249,72 @@ let rawEventBlockFields = [
   "timestamp"
 ];
 
-let selectionKinds = [
+let evmSelectionKinds = [
   "block",
   "transaction"
 ];
 
-function validateFieldsShapeOrThrow(fields, registration) {
+let svmSelectionKinds = [
+  "instruction",
+  "transaction",
+  "accountActivity",
+  "block",
+  "log"
+];
+
+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 block and transaction field names.`);
+    Stdlib_JsError.throwWithMessage(`The fields option of ` + registration + ` must be an object of ` + shapeNoun + ` field names.`);
   }
   Object.keys(fields).forEach(key => {
-    if (!selectionKinds.includes(key)) {
-      return Stdlib_JsError.throwWithMessage(`Invalid "` + key + `" key in the fields option of ` + registration + `. Valid keys: ` + selectionKinds.join(", ") + `.`);
+    if (!validKeys.includes(key)) {
+      return Stdlib_JsError.throwWithMessage(`Invalid "` + key + `" key in the fields option of ` + registration + `. Valid keys: ` + Utils.$$Array.quotedJoin(validKeys) + `.`);
     }
   });
 }
 
+function selectionList(fields, key) {
+  let value = fields[key];
+  if (value !== undefined) {
+    return Primitive_option.valFromOption(value);
+  }
+}
+
 let validBlockFields = new Set(Evm.blockFields);
 
 let validTransactionFields = new Set(Evm.transactionFields);
 
-function parseFieldsOrThrow(fields, valid, kind, registration) {
+function parseFieldsOrThrow(fields, valid, kind, registration, rejectEmptyOpt) {
+  let rejectEmpty = rejectEmptyOpt !== undefined ? rejectEmptyOpt : false;
   let seen = new Set();
   let fields$1 = fields !== undefined ? (
       Array.isArray(fields) ? fields : Stdlib_JsError.throwWithMessage(`The fields.` + kind + ` option of ` + registration + ` must be an array of field names.`)
     ) : [];
   fields$1.forEach(name => {
     if (!valid.has(name)) {
-      Stdlib_JsError.throwWithMessage(`Invalid "` + name + `" field in the fields.` + kind + ` option of ` + registration + `. Valid ` + kind + ` fields: ` + Array.from(valid).join(", ") + `.`);
+      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 + `.`);
     }
     seen.add(name);
   });
+  if (rejectEmpty && fields$1.length === 0) {
+    Stdlib_JsError.throwWithMessage(`The fields.` + kind + ` option of ` + registration + ` must list at least one field.`);
+  }
   return seen;
 }
 
 function resolveInlineFieldSelection(fields, contractName, eventName, enableRawEvents) {
   let registration = `the "` + eventName + `" event registration on contract "` + contractName + `"`;
-  validateFieldsShapeOrThrow(fields, registration);
-  let blockFields = parseFieldsOrThrow(fields.block, validBlockFields, "block", registration);
-  let transactionFields = parseFieldsOrThrow(fields.transaction, validTransactionFields, "transaction", registration);
+  validateFieldsShapeOrThrow(fields, registration, evmSelectionKinds, "block and transaction");
+  let blockFields = parseFieldsOrThrow(selectionList(fields, "block"), validBlockFields, "block", registration, undefined);
+  let transactionFields = parseFieldsOrThrow(selectionList(fields, "transaction"), validTransactionFields, "transaction", registration, undefined);
   Utils.$$Set.addMany(blockFields, internalBlockFields);
   if (enableRawEvents) {
     Utils.$$Set.addMany(blockFields, rawEventBlockFields);
   }
-  return Internal.makeFieldSelection(blockFields, transactionFields, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
+  return Internal.makeFieldSelection(blockFields, transactionFields, undefined, undefined, undefined, Evm.eventBlockFieldMask, Evm.eventTransactionFieldMask);
 }
 
 function buildEvmEventConfig(contractName, eventName, sighash, params, blockFields, transactionFields, globalBlockFieldsSetOpt, globalTransactionFieldsSetOpt) {
@@ -342,20 +362,83 @@ function buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractR
   };
 }
 
-let alwaysIncludedSvmBlockFields = [
+let alwaysIncludedSvmBlockFields = ["slot"];
+
+let validSvmInstructionFields = new Set([
+  "args",
+  "accounts",
+  "accountArguments",
+  "programId",
+  "data",
+  "path",
+  "isInner"
+]);
+
+let validSvmTransactionFields = new Set([
+  "transactionIndex",
+  "signature",
+  "feePayer",
+  "success",
+  "err",
+  "fee",
+  "computeUnitsConsumed",
+  "accountKeys",
+  "recentBlockhash",
+  "version",
+  "allSignatures"
+]);
+
+let validSvmAccountActivityFields = new Set([
+  "address",
+  "transactionAccountIndex",
+  "isSigner",
+  "isWritable",
+  "lamports.pre",
+  "lamports.post",
+  "token.mint",
+  "token.owner",
+  "token.decimals",
+  "token.preAmount",
+  "token.postAmount"
+]);
+
+let validSvmBlockFields = new Set([
   "slot",
   "time",
-  "hash"
-];
+  "hash",
+  "height",
+  "parentSlot",
+  "parentHash"
+]);
+
+let validSvmLogFields = new Set([
+  "kind",
+  "message"
+]);
 
-function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeLogs, transactionFieldsOpt, blockFieldsOpt, accountFilters, isInner, accountsOpt, argsOpt, definedTypesOpt) {
-  let transactionFields = transactionFieldsOpt !== undefined ? transactionFieldsOpt : [];
-  let blockFields = blockFieldsOpt !== undefined ? blockFieldsOpt : [];
+function resolveSvmInlineFieldSelection(fields, contractName, eventName) {
+  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");
+  let instructionFields = parseFieldsOrThrow(selectionList(fields, "instruction"), validSvmInstructionFields, "instruction", registration, undefined);
+  let transactionFields = parseFieldsOrThrow(selectionList(fields, "transaction"), validSvmTransactionFields, "transaction", registration, undefined);
+  let accountActivityFields = parseFieldsOrThrow(accountActivity, validSvmAccountActivityFields, "accountActivity", registration, Stdlib_Option.isSome(accountActivity));
+  let blockFields = parseFieldsOrThrow(selectionList(fields, "block"), validSvmBlockFields, "block", registration, undefined);
+  let logFields = parseFieldsOrThrow(log, validSvmLogFields, "log", registration, Stdlib_Option.isSome(log));
+  Utils.$$Set.addMany(blockFields, alwaysIncludedSvmBlockFields);
+  if (accountActivityFields.size > 0) {
+    transactionFields.add("accountActivities");
+  }
+  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, accountsOpt, argsOpt, definedTypesOpt) {
   let accounts = accountsOpt !== undefined ? accountsOpt : [];
   let args = argsOpt !== undefined ? argsOpt : null;
   let definedTypes = definedTypesOpt !== undefined ? definedTypesOpt : null;
   let paramsSchema = Utils.Schema.coerceToJsonPgType(S$RescriptSchema.json(false));
-  let fieldSelection = Internal.makeFieldSelection(new Set(alwaysIncludedSvmBlockFields.concat(blockFields)), new Set(transactionFields), Svm.eventBlockFieldMask, Svm.eventTransactionFieldMask);
+  let fieldSelection = Internal.makeFieldSelection(new Set(alwaysIncludedSvmBlockFields), new Set(), undefined, undefined, undefined, Svm.eventBlockFieldMask, Svm.eventTransactionFieldMask);
   return {
     id: discriminator !== undefined ? discriminator : "none",
     name: instructionName,
@@ -365,17 +448,121 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
     fieldSelection: fieldSelection,
     programId: programId,
     discriminator: discriminator,
-    discriminatorByteLen: discriminatorByteLen,
-    includeLogs: includeLogs,
-    accountFilters: accountFilters,
-    isInner: isInner,
     accounts: accounts,
     args: args,
     definedTypes: definedTypes
   };
 }
 
-function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, 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,
@@ -384,8 +571,10 @@ function buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractR
     isWildcard: isWildcard,
     filterByAddresses: false,
     dependsOnAddresses: Internal.dependsOnAddresses(isWildcard, false),
-    startBlock: startBlock,
-    fieldSelection: eventConfig.fieldSelection
+    startBlock: sb !== undefined ? sb : startBlock,
+    fieldSelection: fieldSelection !== undefined ? fieldSelection : eventConfig.fieldSelection,
+    accountFilters: resolvedWhere.accountFilters,
+    isInner: resolvedWhere.isInner
   };
 }
 
@@ -438,7 +627,7 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi) {
     contractName: contractName,
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
-    fieldSelection: Internal.makeFieldSelection(new Set(Fuel.blockFields), new Set(Fuel.transactionFields), Fuel.eventBlockFieldMask, Fuel.eventTransactionFieldMask),
+    fieldSelection: Internal.makeFieldSelection(new Set(Fuel.blockFields), new Set(Fuel.transactionFields), undefined, undefined, undefined, Fuel.eventBlockFieldMask, Fuel.eventTransactionFieldMask),
     kind: fuelKind
   };
 }
@@ -457,6 +646,8 @@ function buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contract
   };
 }
 
+let filterableAccountCount = 10;
+
 export {
   paramMetaSchema,
   normalizeOrThrow,
@@ -474,8 +665,10 @@ export {
   resolveFieldSelection,
   internalBlockFields,
   rawEventBlockFields,
-  selectionKinds,
+  evmSelectionKinds,
+  svmSelectionKinds,
   validateFieldsShapeOrThrow,
+  selectionList,
   validBlockFields,
   validTransactionFields,
   parseFieldsOrThrow,
@@ -483,7 +676,17 @@ export {
   buildEvmEventConfig,
   buildEvmOnEventRegistration,
   alwaysIncludedSvmBlockFields,
+  validSvmInstructionFields,
+  validSvmTransactionFields,
+  validSvmAccountActivityFields,
+  validSvmBlockFields,
+  validSvmLogFields,
+  resolveSvmInlineFieldSelection,
   buildSvmInstructionEventConfig,
+  validSvmWhereKeys,
+  svmBlockFilterSchema,
+  filterableAccountCount,
+  resolveSvmWhereOrThrow,
   buildSvmOnEventRegistration,
   buildFuelEventConfig,
   buildFuelOnEventRegistration,

package/src/FetchState.res

@@ -1469,7 +1469,6 @@ let warnAddressRegistration = (
 
 // A rejected registration is simply absent from every partition, so without a
 // warning the user sees a contract that never indexes and nothing saying why.
-// Shared by config-time registration in `make` and by dynamic registration.
 let warnRejectedRegistration = (
   verdict: AddressStore.verdict,
   ~chainId: ChainId.t,
@@ -1477,20 +1476,7 @@ let warnRejectedRegistration = (
   ~contractName: string,
 ) =>
   switch verdict {
-  | Conflict({existingContractName}) =>
-    warnAddressRegistration(
-      ~chainId,
-      ~contractAddress,
-      ~params={
-        "existingContractType": existingContractName,
-        "newContractType": contractName,
-      },
-      `Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`,
-    )
   | Duplicate({effectiveStartBlock, existingEffectiveStartBlock}) =>
-    // FIXME: Instead of filtering out duplicates, we should check the block
-    // number first. If a new registration has an earlier block number we
-    // should register it for the missing block range.
     if existingEffectiveStartBlock > effectiveStartBlock {
       warnAddressRegistration(
         ~chainId,
@@ -1499,7 +1485,7 @@ let warnRejectedRegistration = (
           "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.`,
+        `Skipping same-contract re-registration: the address is already registered for this contract. The start block does not move earlier.`,
       )
     }
   | Invalid =>
@@ -1723,9 +1709,10 @@ let registerDynamicContracts = (
   // exactly what this batch adds.
   let idCursor = addressStore->AddressStore.nextId
   // The store resolves each address against both what it already holds and the
-  // batch's own earlier entries, so two contracts claiming one address inside a
-  // single batch conflict the same way as across batches. It also decides which
-  // additions this chain fetches for, since it's what holds the contract list.
+  // batch's own earlier entries, so the same address registered twice for one
+  // contract inside a single batch is a duplicate just as it is across batches.
+  // It also decides which additions this chain fetches for, since it's what
+  // holds the contract list.
   let verdicts = addressStore->AddressStore.registerBatch(registrations)
 
   let registeringContractNames = []
@@ -1741,7 +1728,7 @@ let registerDynamicContracts = (
     // no partition to build. The address is still stored and persisted, so a
     // config that later adds address-dependent events picks it up on restart.
     | Added({fetchable: false}) => ()
-    | Conflict(_) | Duplicate(_) | Invalid =>
+    | Duplicate(_) | Invalid =>
       verdict->warnRejectedRegistration(
         ~chainId=fetchState.chainId,
         ~contractAddress=registration.address,
@@ -2627,7 +2614,7 @@ let make = (
   ~endBlock,
   ~onEventRegistrations: array<Internal.onEventRegistration>,
   ~addressStore: AddressStore.t,
-  ~addresses: array<Internal.indexingAddress>,
+  ~addressRows: AddressRows.seedRows,
   ~maxAddrInPartition,
   ~chainId: ChainId.t,
   ~maxOnBlockBufferSize,
@@ -2681,27 +2668,24 @@ let make = (
   )
 
   // Every address the chain indexes goes into the store — including ones whose
-  // contract has no address-dependent events, so a later registration of the
-  // same address still conflicts and the address is still persisted.
+  // contract has no address-dependent events, so the address is still persisted
+  // and a config that later adds events picks it up.
+  //
+  // These rows come from the config or from a resume, so they're already stored
+  // and must never be drained back into a write. Only the rows the store
+  // refuses come back: a resume seeds millions of them.
   addressStore
-  // These come from the config or from a resume, so they're already stored and
-  // must never be drained back into a write.
-  ->AddressStore.seedBatch(
-    addresses->Array.map((contract): AddressStore.registration => {
-      address: contract.address,
-      contractName: contract.contractName,
-      registrationBlock: contract.registrationBlock,
-    }),
-  )
-  // Verdicts are in the batch's order, so they line up with `addresses`. A
-  // config address the store rejects is dropped exactly like a dynamic one, and
-  // needs the same warning — restored dynamic addresses come through here too.
-  ->Array.forEachWithIndex((verdict, idx) => {
-    let contract = addresses->Array.getUnsafe(idx)
-    verdict->warnRejectedRegistration(
+  ->AddressStore.seedRows(addressRows)
+  ->Array.forEach(rejected => {
+    warnAddressRegistration(
       ~chainId,
-      ~contractAddress=contract.address,
-      ~contractName=contract.contractName,
+      ~contractAddress=rejected.address,
+      ~params={
+        "contractName": rejected.contractName,
+        "existingBlockNumber": rejected.existingEffectiveStartBlock,
+        "newBlockNumber": rejected.effectiveStartBlock,
+      },
+      `Skipping a stored address: it is already registered for this contract.`,
     )
   })
 
@@ -2709,23 +2693,24 @@ let make = (
   let clientFilteredContracts = Utils.Set.make()
   let registeringSetsByContract = Dict.make()
 
-  addresses->Array.forEach(contract => {
-    let contractName = contract.contractName
-
-    // Only addresses whose contract has events that depend on addresses get
-    // registered for active fetching via partitions.
+  // What each contract needs a partition for is read back off the store rather
+  // than re-derived from the seeded columns: the store is what resolved the
+  // rows, including the ones it refused.
+  contractNamesWithNormalEvents
+  ->Utils.Set.toArray
+  ->Array.forEach(contractName => {
+    if addressStore->AddressStore.contractCount(contractName) > 0 {
+      registeringSetsByContract->Dict.set(
+        contractName,
+        addressStore->AddressStore.makeSet(~contractName),
+      )
+    }
+  })
+  addressStore
+  ->AddressStore.dynamicContractNames
+  ->Array.forEach(contractName => {
     if contractNamesWithNormalEvents->Utils.Set.has(contractName) {
-      if !(registeringSetsByContract->Dict.has(contractName)) {
-        registeringSetsByContract->Dict.set(
-          contractName,
-          addressStore->AddressStore.makeSet(~contractName),
-        )
-      }
-
-      // Detect dynamic contracts by registrationBlock
-      if contract.registrationBlock !== -1 {
-        dynamicContracts->Utils.Set.add(contractName)->ignore
-      }
+      dynamicContracts->Utils.Set.add(contractName)->ignore
     }
   })
 
@@ -2768,7 +2753,7 @@ let make = (
   ) {
     JsError.throwWithMessage(
       `Invalid configuration: Nothing to fetch on chain ${chainId->ChainId.toString}. ` ++
-      `addresses=${addresses->Array.length->Int.toString}, ` ++
+      `addresses=${addressRows.addresses->Array.length->Int.toString}, ` ++
       `onEventRegistrations=${onEventRegistrations->Array.length->Int.toString}, ` ++
       `normalRegistrations=${normalRegistrations
         ->Array.length
@@ -2845,20 +2830,28 @@ let rollbackPendingQueries = (mutPendingQueries: array<pendingQuery>, ~targetBlo
   adjusted
 }
 
+type rollbackResult = {
+  fetchState: t,
+  // The registrations the prune dropped, for the storage that deletes their rows.
+  rolledBackAddresses: array<AddressStore.rolledBackAddress>,
+}
+
 /**
 Rolls back fetch state to the given valid block.
+Prunes the store first, then rebuilds partitions from it: an address survives iff
+`filterByRegistrationBlock` keeps it, so the partitions and the rows the caller
+goes on to delete can't disagree about which registrations died.
 Always recreates optimized partitions to avoid duplicate addresses:
 - Wildcard: only rollback latestFetchedBlock
 - Non-wildcard with lfb <= target: keep, adjust pending queries and mergeBlock
 - Non-wildcard with lfb > target: delete, track addresses for recreation
 */
-let rollback = (fetchState: t, ~addressStore: AddressStore.t, ~targetBlockNumber) => {
-  // Step 1: Prune addresses registered after the target block. The pruned store
-  // is then the source of truth for partition cleanup below — an address
-  // survives iff `filterByRegistrationBlock` keeps it.
-  addressStore->AddressStore.rollback(targetBlockNumber)->ignore
-
-  // Step 2: Categorize partitions
+let rollback = (
+  fetchState: t,
+  ~rolledBackAddressStore: AddressStore.t,
+  ~targetBlockNumber,
+): rollbackResult => {
+  let rolledBackAddresses = rolledBackAddressStore->AddressStore.rollback(targetBlockNumber)
   let keptPartitions = []
   let nextKeptIdRef = ref(0)
   let registeringSetsByContract: dict<AddressSet.t> = Dict.make()
@@ -2935,10 +2928,9 @@ let rollback = (fetchState: t, ~addressStore: AddressStore.t, ~targetBlockNumber
     }
   }
 
-  // Step 3: Recreate partitions from deleted partition addresses
   let optimizedPartitions = createPartitions(
     ~registeringSetsByContract,
-    ~addressStore,
+    ~addressStore=rolledBackAddressStore,
     ~dynamicContracts=fetchState.optimizedPartitions.dynamicContracts,
     ~clientFilteredContracts=fetchState.optimizedPartitions.clientFilteredContracts,
     ~normalSelection=fetchState.normalSelection,
@@ -2949,8 +2941,7 @@ let rollback = (fetchState: t, ~addressStore: AddressStore.t, ~targetBlockNumber
     ~knownHeight=fetchState.knownHeight,
   )
 
-  // Step 4: Update state
-  {
+  let rolledBack = {
     ...fetchState,
     // TODO: Test this. Currently it's not tested.
     latestOnBlockBlockNumber: Pervasives.min(
@@ -2969,6 +2960,7 @@ let rollback = (fetchState: t, ~addressStore: AddressStore.t, ~targetBlockNumber
       targetBlockNumber
     ),
   )
+  {fetchState: rolledBack, rolledBackAddresses}
 }
 
 // Reset pending queries by removing in-flight queries (ones without fetchedBlock).