envio 3.8.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),
@@ -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 + `.`);
@@ -396,10 +393,8 @@ let validSvmAccountActivityFields = new Set([
   "transactionAccountIndex",
   "isSigner",
   "isWritable",
-  "lamports",
   "lamports.pre",
   "lamports.post",
-  "token",
   "token.mint",
   "token.owner",
   "token.decimals",
@@ -422,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");
@@ -438,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;
@@ -453,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,
@@ -471,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
   };
 }
 
@@ -544,6 +646,8 @@ function buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contract
   };
 }
 
+let filterableAccountCount = 10;
+
 export {
   paramMetaSchema,
   normalizeOrThrow,
@@ -563,7 +667,6 @@ export {
   rawEventBlockFields,
   evmSelectionKinds,
   svmSelectionKinds,
-  quotedJoin,
   validateFieldsShapeOrThrow,
   selectionList,
   validBlockFields,
@@ -580,6 +683,10 @@ export {
   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).

package/src/FetchState.res.mjs

@@ -1123,25 +1123,16 @@ function warnRejectedRegistration(verdict, chainId, contractAddress, contractNam
       contractName: contractName
     }, `Skipping contract registration: Not a valid address for this chain's ecosystem.`);
   }
-  switch (verdict.TAG) {
-    case "Added" :
-      return;
-    case "Duplicate" :
-      let existingEffectiveStartBlock = verdict.existingEffectiveStartBlock;
-      let effectiveStartBlock = verdict.effectiveStartBlock;
-      if (existingEffectiveStartBlock > effectiveStartBlock) {
-        return warnAddressRegistration(chainId, contractAddress, {
-          existingBlockNumber: existingEffectiveStartBlock,
-          newBlockNumber: effectiveStartBlock
-        }, `Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.`);
-      } else {
-        return;
-      }
-    case "Conflict" :
-      return warnAddressRegistration(chainId, contractAddress, {
-        existingContractType: verdict.existingContractName,
-        newContractType: contractName
-      }, `Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`);
+  if (verdict.TAG === "Added") {
+    return;
+  }
+  let existingEffectiveStartBlock = verdict.existingEffectiveStartBlock;
+  let effectiveStartBlock = verdict.effectiveStartBlock;
+  if (existingEffectiveStartBlock > effectiveStartBlock) {
+    return warnAddressRegistration(chainId, contractAddress, {
+      existingBlockNumber: existingEffectiveStartBlock,
+      newBlockNumber: effectiveStartBlock
+    }, `Skipping same-contract re-registration: the address is already registered for this contract. The start block does not move earlier.`);
   }
 }
 
@@ -1727,7 +1718,7 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt, clientFilterAddressThresholdOpt, isResumedOpt) {
+function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addressRows, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt, clientFilterAddressThresholdOpt, isResumedOpt) {
   let progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
   let onBlockRegistrations = onBlockRegistrationsOpt !== undefined ? onBlockRegistrationsOpt : [];
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
@@ -1762,29 +1753,24 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
     });
   }
   let normalSelection = makeSelection(normalRegistrations, true, undefined);
-  AddressStore.seedBatch(addressStore, addresses.map(contract => ({
-    address: contract.address,
-    contractName: contract.contractName,
-    registrationBlock: contract.registrationBlock
-  }))).forEach((verdict, idx) => {
-    let contract = addresses[idx];
-    warnRejectedRegistration(verdict, chainId, contract.address, contract.contractName);
-  });
+  AddressStore.seedRows(addressStore, addressRows).forEach(rejected => warnAddressRegistration(chainId, rejected.address, {
+    contractName: rejected.contractName,
+    existingBlockNumber: rejected.existingEffectiveStartBlock,
+    newBlockNumber: rejected.effectiveStartBlock
+  }, `Skipping a stored address: it is already registered for this contract.`));
   let dynamicContracts = new Set();
   let clientFilteredContracts = new Set();
   let registeringSetsByContract = {};
-  addresses.forEach(contract => {
-    let contractName = contract.contractName;
+  Array.from(contractNamesWithNormalEvents).forEach(contractName => {
+    if (addressStore.contractCount(contractName) > 0) {
+      registeringSetsByContract[contractName] = AddressStore.makeSet(addressStore, contractName, undefined);
+      return;
+    }
+  });
+  addressStore.dynamicContractNames().forEach(contractName => {
     if (contractNamesWithNormalEvents.has(contractName)) {
-      if (!(contractName in registeringSetsByContract)) {
-        registeringSetsByContract[contractName] = AddressStore.makeSet(addressStore, contractName, undefined);
-      }
-      if (contract.registrationBlock !== -1) {
-        dynamicContracts.add(contractName);
-        return;
-      } else {
-        return;
-      }
+      dynamicContracts.add(contractName);
+      return;
     }
   });
   if (clientFilterAddressThreshold !== undefined) {
@@ -1797,7 +1783,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
   }
   let optimizedPartitions = createPartitions(registeringSetsByContract, addressStore, dynamicContracts, clientFilteredContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber, knownHeight);
   if (optimizedPartitions.idsInAscOrder.length === 0 && Utils.$$Array.isEmpty(onBlockRegistrations)) {
-    Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + ChainId.toString(chainId) + `. ` + (`addresses=` + addresses.length.toString() + `, `) + (`onEventRegistrations=` + onEventRegistrations.length.toString() + `, `) + (`normalRegistrations=` + normalRegistrations.length.toString() + `. `) + `Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.`);
+    Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + ChainId.toString(chainId) + `. ` + (`addresses=` + addressRows.addresses.length.toString() + `, `) + (`onEventRegistrations=` + onEventRegistrations.length.toString() + `, `) + (`normalRegistrations=` + normalRegistrations.length.toString() + `. `) + `Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.`);
   }
   let buffer = [];
   let latestOnBlockBlockNumber;
@@ -1861,8 +1847,8 @@ function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
   return adjusted;
 }
 
-function rollback(fetchState, addressStore, targetBlockNumber) {
-  addressStore.rollback(targetBlockNumber);
+function rollback(fetchState, rolledBackAddressStore, targetBlockNumber) {
+  let rolledBackAddresses = rolledBackAddressStore.rollback(targetBlockNumber);
   let keptPartitions = [];
   let nextKeptIdRef = 0;
   let registeringSetsByContract = {};
@@ -1921,8 +1907,8 @@ function rollback(fetchState, addressStore, targetBlockNumber) {
       });
     }
   }
-  let optimizedPartitions = createPartitions(registeringSetsByContract, addressStore, fetchState.optimizedPartitions.dynamicContracts, fetchState.optimizedPartitions.clientFilteredContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, nextKeptIdRef, keptPartitions, targetBlockNumber, fetchState.knownHeight);
-  return updateInternal({
+  let optimizedPartitions = createPartitions(registeringSetsByContract, rolledBackAddressStore, fetchState.optimizedPartitions.dynamicContracts, fetchState.optimizedPartitions.clientFilteredContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, nextKeptIdRef, keptPartitions, targetBlockNumber, fetchState.knownHeight);
+  let rolledBack = updateInternal({
     optimizedPartitions: fetchState.optimizedPartitions,
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
@@ -1941,6 +1927,10 @@ function rollback(fetchState, addressStore, targetBlockNumber) {
     tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
     return tmp <= targetBlockNumber;
   }), true, undefined, undefined);
+  return {
+    fetchState: rolledBack,
+    rolledBackAddresses: rolledBackAddresses
+  };
 }
 
 function resetPendingQueries(fetchState) {

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.`,
       )
     }
   }
@@ -359,17 +360,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",
           )}.`,