envio 3.8.0 → 3.9.0

package/src/ContractMapping.res

@@ -0,0 +1,66 @@
+// The contract name <-> id mapping every stored address row references: a
+// name's position in `names` is the id `envio_contracts` holds and
+// `envio_addresses.contract_id` points at. Ids must mean the same thing on
+// every chain and across restarts, so a mapping is built once — from the whole
+// config, never from a filtered subset — and read everywhere else.
+type t = {
+  // Id order. Index i is the name of contract id i.
+  names: array<string>,
+  idByName: dict<int>,
+}
+
+let indexNames = (names: array<string>): t => {
+  let idByName = Dict.make()
+  names->Array.forEachWithIndex((name, id) => idByName->Dict.set(name, id))
+  {names, idByName}
+}
+
+// Ids are 0-based positions in a smallint column, so 32768 contracts fit.
+let maxContracts = 32768
+
+// Names in any order; the codec puts them in byte order so the ids never depend
+// on the order contracts happen to be declared in.
+let make = (~names: array<string>): t => {
+  let canonical = Core.getAddon().canonicalContractNames(names)
+  if canonical->Array.length > maxContracts {
+    JsError.throwWithMessage(
+      `The indexer declares ${canonical
+        ->Array.length
+        ->Int.toString} contracts, more than the ${maxContracts->Int.toString} a smallint contract id can hold.`,
+    )
+  }
+  indexNames(canonical)
+}
+
+// What a storage holds before it has been initialized: no contract has an id
+// yet, so every lookup fails rather than resolving against a stale mapping.
+let empty = indexNames([])
+
+// A mapping read back from storage. Taken verbatim: the stored order *is* the
+// id order the stored rows were written against, so re-canonicalizing it would
+// paper over a mapping that no longer matches those rows.
+let fromStoredNames = indexNames
+
+let names = (mapping: t) => mapping.names
+
+let idOfOrThrow = (mapping: t, name, ~context="") =>
+  switch mapping.idByName->Utils.Dict.dangerouslyGetNonOption(name) {
+  | Some(id) => id
+  | None =>
+    JsError.throwWithMessage(
+      `Contract "${name}"${context} is missing from the indexer's contract list.`,
+    )
+  }
+
+let nameOfOrThrow = (mapping: t, id) =>
+  switch mapping.names->Array.get(id) {
+  | Some(name) => name
+  | None =>
+    JsError.throwWithMessage(
+      `Contract id ${id->Int.toString} is outside the indexer's contract list.`,
+    )
+  }
+
+let isEqual = (a: t, b: t) =>
+  a.names->Array.length === b.names->Array.length &&
+    a.names->Array.everyWithIndex((name, idx) => b.names->Array.getUnsafe(idx) === name)

package/src/ContractMapping.res.mjs

@@ -0,0 +1,73 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "./Core.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+function indexNames(names) {
+  let idByName = {};
+  names.forEach((name, id) => {
+    idByName[name] = id;
+  });
+  return {
+    names: names,
+    idByName: idByName
+  };
+}
+
+function make(names) {
+  let canonical = Core.getAddon().canonicalContractNames(names);
+  if (canonical.length > 32768) {
+    Stdlib_JsError.throwWithMessage(`The indexer declares ` + canonical.length.toString() + ` contracts, more than the ` + (32768).toString() + ` a smallint contract id can hold.`);
+  }
+  return indexNames(canonical);
+}
+
+let empty = indexNames([]);
+
+function names(mapping) {
+  return mapping.names;
+}
+
+function idOfOrThrow(mapping, name, contextOpt) {
+  let context = contextOpt !== undefined ? contextOpt : "";
+  let id = mapping.idByName[name];
+  if (id !== undefined) {
+    return id;
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Contract "` + name + `"` + context + ` is missing from the indexer's contract list.`);
+  }
+}
+
+function nameOfOrThrow(mapping, id) {
+  let name = mapping.names[id];
+  if (name !== undefined) {
+    return name;
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Contract id ` + id.toString() + ` is outside the indexer's contract list.`);
+  }
+}
+
+function isEqual(a, b) {
+  if (a.names.length === b.names.length) {
+    return a.names.every((name, idx) => b.names[idx] === name);
+  } else {
+    return false;
+  }
+}
+
+let maxContracts = 32768;
+
+let fromStoredNames = indexNames;
+
+export {
+  indexNames,
+  maxContracts,
+  make,
+  empty,
+  fromStoredNames,
+  names,
+  idOfOrThrow,
+  nameOfOrThrow,
+  isEqual,
+}
+/* empty Not a pure module */

package/src/Core.res

@@ -47,6 +47,22 @@ type addon = {
   addressStore: addressStoreCtor,
   @as("MockHyperSyncServer")
   mockHyperSyncServer: mockHyperSyncServerCtor,
+  encodeAddresses: (~ecosystem: string, ~addresses: array<Address.t>) => array<NodeJs.Buffer.t>,
+  renderAddresses: (
+    ~ecosystem: string,
+    ~shouldChecksum: bool,
+    ~bytes: NodeJs.Buffer.t,
+    ~lengths: array<int>,
+  ) => array<Address.t>,
+  renderContractAddresses: (
+    ~ecosystem: string,
+    ~shouldChecksum: bool,
+    ~bytes: NodeJs.Buffer.t,
+    ~lengths: array<int>,
+    ~contractIds: array<int>,
+    ~contractId: int,
+  ) => array<Address.t>,
+  canonicalContractNames: array<string> => array<string>,
   // Ordered transaction-field names exposed for the field-code contract test
   // (the ReScript `transactionFields` arrays must match the Rust ordinals).
   evmTransactionFieldNames: unit => array<string>,
@@ -84,6 +100,10 @@ let loadDevAddon: ({..}, string) => addon = %raw(`function(req, envioDir) {
   var path = Nodepath;
   var fs = Nodefs;
 
+  // Vitest test.env points workers at the addon globalSetup already built.
+  var preBuilt = process.env.ENVIO_DEV_ADDON;
+  if (preBuilt && fs.existsSync(preBuilt)) return req(preBuilt);
+
   var repoRoot = null;
   var dir = path.resolve(envioDir);
   for (var i = 0; i < 10; i++) {

package/src/Core.res.mjs

@@ -26,6 +26,10 @@ let loadDevAddon = (function(req, envioDir) {
   var path = Nodepath;
   var fs = Nodefs;
 
+  // Vitest test.env points workers at the addon globalSetup already built.
+  var preBuilt = process.env.ENVIO_DEV_ADDON;
+  if (preBuilt && fs.existsSync(preBuilt)) return req(preBuilt);
+
   var repoRoot = null;
   var dir = path.resolve(envioDir);
   for (var i = 0; i < 10; i++) {

package/src/EventConfigBuilder.res

@@ -554,10 +554,8 @@ let validSvmAccountActivityFields = Utils.Set.fromArray([
   "transactionAccountIndex",
   "isSigner",
   "isWritable",
-  "lamports",
   "lamports.pre",
   "lamports.post",
-  "token",
   "token.mint",
   "token.owner",
   "token.decimals",

package/src/EventConfigBuilder.res.mjs

@@ -396,10 +396,8 @@ let validSvmAccountActivityFields = new Set([
   "transactionAccountIndex",
   "isSigner",
   "isWritable",
-  "lamports",
   "lamports.pre",
   "lamports.post",
-  "token",
   "token.mint",
   "token.owner",
   "token.decimals",

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/InMemoryStore.res

@@ -130,11 +130,13 @@ let prepareRollbackDiff = async (
   ~rollbackTargetCheckpointId,
   ~rollbackDiffCheckpointId,
   ~progressBlockNumberByChainId,
+  ~rolledBackAddresses,
 ) => {
   state->IndexerState.beginRollbackDiff(
     ~targetCheckpointId=rollbackTargetCheckpointId,
     ~diffCheckpointId=rollbackDiffCheckpointId,
     ~progressBlockNumberByChainId,
+    ~rolledBackAddresses,
   )
   let persistence = state->IndexerState.persistence
   let committedCheckpointId = state->IndexerState.committedCheckpointId
@@ -194,12 +196,6 @@ let prepareRollbackDiff = async (
 // registered them: the store is where they already live, and it knows which
 // ones the database hasn't seen yet.
 let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
-  let inMemTable = state->getInMemTable(
-    ~entityConfig=InternalTable.EnvioAddresses.entityConfig,
-    ~scope=CrossChain,
-  )
-  let committedCheckpointId = state->IndexerState.committedCheckpointId
-
   batch.progressedChainsById->Utils.Dict.forEach(progressedChain => {
     let chainId = progressedChain.fetchState.chainId
     let chainState = state->IndexerState.getChainState(~chainId)
@@ -219,31 +215,22 @@ let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
         }
       }
 
-      chainState
-      ->ChainState.drainAddressesForWrite(
-        ~toBlockInclusive=progressedChain.progressBlockNumber,
-        ~checkpointBlockNumbers,
-      )
-      ->Array.forEach(dc => {
-        let entity: InternalTable.EnvioAddresses.t = {
-          id: InternalTable.EnvioAddresses.makeId(~chainId, ~address=dc.address),
-          chainId,
-          contractName: dc.contractName,
-          registrationBlock: dc.registrationBlock,
-          // Only ever written, never read back. Kept on the table so the column
-          // doesn't need a migration.
-          registrationLogIndex: -1,
-        }
-
-        inMemTable->InMemoryTable.Entity.set(
-          ~committedCheckpointId,
-          Set({
-            entityId: entity.id->EntityId.unsafeOfString,
-            checkpointId: checkpointIds->Array.getUnsafe(dc.checkpointIdx),
-            entity: entity->InternalTable.EnvioAddresses.castToInternal,
-          }),
+      batch.registeredAddresses->Array.pushMany(
+        chainState
+        ->ChainState.drainAddressesForWrite(
+          ~toBlockInclusive=progressedChain.progressBlockNumber,
+          ~checkpointBlockNumbers,
         )
-      })
+        ->Array.map((dc): AddressRows.staged => {
+          row: {
+            chainId,
+            address: dc.address,
+            contractId: dc.contractId,
+            registrationBlock: dc.registrationBlock,
+          },
+          checkpointId: checkpointIds->Array.getUnsafe(dc.checkpointIdx),
+        }),
+      )->ignore
     }
   })
 }