envio 3.5.0 → 3.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.5.0",
+  "version": "3.5.1",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -69,10 +69,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.5.0",
-    "envio-linux-x64-musl": "3.5.0",
-    "envio-linux-arm64": "3.5.0",
-    "envio-darwin-x64": "3.5.0",
-    "envio-darwin-arm64": "3.5.0"
+    "envio-linux-x64": "3.5.1",
+    "envio-linux-x64-musl": "3.5.1",
+    "envio-linux-arm64": "3.5.1",
+    "envio-darwin-x64": "3.5.1",
+    "envio-darwin-arm64": "3.5.1"
   }
 }

package/src/ChainFetching.res

@@ -24,25 +24,15 @@ let runContractRegistersOrThrow = async (
     ~ecosystem=config.ecosystem.name,
   )
 
-  let itemsWithDcs = []
+  let registrations: array<AddressStore.registration> = []
 
   let onRegister = (~item: Internal.item, ~contractAddress, ~contractName) => {
     let eventItem = item->Internal.castUnsafeEventItem
-    let {blockNumber} = eventItem
-
-    let dc: Internal.indexingAddress = {
+    registrations->Array.push({
       address: contractAddress,
       contractName,
-      registrationBlock: blockNumber,
-    }
-
-    switch item->Internal.getItemDcs {
-    | None => {
-        item->Internal.setItemDcs([dc])
-        itemsWithDcs->Array.push(item)
-      }
-    | Some(dcs) => dcs->Array.push(dc)
-    }
+      registrationBlock: eventItem.blockNumber,
+    })
   }
 
   let promises = []
@@ -101,7 +91,7 @@ let runContractRegistersOrThrow = async (
     let _ = await Promise.all(promises)
   }
 
-  itemsWithDcs
+  registrations
 }
 
 let rec onQueryResponse = async (
@@ -226,13 +216,13 @@ let rec onQueryResponse = async (
 
       // Re-check staleness: contract registration is async, so the chain state
       // may have rolled back by the time we apply the fetched items.
-      let proceed = (~newItemsWithDcs) =>
+      let proceed = (~newRegistrations) =>
         if !(state->IndexerState.isStale(~stateId)) {
           applyQueryResponse(
             state,
             ~chainId,
             ~newItems,
-            ~newItemsWithDcs,
+            ~newRegistrations,
             ~knownHeight,
             ~latestFetchedBlock={
               FetchState.blockNumber: latestFetchedBlockNumber,
@@ -248,7 +238,7 @@ let rec onQueryResponse = async (
         }
 
       switch itemsWithContractRegister {
-      | [] => proceed(~newItemsWithDcs=[])
+      | [] => proceed(~newRegistrations=[])
       | _ =>
         switch await runContractRegistersOrThrow(
           ~itemsWithContractRegister,
@@ -257,7 +247,7 @@ let rec onQueryResponse = async (
           ~blockStore,
         ) {
         | exception exn => IndexerState.errorExit(state, exn->ErrorHandling.make)
-        | newItemsWithDcs => proceed(~newItemsWithDcs)
+        | newRegistrations => proceed(~newRegistrations)
         }
       }
     }
@@ -267,7 +257,7 @@ and applyQueryResponse = (
   state: IndexerState.t,
   ~chainId,
   ~newItems,
-  ~newItemsWithDcs,
+  ~newRegistrations,
   ~knownHeight,
   ~latestFetchedBlock,
   ~query,
@@ -281,7 +271,7 @@ and applyQueryResponse = (
     ~query,
     ~latestFetchedBlock,
     ~newItems,
-    ~newItemsWithDcs,
+    ~newRegistrations,
     ~knownHeight,
     ~transactionStore,
     ~blockStore,

package/src/ChainFetching.res.mjs

@@ -18,21 +18,13 @@ import * as ContractRegisterContext from "./ContractRegisterContext.res.mjs";
 
 async function runContractRegistersOrThrow(itemsWithContractRegister, config, transactionStore, blockStore) {
   await ChainState.materializePageItems(itemsWithContractRegister, transactionStore, blockStore, config.ecosystem.name);
-  let itemsWithDcs = [];
+  let registrations = [];
   let onRegister = (item, contractAddress, contractName) => {
-    let dc_registrationBlock = item.blockNumber;
-    let dc = {
+    registrations.push({
       address: contractAddress,
       contractName: contractName,
-      registrationBlock: dc_registrationBlock
-    };
-    let dcs = item.dcs;
-    if (dcs !== undefined) {
-      dcs.push(dc);
-    } else {
-      item.dcs = [dc];
-      itemsWithDcs.push(item);
-    }
+      registrationBlock: item.blockNumber
+    });
   };
   let promises = [];
   for (let idx = 0, idx_finish = itemsWithContractRegister.length; idx < idx_finish; ++idx) {
@@ -68,13 +60,13 @@ async function runContractRegistersOrThrow(itemsWithContractRegister, config, tr
   if (Utils.$$Array.notEmpty(promises)) {
     await Promise.all(promises);
   }
-  return itemsWithDcs;
+  return registrations;
 }
 
-function applyQueryResponse(state, chainId, newItems, newItemsWithDcs, knownHeight, latestFetchedBlock, query, transactionStore, blockStore) {
+function applyQueryResponse(state, chainId, newItems, newRegistrations, knownHeight, latestFetchedBlock, query, transactionStore, blockStore) {
   let chainState = IndexerState.getChainState(state, chainId);
   let wasFetchingAtHead = ChainState.isFetchingAtHead(chainState);
-  ChainState.handleQueryResult(chainState, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight, transactionStore, blockStore);
+  ChainState.handleQueryResult(chainState, query, newItems, newRegistrations, latestFetchedBlock, knownHeight, transactionStore, blockStore);
   if (IndexerState.exitAfterFirstEventBlock(state) && newItems.length !== 0) {
     ChainState.setEndBlockToFirstEvent(chainState, newItems[0].blockNumber);
   }
@@ -152,9 +144,9 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
       itemsWithContractRegister.push(item);
     }
   }
-  let proceed = newItemsWithDcs => {
+  let proceed = newRegistrations => {
     if (!IndexerState.isStale(state, stateId)) {
-      applyQueryResponse(state, chainId, parsedQueueItems, newItemsWithDcs, knownHeight, {
+      applyQueryResponse(state, chainId, parsedQueueItems, newRegistrations, knownHeight, {
         blockNumber: latestFetchedBlockNumber,
         blockTimestamp: latestFetchedBlockTimestamp
       }, query, transactionStore, blockStore);
@@ -166,14 +158,14 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   if (itemsWithContractRegister.length === 0) {
     return proceed([]);
   }
-  let newItemsWithDcs;
+  let newRegistrations;
   try {
-    newItemsWithDcs = await runContractRegistersOrThrow(itemsWithContractRegister, IndexerState.config(state), transactionStore, blockStore);
+    newRegistrations = await runContractRegistersOrThrow(itemsWithContractRegister, IndexerState.config(state), transactionStore, blockStore);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, undefined));
   }
-  return proceed(newItemsWithDcs);
+  return proceed(newRegistrations);
 }
 
 function finishWaitingForNewBlock(state, chainId, knownHeight, stateId, scheduleFetch, scheduleProcessing) {

package/src/ChainState.res

@@ -130,6 +130,19 @@ let make = (
   }
 }
 
+// Every chain's contracts, not just one chain's: `context.chain.X.add` accepts
+// any config contract, whichever chain declared it, so every chain's address
+// store has to hold the whole set.
+let configContractNames = (config: Config.t) => {
+  let names = Utils.Set.make()
+  config.chainMap
+  ->ChainMap.values
+  ->Array.forEach(chain =>
+    chain.contracts->Array.forEach(contract => names->Utils.Set.add(contract.name)->ignore)
+  )
+  names->Utils.Set.toArray
+}
+
 let makeInternal = (
   ~chainConfig: Config.chain,
   ~indexingAddresses: array<Internal.indexingAddress>,
@@ -174,7 +187,10 @@ let makeInternal = (
   let addressStore = AddressStore.make(
     ~ecosystem=config.ecosystem.name,
     ~shouldChecksum=!lowercaseAddresses,
-    ~contracts=AddressStore.contractsOf(~onEventRegistrations),
+    ~contracts=AddressStore.contractsOf(
+      ~onEventRegistrations,
+      ~configContractNames=config->configContractNames,
+    ),
   )
 
   let fetchState = FetchState.make(
@@ -430,6 +446,15 @@ let setRollbackTargetBlock = (cs: t, ~blockNumber) => cs.rollbackTargetBlock = S
 let knownHeight = (cs: t) => cs.fetchState.knownHeight
 let contractAddresses = (cs: t, ~contractName) =>
   cs.addressStore->AddressStore.contractAddresses(contractName)
+
+// Hands over the dynamically registered addresses the database hasn't seen yet,
+// up to the block the caller is about to commit, each paired with the checkpoint
+// that owns its row. Destructive: the caller must persist them or take the
+// indexer down. Throws with nothing consumed when a registration's block has no
+// checkpoint in the batch.
+let drainAddressesForWrite = (cs: t, ~toBlockInclusive, ~checkpointBlockNumbers) =>
+  cs.addressStore->AddressStore.drainForWrite(toBlockInclusive, checkpointBlockNumbers)
+let hasAddressesToWrite = (cs: t) => cs.addressStore->AddressStore.pendingCount > 0
 let bufferSize = (cs: t) => cs.fetchState->FetchState.bufferSize
 let bufferReadyCount = (cs: t) => cs.fetchState->FetchState.bufferReadyCount
 let getProgressPercentage = (cs: t) => cs.fetchState->FetchState.getProgressPercentage
@@ -841,7 +866,7 @@ let handleQueryResult = (
   cs: t,
   ~query: FetchState.query,
   ~newItems,
-  ~newItemsWithDcs,
+  ~newRegistrations,
   ~latestFetchedBlock: FetchState.blockNumberAndTimestamp,
   ~knownHeight,
   ~transactionStore as txPage: option<TransactionStore.t>,
@@ -858,7 +883,7 @@ let handleQueryResult = (
   | None => ()
   }
 
-  let fs = switch newItemsWithDcs {
+  let fs = switch newRegistrations {
   | [] => cs.fetchState
   | _ =>
     cs.fetchState->FetchState.registerDynamicContracts(
@@ -868,7 +893,7 @@ let handleQueryResult = (
       // catch-up range — and an unbounded query can reach past the height that
       // was known when it went out.
       ~claimCeiling=Pervasives.max(knownHeight, latestFetchedBlock.blockNumber),
-      newItemsWithDcs,
+      newRegistrations,
     )
   }
 

package/src/ChainState.res.mjs

@@ -6,6 +6,7 @@ import * as Batch from "./Batch.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
 import * as EvmChain from "./sources/EvmChain.res.mjs";
 import * as FieldMask from "./sources/FieldMask.res.mjs";
 import * as BlockStore from "./sources/BlockStore.res.mjs";
@@ -90,6 +91,16 @@ function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, so
   };
 }
 
+function configContractNames(config) {
+  let names = new Set();
+  ChainMap.values(config.chainMap).forEach(chain => {
+    chain.contracts.forEach(contract => {
+      names.add(contract.name);
+    });
+  });
+  return Array.from(names);
+}
+
 function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBlockOpt, progressBlockNumber, config, registrationsByChainId, logger, timestampCaughtUpToHeadOrEndblock, numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, maxReorgDepth, knownHeightOpt, isResumedOpt, reducedPollingInterval) {
   let firstEventBlock = firstEventBlockOpt !== undefined ? Primitive_option.valFromOption(firstEventBlockOpt) : undefined;
   let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : 0;
@@ -106,7 +117,7 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
     }
   });
   let lowercaseAddresses = config.lowercaseAddresses;
-  let addressStore = AddressStore.make(config.ecosystem.name, !lowercaseAddresses, AddressStore.contractsOf(onEventRegistrations));
+  let addressStore = AddressStore.make(config.ecosystem.name, !lowercaseAddresses, AddressStore.contractsOf(onEventRegistrations, configContractNames(config)));
   let match$1 = config.ecosystem.name;
   let tmp;
   switch (match$1) {
@@ -259,6 +270,14 @@ function contractAddresses(cs, contractName) {
   return cs.addressStore.contractAddresses(contractName);
 }
 
+function drainAddressesForWrite(cs, toBlockInclusive, checkpointBlockNumbers) {
+  return cs.addressStore.drainForWrite(toBlockInclusive, checkpointBlockNumbers);
+}
+
+function hasAddressesToWrite(cs) {
+  return cs.addressStore.pendingCount() > 0;
+}
+
 function bufferSize(cs) {
   return FetchState.bufferSize(cs.fetchState);
 }
@@ -565,14 +584,14 @@ async function materializePageItems(items, transactionStore, blockStore, ecosyst
   ]);
 }
 
-function handleQueryResult(cs, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight, txPage, blockPage) {
+function handleQueryResult(cs, query, newItems, newRegistrations, latestFetchedBlock, knownHeight, txPage, blockPage) {
   if (txPage !== undefined) {
     cs.transactionStore.merge(Primitive_option.valFromOption(txPage));
   }
   if (blockPage !== undefined) {
     cs.blockStore.merge(Primitive_option.valFromOption(blockPage));
   }
-  let fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, cs.addressStore, Primitive_int.max(knownHeight, latestFetchedBlock.blockNumber), newItemsWithDcs) : cs.fetchState;
+  let fs = newRegistrations.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, cs.addressStore, Primitive_int.max(knownHeight, latestFetchedBlock.blockNumber), newRegistrations) : cs.fetchState;
   cs.fetchState = FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight);
   cs.pendingBudget = Primitive_float.max(0, cs.pendingBudget - query.itemsEst);
 }
@@ -837,6 +856,8 @@ export {
   setRollbackTargetBlock,
   knownHeight,
   contractAddresses,
+  drainAddressesForWrite,
+  hasAddressesToWrite,
   bufferSize,
   bufferReadyCount,
   getProgressPercentage,

package/src/ChainState.resi

@@ -69,6 +69,12 @@ let setRollbackTargetBlock: (t, ~blockNumber: int) => unit
 // Fetch-frontier reads.
 let knownHeight: t => int
 let contractAddresses: (t, ~contractName: string) => array<Address.t>
+let drainAddressesForWrite: (
+  t,
+  ~toBlockInclusive: int,
+  ~checkpointBlockNumbers: array<int>,
+) => array<AddressStore.drainedAddress>
+let hasAddressesToWrite: t => bool
 let bufferSize: t => int
 let bufferReadyCount: t => int
 let getProgressPercentage: t => float
@@ -110,7 +116,7 @@ let handleQueryResult: (
   t,
   ~query: FetchState.query,
   ~newItems: array<Internal.item>,
-  ~newItemsWithDcs: array<Internal.item>,
+  ~newRegistrations: array<AddressStore.registration>,
   ~latestFetchedBlock: FetchState.blockNumberAndTimestamp,
   ~knownHeight: int,
   ~transactionStore: option<TransactionStore.t>,

package/src/Config.res

@@ -114,7 +114,8 @@ module EnvioAddresses = {
     id: string,
     @as("chain_id") chainId: ChainId.t,
     @as("registration_block") registrationBlock: int,
-    // -1 when the address was registered from a block handler (no log index)
+    // Vestigial: always written as -1 and never read back. The column stays so
+    // an existing schema doesn't need a migration.
     @as("registration_log_index") registrationLogIndex: int,
     @as("contract_name") contractName: string,
   }

package/src/FetchState.res

@@ -1473,7 +1473,7 @@ let warnRejectedRegistration = (
       ~params={"contractName": contractName},
       `Skipping contract registration: Not a valid address for this chain's ecosystem.`,
     )
-  | Added(_) | NoEvents(_) => ()
+  | Added(_) => ()
   }
 
 /**
@@ -1678,9 +1678,9 @@ let registerDynamicContracts = (
   // height in here. Defaults to what the fetch state knows, which is all
   // there is to go on when no response is being applied.
   ~claimCeiling=fetchState.knownHeight,
-  // These are raw items which might have dynamic contracts received from contractRegister call.
-  // Might contain duplicates which we should filter out
-  items: array<Internal.item>,
+  // Registrations collected from contractRegister calls, in the order the
+  // handlers made them. May contain duplicates, which the store filters out.
+  registrations: array<AddressStore.registration>,
 ) => {
   if fetchState.normalSelection.onEventRegistrations->Utils.Array.isEmpty {
     // Can the normalSelection be empty?
@@ -1689,91 +1689,42 @@ let registerDynamicContracts = (
     )
   }
 
-  // Flatten every item's dcs into one batch, remembering where each came from
-  // so the rejected ones can be spliced back out of their item (which is what
-  // keeps them from being persisted twice).
-  let registrations: array<AddressStore.registration> = []
-  let sourceDcs: array<Internal.dcs> = []
-  let sourceIndexes: array<int> = []
-  for itemIdx in 0 to items->Array.length - 1 {
-    switch items->Array.getUnsafe(itemIdx)->Internal.getItemDcs {
-    | None => ()
-    | Some(dcs) =>
-      for dcIdx in 0 to dcs->Array.length - 1 {
-        let dc = dcs->Array.getUnsafe(dcIdx)
-        registrations
-        ->Array.push({
-          address: dc.address,
-          contractName: dc.contractName,
-          registrationBlock: dc.registrationBlock,
-        })
-        ->ignore
-        sourceDcs->Array.push(dcs)->ignore
-        sourceIndexes->Array.push(dcIdx)->ignore
-      }
-    }
-  }
-
   // Ids are handed out in registration order, so a cursor taken now selects
   // 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.
+  // 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.
   let verdicts = addressStore->AddressStore.registerBatch(registrations)
 
   let registeringContractNames = []
-  let hasNoEventsUpdatesRef = ref(false)
   for idx in 0 to verdicts->Array.length - 1 {
     let registration = registrations->Array.getUnsafe(idx)
     let verdict = verdicts->Array.getUnsafe(idx)
-    let keep = switch verdict {
-    | Added(_) =>
+    switch verdict {
+    | Added({fetchable: true}) =>
       if !(registeringContractNames->Array.includes(registration.contractName)) {
         registeringContractNames->Array.push(registration.contractName)->ignore
       }
-      true
-    | NoEvents(_) =>
-      hasNoEventsUpdatesRef := true
-      // Persist the address to the db so a future config change that adds
-      // events for this contract can pick it up on restart, but skip partition
-      // registration since there's nothing to fetch.
-      warnAddressRegistration(
-        ~chainId=fetchState.chainId,
-        ~contractAddress=registration.address,
-        ~params={"contractName": registration.contractName},
-        `Persisting contract registration without fetching: Contract doesn't have any events to fetch. It'll be picked up on restart if you add events for the contract.`,
-      )
-      true
+    // Nothing on this chain is fetched by address for the contract, so there's
+    // 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 =>
       verdict->warnRejectedRegistration(
         ~chainId=fetchState.chainId,
         ~contractAddress=registration.address,
         ~contractName=registration.contractName,
       )
-      false
-    }
-    if !keep {
-      // Mark for removal; the splice happens below, back to front, so earlier
-      // indexes stay valid.
-      sourceIndexes->Array.setUnsafe(idx, -1 - sourceIndexes->Array.getUnsafe(idx))
-    }
-  }
-  for idx in verdicts->Array.length - 1 downto 0 {
-    let marked = sourceIndexes->Array.getUnsafe(idx)
-    if marked < 0 {
-      let _ =
-        sourceDcs->Array.getUnsafe(idx)->Array.splice(~start=-1 - marked, ~remove=1, ~insert=[])
     }
   }
 
-  switch (registeringContractNames, hasNoEventsUpdatesRef.contents) {
-  // Dont update anything when everything was filtered out
-  | ([], false) => fetchState
-  // Only dcs for contracts without events. The store already tracks them so
-  // subsequent registrations see them, but there are no partitions to touch.
-  | ([], true) => fetchState
-  | (_, _) => {
+  switch registeringContractNames {
+  // Nothing to fetch: everything was rejected, or registered for contracts
+  // this chain has no address-dependent events for.
+  | [] => fetchState
+  | _ => {
       let newPartitions = []
       let dynamicContractsRef = ref(fetchState.optimizedPartitions.dynamicContracts)
       let mutExistingPartitions = fetchState.optimizedPartitions.entities->Dict.valuesToArray
@@ -1835,7 +1786,11 @@ let registerDynamicContracts = (
                         dynamicContract: Some(contractName),
                         addresses: splitAddresses,
                         mergeBlock: None,
-                        mutPendingQueries: p.mutPendingQueries,
+                        // Must be a fresh array: sharing p's (empty) queue by
+                        // reference lets both split halves push and consume in
+                        // one array, so one half can consume the other's
+                        // fetched range and skip it for its own addresses.
+                        mutPendingQueries: [],
                         sourceRangeCapacity: p.sourceRangeCapacity,
                         prevSourceRangeCapacity: p.prevSourceRangeCapacity,
                         eventDensity: p.eventDensity,
@@ -2709,7 +2664,9 @@ let make = (
   // contract has no address-dependent events, so a later registration of the
   // same address still conflicts and the address is still persisted.
   addressStore
-  ->AddressStore.registerBatch(
+  // 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,

package/src/FetchState.res.mjs

@@ -1086,7 +1086,6 @@ function warnRejectedRegistration(verdict, chainId, contractAddress, contractNam
   }
   switch (verdict.TAG) {
     case "Added" :
-    case "NoEvents" :
       return;
     case "Duplicate" :
       let existingEffectiveStartBlock = verdict.existingEffectiveStartBlock;
@@ -1225,71 +1224,25 @@ function createPartitions(registeringSetsByContract, addressStore, dynamicContra
   return make(allPartitions, maxAddrInPartition, nextPartitionIndexRef.contents, dynamicContracts, clientFilteredContracts);
 }
 
-function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, items) {
+function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, registrations) {
   let claimCeiling = claimCeilingOpt !== undefined ? claimCeilingOpt : fetchState.knownHeight;
   if (Utils.$$Array.isEmpty(fetchState.normalSelection.onEventRegistrations)) {
     Stdlib_JsError.throwWithMessage("Invalid configuration. No events to fetch for the dynamic contract registration.");
   }
-  let registrations = [];
-  let sourceDcs = [];
-  let sourceIndexes = [];
-  for (let itemIdx = 0, itemIdx_finish = items.length; itemIdx < itemIdx_finish; ++itemIdx) {
-    let dcs = items[itemIdx].dcs;
-    if (dcs !== undefined) {
-      for (let dcIdx = 0, dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx) {
-        let dc = dcs[dcIdx];
-        registrations.push({
-          address: dc.address,
-          contractName: dc.contractName,
-          registrationBlock: dc.registrationBlock
-        });
-        sourceDcs.push(dcs);
-        sourceIndexes.push(dcIdx);
-      }
-    }
-  }
   let idCursor = addressStore.nextId();
   let verdicts = AddressStore.registerBatch(addressStore, registrations);
   let registeringContractNames = [];
-  let hasNoEventsUpdatesRef = false;
   for (let idx = 0, idx_finish = verdicts.length; idx < idx_finish; ++idx) {
     let registration = registrations[idx];
     let verdict = verdicts[idx];
-    let keep;
     let exit = 0;
-    if (typeof verdict !== "object") {
+    if (typeof verdict !== "object" || verdict.TAG !== "Added") {
       exit = 1;
-    } else {
-      switch (verdict.TAG) {
-        case "Added" :
-          if (!registeringContractNames.includes(registration.contractName)) {
-            registeringContractNames.push(registration.contractName);
-          }
-          keep = true;
-          break;
-        case "NoEvents" :
-          hasNoEventsUpdatesRef = true;
-          warnAddressRegistration(fetchState.chainId, registration.address, {
-            contractName: registration.contractName
-          }, `Persisting contract registration without fetching: Contract doesn't have any events to fetch. It'll be picked up on restart if you add events for the contract.`);
-          keep = true;
-          break;
-        default:
-          exit = 1;
-      }
+    } else if (verdict.fetchable && !registeringContractNames.includes(registration.contractName)) {
+      registeringContractNames.push(registration.contractName);
     }
     if (exit === 1) {
       warnRejectedRegistration(verdict, fetchState.chainId, registration.address, registration.contractName);
-      keep = false;
-    }
-    if (!keep) {
-      sourceIndexes[idx] = -1 - sourceIndexes[idx] | 0;
-    }
-  }
-  for (let idx$1 = verdicts.length - 1 | 0; idx$1 >= 0; --idx$1) {
-    let marked = sourceIndexes[idx$1];
-    if (marked < 0) {
-      sourceDcs[idx$1].splice(-1 - marked | 0, 1);
     }
   }
   if (registeringContractNames.length === 0) {
@@ -1298,12 +1251,12 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
   let newPartitions = [];
   let dynamicContractsRef = fetchState.optimizedPartitions.dynamicContracts;
   let mutExistingPartitions = Object.values(fetchState.optimizedPartitions.entities);
-  for (let idx$2 = 0, idx_finish$1 = registeringContractNames.length; idx$2 < idx_finish$1; ++idx$2) {
-    let contractName = registeringContractNames[idx$2];
+  for (let idx$1 = 0, idx_finish$1 = registeringContractNames.length; idx$1 < idx_finish$1; ++idx$1) {
+    let contractName = registeringContractNames[idx$1];
     if (!dynamicContractsRef.has(contractName)) {
       dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
-      for (let idx$3 = 0, idx_finish$2 = mutExistingPartitions.length; idx$3 < idx_finish$2; ++idx$3) {
-        let p = mutExistingPartitions[idx$3];
+      for (let idx$2 = 0, idx_finish$2 = mutExistingPartitions.length; idx$2 < idx_finish$2; ++idx$2) {
+        let p = mutExistingPartitions[idx$2];
         let match = p.addresses.countFor(contractName);
         if (match !== 0 && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
           let allPartitionContractNames = p.addresses.contractNames();
@@ -1312,7 +1265,7 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
             if (!isFetching) {
               let newPartitionId = (fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0).toString();
               let restNames = allPartitionContractNames.filter(name => name !== contractName);
-              mutExistingPartitions[idx$3] = withAddresses(p, p.addresses.filterByContracts(restNames));
+              mutExistingPartitions[idx$2] = withAddresses(p, p.addresses.filterByContracts(restNames));
               let splitAddresses = p.addresses.filterByContracts([contractName]);
               newPartitions.push({
                 id: newPartitionId,
@@ -1321,7 +1274,7 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
                 addresses: splitAddresses,
                 mergeBlock: undefined,
                 dynamicContract: contractName,
-                mutPendingQueries: p.mutPendingQueries,
+                mutPendingQueries: [],
                 sourceRangeCapacity: p.sourceRangeCapacity,
                 prevSourceRangeCapacity: p.prevSourceRangeCapacity,
                 eventDensity: p.eventDensity,
@@ -1329,7 +1282,7 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
               });
             }
           } else {
-            mutExistingPartitions[idx$3] = {
+            mutExistingPartitions[idx$2] = {
               id: p.id,
               latestFetchedBlock: p.latestFetchedBlock,
               selection: p.selection,
@@ -1786,7 +1739,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
     });
   }
   let normalSelection = makeSelection(normalRegistrations, true, undefined);
-  AddressStore.registerBatch(addressStore, addresses.map(contract => ({
+  AddressStore.seedBatch(addressStore, addresses.map(contract => ({
     address: contract.address,
     contractName: contract.contractName,
     registrationBlock: contract.registrationBlock

package/src/InMemoryStore.res

@@ -157,46 +157,58 @@ let prepareRollbackDiff = async (
   }
 }
 
+// Stages the addresses registered by this batch's events for the write. They're
+// drained from each chain's address store rather than carried on the items that
+// 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)
   let committedCheckpointId = state->IndexerState.committedCheckpointId
 
-  let itemIdx = ref(0)
-
-  for checkpoint in 0 to batch.checkpointIds->Array.length - 1 {
-    let checkpointId = batch.checkpointIds->Array.getUnsafe(checkpoint)
-    let chainId = batch.checkpointChainIds->Array.getUnsafe(checkpoint)
-    let checkpointEventsProcessed = batch.checkpointEventsProcessed->Array.getUnsafe(checkpoint)
-
-    for idx in 0 to checkpointEventsProcessed - 1 {
-      let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
-      switch item->Internal.getItemDcs {
-      | None => ()
-      | Some(dcs) =>
-        // Currently only events support contract registration, so we can cast to event item
-        let eventItem = item->Internal.castUnsafeEventItem
-        for dcIdx in 0 to dcs->Array.length - 1 {
-          let dc = dcs->Array.getUnsafe(dcIdx)
-          let entity: InternalTable.EnvioAddresses.t = {
-            id: InternalTable.EnvioAddresses.makeId(~chainId, ~address=dc.address),
-            chainId,
-            contractName: dc.contractName,
-            registrationBlock: eventItem.blockNumber,
-            registrationLogIndex: eventItem.logIndex,
-          }
-
-          inMemTable->InMemoryTable.Entity.set(
-            ~committedCheckpointId,
-            Set({
-              entityId: entity.id->EntityId.unsafeOfString,
-              checkpointId,
-              entity: entity->InternalTable.EnvioAddresses.castToInternal,
-            }),
-          )
+  batch.progressedChainsById->Utils.Dict.forEach(progressedChain => {
+    let chainId = progressedChain.fetchState.chainId
+    let chainState = state->IndexerState.getChainState(~chainId)
+
+    // Most batches register nothing, so the checkpoints are only collected for a
+    // chain that has something waiting.
+    if chainState->ChainState.hasAddressesToWrite {
+      // The store pairs each drained registration with a checkpoint of its own
+      // chain, so only this chain's checkpoints go in — and the index it returns
+      // points back into these two parallel arrays.
+      let checkpointIds = []
+      let checkpointBlockNumbers = []
+      for idx in 0 to batch.checkpointIds->Array.length - 1 {
+        if batch.checkpointChainIds->Array.getUnsafe(idx) === chainId {
+          checkpointIds->Array.push(batch.checkpointIds->Array.getUnsafe(idx))
+          checkpointBlockNumbers->Array.push(batch.checkpointBlockNumbers->Array.getUnsafe(idx))
         }
       }
-    }
 
-    itemIdx := itemIdx.contents + checkpointEventsProcessed
-  }
+      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,
+          }),
+        )
+      })
+    }
+  })
 }

package/src/InMemoryStore.res.mjs

@@ -4,6 +4,7 @@ import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Internal from "./Internal.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
 import * as EffectState from "./EffectState.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
@@ -117,39 +118,39 @@ async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDi
 function setBatchDcs(state, batch) {
   let inMemTable = getInMemTable(state, Config.EnvioAddresses.entityConfig);
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
-  let itemIdx = 0;
-  for (let checkpoint = 0, checkpoint_finish = batch.checkpointIds.length; checkpoint < checkpoint_finish; ++checkpoint) {
-    let checkpointId = batch.checkpointIds[checkpoint];
-    let chainId = batch.checkpointChainIds[checkpoint];
-    let checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpoint];
-    for (let idx = 0; idx < checkpointEventsProcessed; ++idx) {
-      let item = batch.items[itemIdx + idx | 0];
-      let dcs = item.dcs;
-      if (dcs !== undefined) {
-        for (let dcIdx = 0, dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx) {
-          let dc = dcs[dcIdx];
-          let entity_id = Config.EnvioAddresses.makeId(chainId, dc.address);
-          let entity_registration_block = item.blockNumber;
-          let entity_registration_log_index = item.logIndex;
-          let entity_contract_name = dc.contractName;
-          let entity = {
-            id: entity_id,
-            chain_id: chainId,
-            registration_block: entity_registration_block,
-            registration_log_index: entity_registration_log_index,
-            contract_name: entity_contract_name
-          };
-          InMemoryTable.Entity.set(inMemTable, committedCheckpointId, {
-            type: "SET",
-            entityId: entity_id,
-            entity: entity,
-            checkpointId: checkpointId
-          });
-        }
+  Utils.Dict.forEach(batch.progressedChainsById, progressedChain => {
+    let chainId = progressedChain.fetchState.chainId;
+    let chainState = IndexerState.getChainState(state, chainId);
+    if (!ChainState.hasAddressesToWrite(chainState)) {
+      return;
+    }
+    let checkpointIds = [];
+    let checkpointBlockNumbers = [];
+    for (let idx = 0, idx_finish = batch.checkpointIds.length; idx < idx_finish; ++idx) {
+      if (batch.checkpointChainIds[idx] === chainId) {
+        checkpointIds.push(batch.checkpointIds[idx]);
+        checkpointBlockNumbers.push(batch.checkpointBlockNumbers[idx]);
       }
     }
-    itemIdx = itemIdx + checkpointEventsProcessed | 0;
-  }
+    ChainState.drainAddressesForWrite(chainState, progressedChain.progressBlockNumber, checkpointBlockNumbers).forEach(dc => {
+      let entity_id = Config.EnvioAddresses.makeId(chainId, dc.address);
+      let entity_registration_block = dc.registrationBlock;
+      let entity_contract_name = dc.contractName;
+      let entity = {
+        id: entity_id,
+        chain_id: chainId,
+        registration_block: entity_registration_block,
+        registration_log_index: -1,
+        contract_name: entity_contract_name
+      };
+      InMemoryTable.Entity.set(inMemTable, committedCheckpointId, {
+        type: "SET",
+        entityId: entity_id,
+        entity: entity,
+        checkpointId: checkpointIds[dc.checkpointIdx]
+      });
+    });
+  });
 }
 
 export {

package/src/Internal.res

@@ -616,8 +616,6 @@ type indexingAddress = {
   registrationBlock: int,
 }
 
-type dcs = array<indexingAddress>
-
 // Duplicate the type from item to keep item properly unboxed. Runtime event
 // items carry the registration their source already resolved from the
 // ChainState-owned registration array.
@@ -698,11 +696,6 @@ let getItemChainId = item =>
   | Block({onBlockRegistration: {chainId}}) => chainId
   }
 
-@get
-external getItemDcs: item => option<dcs> = "dcs"
-@set
-external setItemDcs: (item, dcs) => unit = "dcs"
-
 type eventOptions<'where> = {
   wildcard?: bool,
   where?: 'where,

package/src/bindings/Vitest.res

@@ -119,9 +119,6 @@ module Async = {
   @module("vitest") @scope("it")
   external it_fails: (string, testContext => promise<unit>) => unit = "fails"
 
-  let isClaudeCloud: bool = %raw(`process.env.CLAUDE_CODE_CONTAINER_ID != null`)
-  let itSkipInClaudeCloud = (name, fn) => it_skipIf(isClaudeCloud)(name, fn)
-
   @module("vitest")
   external test: (string, testContext => promise<unit>) => unit = "test"
 

package/src/bindings/Vitest.res.mjs

@@ -1,17 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Vitest from "vitest";
 
-let isClaudeCloud = (process.env.CLAUDE_CODE_CONTAINER_ID != null);
-
-function itSkipInClaudeCloud(name, fn) {
-  Vitest.it.skipIf(isClaudeCloud)(name, fn);
-}
-
-let Async = {
-  isClaudeCloud: isClaudeCloud,
-  itSkipInClaudeCloud: itSkipInClaudeCloud
-};
+let Async = {};
 
 let messageOfThrown = (function (fn) {
   try {
@@ -31,4 +21,4 @@ export {
   messageOfThrown,
   toThrowErrorEqual,
 }
-/* isClaudeCloud Not a pure module */
+/* No side effect */

package/src/sources/AddressStore.res

@@ -7,10 +7,12 @@
 // (or address-valued param) isn't registered at the item's block.
 type t
 
-// A contract the chain has events for. An address registered for anything else
-// gets the `NoEvents` verdict: persisted so a future config that adds events
-// picks it up, but never fetched.
-type contract = {name: string, startBlock: option<int>}
+// A contract an address may be registered for. Every config contract of every
+// chain, since `context.chain.<Contract>.add` validates against that whole set
+// — a name outside it makes the store throw. `dependsOnAddresses` is whether
+// this chain fetches for the contract by address, which is what makes the store
+// able to answer `fetchable` on a verdict.
+type contract = {name: string, startBlock: option<int>, dependsOnAddresses: bool}
 
 type registration = {
   address: Address.t,
@@ -20,9 +22,10 @@ type registration = {
 }
 
 type verdict =
-  | Added({effectiveStartBlock: int})
-  // Contract has no events; tracked and persisted, never fetched.
-  | NoEvents({effectiveStartBlock: int})
+  // `fetchable` is false when nothing on the chain is fetched by address for the
+  // contract: the address is still stored and persisted, so a config that later
+  // adds events picks it up on restart, but no partition is built from it.
+  | Added({effectiveStartBlock: int, fetchable: bool})
   // Already registered for the same contract.
   | Duplicate({effectiveStartBlock: int, existingEffectiveStartBlock: int})
   // Already registered for a different contract.
@@ -32,11 +35,22 @@ type verdict =
 
 type rawVerdict = {
   kind: string,
+  fetchable: bool,
   effectiveStartBlock: int,
   existingContractName: Null.t<string>,
   existingEffectiveStartBlock: Null.t<int>,
 }
 
+// A registration the store handed over for persistence, paired with the
+// checkpoint that owns its row. `checkpointIdx` indexes the block numbers
+// passed to `drainForWrite` — the ids stay on the JS side.
+type drainedAddress = {
+  address: Address.t,
+  contractName: string,
+  registrationBlock: int,
+  checkpointIdx: int,
+}
+
 type makeSetOptions = {
   // Only addresses whose id is at or above this. Ids are handed out in
   // registration order, so a cursor read before a batch (`nextId`) selects
@@ -66,22 +80,37 @@ let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool, ~contracts: array
   }
 }
 
-// The contracts of a chain that have events, with the earliest block any of
-// their events may fire at. `None` means unrestricted, so it wins over any
-// `Some`: one registration without a start block makes the whole contract's
-// address gate open from the chain's start, and the per-registration start
-// block still holds back the registrations that declared one.
-let contractsOf = (~onEventRegistrations: array<Internal.onEventRegistration>): array<contract> => {
+// Every contract an address may be registered for, with the earliest block any
+// of this chain's events for it may fire at. `None` means unrestricted, so it
+// wins over any `Some`: one registration without a start block makes the whole
+// contract's address gate open from the chain's start, and the per-registration
+// start block still holds back the registrations that declared one.
+//
+// A contract whose events are all wildcard is fetched without consulting
+// addresses, so registering one changes nothing about what's queried — it
+// carries `dependsOnAddresses: false` just like a contract named only by
+// `configContractNames`. Either way the addresses are stored and persisted,
+// never fetched.
+let contractsOf = (
+  ~onEventRegistrations: array<Internal.onEventRegistration>,
+  ~configContractNames: array<string>,
+): array<contract> => {
   // Only ever holds a declared start block, so a missing key is unambiguous —
   // storing `None` in a dict would be indistinguishable from "not seen yet".
   let startBlocks: dict<int> = Dict.make()
   let unrestricted = Utils.Set.make()
+  let addressDependent = Utils.Set.make()
   let names = []
-  onEventRegistrations->Array.forEach(reg => {
-    let name = reg.eventConfig.contractName
+  let addName = name =>
     if !(names->Array.includes(name)) {
       names->Array.push(name)->ignore
     }
+  onEventRegistrations->Array.forEach(reg => {
+    let name = reg.eventConfig.contractName
+    addName(name)
+    if reg.dependsOnAddresses {
+      addressDependent->Utils.Set.add(name)->ignore
+    }
     switch reg.startBlock {
     | None => unrestricted->Utils.Set.add(name)->ignore
     | Some(startBlock) =>
@@ -94,11 +123,13 @@ let contractsOf = (~onEventRegistrations: array<Internal.onEventRegistration>):
       )
     }
   })
+  configContractNames->Array.forEach(addName)
   names->Array.map(name => {
     name,
     startBlock: unrestricted->Utils.Set.has(name)
       ? None
       : startBlocks->Utils.Dict.dangerouslyGetNonOption(name),
+    dependsOnAddresses: addressDependent->Utils.Set.has(name),
   })
 }
 
@@ -112,10 +143,24 @@ let contractsOf = (~onEventRegistrations: array<Internal.onEventRegistration>):
 // come from that chain's one store — ids are store-scoped, so sets from
 // different stores can't be merged.
 @send external makeSetOf: (t, array<Address.t>) => AddressSet.t = "makeSetOf"
-@send external registerBatchRaw: (t, array<registration>) => array<rawVerdict> = "registerBatch"
-@send external makeSetRaw: (t, string, makeSetOptions) => AddressSet.t = "makeSet"
 @send
-external startBlockGroups: (t, string) => array<AddressSet.startBlockGroup> = "startBlockGroups"
+external registerBatchRaw: (t, array<registration>) => array<rawVerdict> = "registerBatch"
+@send external seedBatchRaw: (t, array<registration>) => array<rawVerdict> = "seedBatch"
+
+// Drains the registrations awaiting persistence at or below the given block —
+// what the batch being written covers — pairing each with the checkpoint at its
+// registration block. Later registrations stay pending. Throws, with the queue
+// untouched, when a drained registration's block has no checkpoint in the batch.
+@send
+external drainForWrite: (t, int, array<int>) => array<drainedAddress> = "drainForWrite"
+
+// How many registrations await persistence — lets a caller skip the work of
+// assembling what `drainForWrite` needs.
+@send external pendingCount: t => int = "pendingCount"
+
+// The registrations still awaiting persistence. For assertions.
+@send external pendingEntries: t => array<Internal.indexingContract> = "pendingEntries"
+@send external makeSetRaw: (t, string, makeSetOptions) => AddressSet.t = "makeSet"
 @send external contractCount: (t, string) => int = "contractCount"
 @send external size: t => int = "size"
 
@@ -132,12 +177,9 @@ external startBlockGroups: (t, string) => array<AddressSet.startBlockGroup> = "s
 
 @send external contractAddresses: (t, string) => array<Address.t> = "contractAddresses"
 
-@send external entries: t => array<Internal.indexingContract> = "entries"
-
 let toVerdict = (raw: rawVerdict): verdict =>
   switch raw.kind {
-  | "added" => Added({effectiveStartBlock: raw.effectiveStartBlock})
-  | "noEvents" => NoEvents({effectiveStartBlock: raw.effectiveStartBlock})
+  | "added" => Added({effectiveStartBlock: raw.effectiveStartBlock, fetchable: raw.fetchable})
   | "duplicate" =>
     Duplicate({
       effectiveStartBlock: raw.effectiveStartBlock,
@@ -148,13 +190,22 @@ let toVerdict = (raw: rawVerdict): verdict =>
   | kind => JsError.throwWithMessage(`Unexpected address registration verdict "${kind}"`)
   }
 
-// Registers a batch, resolving each address against both the store and the
-// batch's own earlier entries — so two contracts claiming one address inside a
-// single batch conflict just as they would across batches. Verdicts come back
-// in the batch's order.
+// Registers dynamic registrations, resolving each address against both the
+// store and the batch's own earlier entries — so two contracts claiming one
+// address inside a single batch conflict just as they would across batches.
+// Verdicts come back in the batch's order. What it adds is pending persistence
+// until a batch write drains it.
+//
+// An unknown contract name throws with none of the batch applied.
 let registerBatch = (store: t, registrations: array<registration>): array<verdict> =>
   store->registerBatchRaw(registrations)->Array.map(toVerdict)
 
+// `registerBatch` for addresses the database already holds — config addresses
+// and the dynamic ones a resume restores. Nothing is marked pending, so nothing
+// is ever written back.
+let seedBatch = (store: t, registrations: array<registration>): array<verdict> =>
+  store->seedBatchRaw(registrations)->Array.map(toVerdict)
+
 let makeSet = (store: t, ~contractName, ~options={}: makeSetOptions) =>
   store->makeSetRaw(contractName, options)
 

package/src/sources/AddressStore.res.mjs

@@ -17,14 +17,22 @@ function make(ecosystem, shouldChecksum, contracts) {
   }
 }
 
-function contractsOf(onEventRegistrations) {
+function contractsOf(onEventRegistrations, configContractNames) {
   let startBlocks = {};
   let unrestricted = new Set();
+  let addressDependent = new Set();
   let names = [];
-  onEventRegistrations.forEach(reg => {
-    let name = reg.eventConfig.contractName;
+  let addName = name => {
     if (!names.includes(name)) {
       names.push(name);
+      return;
+    }
+  };
+  onEventRegistrations.forEach(reg => {
+    let name = reg.eventConfig.contractName;
+    addName(name);
+    if (reg.dependsOnAddresses) {
+      addressDependent.add(name);
     }
     let startBlock = reg.startBlock;
     if (startBlock !== undefined) {
@@ -34,9 +42,11 @@ function contractsOf(onEventRegistrations) {
     }
     unrestricted.add(name);
   });
+  configContractNames.forEach(addName);
   return names.map(name => ({
     name: name,
-    startBlock: unrestricted.has(name) ? undefined : startBlocks[name]
+    startBlock: unrestricted.has(name) ? undefined : startBlocks[name],
+    dependsOnAddresses: addressDependent.has(name)
   }));
 }
 
@@ -46,7 +56,8 @@ function toVerdict(raw) {
     case "added" :
       return {
         TAG: "Added",
-        effectiveStartBlock: raw.effectiveStartBlock
+        effectiveStartBlock: raw.effectiveStartBlock,
+        fetchable: raw.fetchable
       };
     case "conflict" :
       return {
@@ -61,11 +72,6 @@ function toVerdict(raw) {
       };
     case "invalid" :
       return "Invalid";
-    case "noEvents" :
-      return {
-        TAG: "NoEvents",
-        effectiveStartBlock: raw.effectiveStartBlock
-      };
     default:
       return Stdlib_JsError.throwWithMessage(`Unexpected address registration verdict "` + kind + `"`);
   }
@@ -75,6 +81,10 @@ function registerBatch(store, registrations) {
   return store.registerBatch(registrations).map(toVerdict);
 }
 
+function seedBatch(store, registrations) {
+  return store.seedBatch(registrations).map(toVerdict);
+}
+
 function makeSet(store, contractName, optionsOpt) {
   let options = optionsOpt !== undefined ? optionsOpt : ({});
   return store.makeSet(contractName, options);
@@ -89,6 +99,7 @@ export {
   contractsOf,
   toVerdict,
   registerBatch,
+  seedBatch,
   makeSet,
   get,
 }