envio 3.5.0-alpha.1 → 3.5.0-alpha.3

package/index.d.ts

@@ -585,14 +585,18 @@ export type SvmOnSlotContext<Config extends IndexerConfigTypes = GlobalConfig> =
   BaseHandlerContext<Config, SvmChainIds<Config>>
 >;
 
+/** The entity's `id` type. `ID!`/`String!` ids are `string`; `Int!` is `number`
+ * and `BigInt!` is `bigint`, so id-keyed operations accept the real scalar. */
+type EntityId<Entity> = Entity extends { readonly id: infer Id } ? Id : string;
+
 /** Entity operations available in handler contexts. */
 type EntityOperations<Entity> = {
-  readonly get: (id: string) => Promise<Entity | undefined>;
-  readonly getOrThrow: (id: string, message?: string) => Promise<Entity>;
+  readonly get: (id: EntityId<Entity>) => Promise<Entity | undefined>;
+  readonly getOrThrow: (id: EntityId<Entity>, message?: string) => Promise<Entity>;
   readonly getWhere: (filter: GetWhereFilter<Entity>) => Promise<Entity[]>;
   readonly getOrCreate: (entity: Entity) => Promise<Entity>;
   readonly set: (entity: Entity) => void;
-  readonly deleteUnsafe: (id: string) => void;
+  readonly deleteUnsafe: (id: EntityId<Entity>) => void;
 };
 
 /** Contract registration handle. */
@@ -1510,7 +1514,7 @@ type EntityChangeValue<Entity> = {
   /** Entities that were created or updated. */
   readonly sets?: readonly Entity[];
   /** IDs of entities that were deleted. */
-  readonly deleted?: readonly string[];
+  readonly deleted?: readonly EntityId<Entity>[];
 };
 
 /** A dynamic contract address registration. */
@@ -1528,9 +1532,9 @@ type ConfigEntities<Config extends IndexerConfigTypes = GlobalConfig> =
 /** Entity operations available on test indexer for direct entity manipulation. */
 type TestIndexerEntityOperations<Entity> = {
   /** Get an entity by ID. Returns undefined if not found. */
-  readonly get: (id: string) => Promise<Entity | undefined>;
+  readonly get: (id: EntityId<Entity>) => Promise<Entity | undefined>;
   /** Get an entity by ID or throw if not found. */
-  readonly getOrThrow: (id: string, message?: string) => Promise<Entity>;
+  readonly getOrThrow: (id: EntityId<Entity>, message?: string) => Promise<Entity>;
   /** Get all entities. */
   readonly getAll: () => Promise<Entity[]>;
   /** Set (create or update) an entity. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.5.0-alpha.1",
+  "version": "3.5.0-alpha.3",
   "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-alpha.1",
-    "envio-linux-x64-musl": "3.5.0-alpha.1",
-    "envio-linux-arm64": "3.5.0-alpha.1",
-    "envio-darwin-x64": "3.5.0-alpha.1",
-    "envio-darwin-arm64": "3.5.0-alpha.1"
+    "envio-linux-x64": "3.5.0-alpha.3",
+    "envio-linux-x64-musl": "3.5.0-alpha.3",
+    "envio-linux-arm64": "3.5.0-alpha.3",
+    "envio-darwin-x64": "3.5.0-alpha.3",
+    "envio-darwin-arm64": "3.5.0-alpha.3"
   }
 }

package/src/BatchProcessing.res

@@ -45,6 +45,19 @@ let rec startProcessing = async (state: IndexerState.t, ~scheduleFetch, ~schedul
     // Hand off now that no batch is in flight.
     if state->IndexerState.isResolvingReorg {
       scheduleRollback()
+    } else if (
+      !(state->IndexerState.isStopped) &&
+      // Only a genuine fetch stall when some chain still has blocks to bring in.
+      // If every chain has buffered up to its known head, the loop is idling at
+      // the tip waiting for new blocks, not bottlenecked on fetch.
+      !(
+        state
+        ->IndexerState.chainStates
+        ->Dict.valuesToArray
+        ->Array.every(ChainState.isFetchingAtHead)
+      )
+    ) {
+      state->IndexerState.markProcessingStalledOnFetch
     }
   }
 }
@@ -91,6 +104,13 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
     // When resuming from persisted state, all events may already be processed.
     if EventProcessing.allChainsEventsProcessedToEndblock(state->IndexerState.chainStates) {
       Logging.info("All chains are caught up to end blocks.")
+      // A run that has nothing left to process still owes the schema its
+      // deferred indexes — otherwise a resume of a backfill that died right
+      // before finalizing would report ready without them.
+      state->IndexerState.markCaughtUp
+      if state->IndexerState.isFinalizingIndexes {
+        await FinalizeBackfill.run(state)
+      }
       if !(state->IndexerState.keepProcessAlive) {
         await ExitOnCaughtUp.run(state)
       }
@@ -143,6 +163,13 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
         state->IndexerState.clearRollback
         state->IndexerState.applyBatchProgress(~batch)
 
+        // Backfilling → FinalizingIndexes → Ready. Awaiting here holds the
+        // processing loop for the whole finalize, which is what pauses
+        // processing while the indexes are built.
+        if state->IndexerState.isFinalizingIndexes {
+          await FinalizeBackfill.run(state)
+        }
+
         if !isRealtimeBeforeUpdate && state->IndexerState.isRealtime {
           // Catching up just flipped the chain to realtime, which changes the
           // active source for waitForNewBlock (eg sync -> live). The waiter that

package/src/BatchProcessing.res.mjs

@@ -9,6 +9,7 @@ import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as ExitOnCaughtUp from "./ExitOnCaughtUp.res.mjs";
 import * as EventProcessing from "./EventProcessing.res.mjs";
+import * as FinalizeBackfill from "./FinalizeBackfill.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
@@ -38,6 +39,10 @@ async function processNextBatch(state, scheduleFetch) {
     }
     if (EventProcessing.allChainsEventsProcessedToEndblock(IndexerState.chainStates(state))) {
       Logging.info("All chains are caught up to end blocks.");
+      IndexerState.markCaughtUp(state);
+      if (IndexerState.isFinalizingIndexes(state)) {
+        await FinalizeBackfill.run(state);
+      }
       if (!IndexerState.keepProcessAlive(state)) {
         return await ExitOnCaughtUp.run(state);
       } else {
@@ -64,6 +69,9 @@ async function processNextBatch(state, scheduleFetch) {
   }
   IndexerState.clearRollback(state);
   IndexerState.applyBatchProgress(state, batch);
+  if (IndexerState.isFinalizingIndexes(state)) {
+    await FinalizeBackfill.run(state);
+  }
   if (!isRealtimeBeforeUpdate && IndexerState.isRealtime(state)) {
     IndexerState.invalidateInflight(state);
     scheduleFetch();
@@ -108,6 +116,10 @@ async function startProcessing(state, scheduleFetch, scheduleRollback) {
   IndexerState.endProcessing(state);
   if (IndexerState.isResolvingReorg(state)) {
     return scheduleRollback();
+  } else if (!IndexerState.isStopped(state) && !Object.values(IndexerState.chainStates(state)).every(ChainState.isFetchingAtHead)) {
+    return IndexerState.markProcessingStalledOnFetch(state);
+  } else {
+    return;
   }
 }
 

package/src/ChainFetching.res

@@ -209,11 +209,11 @@ let rec onQueryResponse = async (
       // kick (eg from the processing loop quiescing) collapses into this one.
       scheduleRollback()
     | None =>
-      // Drop over-fetched events (a merged partition returning an address before
-      // its effectiveStartBlock, or a wildcard param referencing an address
-      // registered after the log's block) before contract registration, so they
-      // neither spawn dynamic contracts nor enter the buffer.
-      let newItems = chainState->ChainState.filterByClientAddress(parsedQueueItems)
+      // Over-fetched events (a merged partition returning an address before its
+      // effectiveStartBlock, or a wildcard param referencing an address
+      // registered after the log's block) are already dropped by the source's
+      // native address gate, so everything here is indexable.
+      let newItems = parsedQueueItems
       let itemsWithContractRegister = []
       for idx in 0 to newItems->Array.length - 1 {
         let item = newItems->Array.getUnsafe(idx)

package/src/ChainFetching.res.mjs

@@ -145,17 +145,16 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
     IndexerState.beginReorg(state, chain, rollbackWithReorgDetectedBlockNumber);
     return scheduleRollback();
   }
-  let newItems = ChainState.filterByClientAddress(chainState, parsedQueueItems);
   let itemsWithContractRegister = [];
-  for (let idx = 0, idx_finish = newItems.length; idx < idx_finish; ++idx) {
-    let item = newItems[idx];
+  for (let idx = 0, idx_finish = parsedQueueItems.length; idx < idx_finish; ++idx) {
+    let item = parsedQueueItems[idx];
     if (item.onEventRegistration.contractRegister !== undefined) {
       itemsWithContractRegister.push(item);
     }
   }
   let proceed = newItemsWithDcs => {
     if (!IndexerState.isStale(state, stateId)) {
-      applyQueryResponse(state, chain, newItems, newItemsWithDcs, knownHeight, {
+      applyQueryResponse(state, chain, parsedQueueItems, newItemsWithDcs, knownHeight, {
         blockNumber: latestFetchedBlockNumber,
         blockTimestamp: latestFetchedBlockTimestamp
       }, query, transactionStore, blockStore);

package/src/ChainState.res

@@ -7,9 +7,10 @@ type t = {
   // The registrations used to build this chain's sources and route native items.
   onEventRegistrations: array<Internal.onEventRegistration>,
   mutable fetchState: FetchState.t,
-  // The chain-wide address index. Not `mutable`: the dict is mutated in place by
-  // register/rollback, so the reference is stable across fetchState versions.
-  indexingAddresses: IndexingAddresses.t,
+  // The chain-wide address index, kept in Rust. Not `mutable`: registration and
+  // rollback mutate it in place, so the handle is stable across fetchState
+  // versions — and it's the same handle this chain's source clients hold.
+  addressStore: AddressStore.t,
   sourceManager: SourceManager.t,
   chainConfig: Config.chain,
   mutable isProgressAtHead: bool,
@@ -83,7 +84,7 @@ let make = (
   ~chainConfig: Config.chain,
   ~fetchState: FetchState.t,
   ~onEventRegistrations=[],
-  ~indexingAddresses: IndexingAddresses.t,
+  ~addressStore: AddressStore.t,
   ~sourceManager: SourceManager.t,
   ~reorgDetection: ReorgDetection.t,
   ~committedProgressBlockNumber: int,
@@ -102,7 +103,7 @@ let make = (
     logger,
     onEventRegistrations,
     fetchState,
-    indexingAddresses,
+    addressStore,
     sourceManager,
     chainConfig,
     isProgressAtHead,
@@ -146,6 +147,7 @@ let makeInternal = (
   ~reorgCheckpoints: array<Internal.reorgCheckpoint>,
   ~maxReorgDepth,
   ~knownHeight=0,
+  ~isResumed=false,
   ~reducedPollingInterval=?,
 ): t => {
   // Handler binding + `where`-derived fetch state, and onBlock registrations,
@@ -166,12 +168,18 @@ let makeInternal = (
     }
   })
 
-  let contractConfigs = IndexingAddresses.makeContractConfigs(~onEventRegistrations)
-  let indexingAddressIndex = IndexingAddresses.make(~contractConfigs, ~addresses=indexingAddresses)
+  let lowercaseAddresses = config.lowercaseAddresses
+  // Created before the fetch state and the sources: `make` registers this
+  // chain's addresses into it, and every source client holds the same handle.
+  let addressStore = AddressStore.make(
+    ~ecosystem=config.ecosystem.name,
+    ~shouldChecksum=!lowercaseAddresses,
+    ~contracts=AddressStore.contractsOf(~onEventRegistrations),
+  )
 
   let fetchState = FetchState.make(
     ~maxAddrInPartition=config.maxAddrInPartition,
-    ~contractConfigs,
+    ~addressStore,
     ~addresses=indexingAddresses,
     ~progressBlockNumber,
     ~startBlock,
@@ -187,12 +195,16 @@ let makeInternal = (
     ),
     ~onBlockRegistrations,
     ~firstEventBlock,
-    // Only EVM sources (HyperSync + RPC) honor client-side address filtering so
-    // far, so switching contracts to it is gated to EVM chains.
+    // Fuel and SVM route through the address store like EVM does, so the
+    // client-side path works for them — but their address counts are nowhere
+    // near the threshold, so switching would only trade a server-side filter
+    // that costs nothing today for an over-fetch. Keep them server-side until a
+    // chain actually needs it.
     ~clientFilterAddressThreshold=switch config.ecosystem.name {
     | Evm => Some(config.clientFilterAddressThreshold)
     | Fuel | Svm => None
     },
+    ~isResumed,
   )
 
   let chainReorgCheckpoints = reorgCheckpoints->Array.filterMap(reorgCheckpoint => {
@@ -205,7 +217,6 @@ let makeInternal = (
 
   // Create sources lazily here - this is where API token validation happens
   let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
-  let lowercaseAddresses = config.lowercaseAddresses
   let sources = switch chainConfig.sourceConfig {
   | Config.EvmSourceConfig({hypersync, rpcs}) =>
     let evmRpcs: array<EvmChain.rpc> = rpcs->Array.map((rpc): EvmChain.rpc => {
@@ -228,6 +239,7 @@ let makeInternal = (
       ~hyperSync=hypersync,
       ~rpcs=evmRpcs,
       ~lowercaseAddresses,
+      ~addressStore,
     )
   | Config.FuelSourceConfig({hypersync}) => [
       FuelHyperSyncSource.make({
@@ -235,6 +247,7 @@ let makeInternal = (
         endpointUrl: hypersync,
         apiToken: Env.envioApiToken,
         onEventRegistrations,
+        addressStore,
       }),
     ]
   | Config.SvmSourceConfig({hypersync, rpc}) =>
@@ -255,6 +268,7 @@ let makeInternal = (
           apiToken,
           onEventRegistrations,
           clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
+          addressStore,
         }),
       ]
     }
@@ -274,7 +288,7 @@ let makeInternal = (
     ~chainConfig,
     ~fetchState,
     ~onEventRegistrations,
-    ~indexingAddresses=indexingAddressIndex,
+    ~addressStore,
     ~sourceManager=SourceManager.make(~sources, ~isRealtime, ~reducedPollingInterval?),
     ~reorgDetection=ReorgDetection.make(
       ~chainReorgCheckpoints,
@@ -371,6 +385,7 @@ let makeFromDbState = (
     ~isInReorgThreshold,
     ~isRealtime,
     ~knownHeight=resumedChainState.sourceBlockNumber,
+    ~isResumed=true,
     ~reducedPollingInterval?,
   )
 }
@@ -415,7 +430,7 @@ let setRollbackTargetBlock = (cs: t, ~blockNumber) => cs.rollbackTargetBlock = S
 // rather than reaching into it.
 let knownHeight = (cs: t) => cs.fetchState.knownHeight
 let contractAddresses = (cs: t, ~contractName) =>
-  cs.indexingAddresses->IndexingAddresses.getContractAddresses(~contractName)
+  cs.addressStore->AddressStore.contractAddresses(contractName)
 let bufferSize = (cs: t) => cs.fetchState->FetchState.bufferSize
 let bufferReadyCount = (cs: t) => cs.fetchState->FetchState.bufferReadyCount
 let getProgressPercentage = (cs: t) => cs.fetchState->FetchState.getProgressPercentage
@@ -706,6 +721,9 @@ let groupBatchItems = (items: array<Internal.item>, ~includeBlocks: bool): (
           }
         }
       }
+    // onBlock items build their block from the handler's own block number, not
+    // from the stores — which is what lets the sources keep only the blocks and
+    // transactions an event item references.
     | Internal.Block(_) => ()
     }
   )
@@ -802,15 +820,12 @@ let materializePageItems = async (
   ))
 }
 
-let filterByClientAddress = (cs: t, items: array<Internal.item>): array<Internal.item> =>
-  items->FetchState.filterByClientAddress(~indexingAddresses=cs.indexingAddresses)
-
 let handleQueryResult = (
   cs: t,
   ~query: FetchState.query,
   ~newItems,
   ~newItemsWithDcs,
-  ~latestFetchedBlock,
+  ~latestFetchedBlock: FetchState.blockNumberAndTimestamp,
   ~knownHeight,
   ~transactionStore as txPage: option<TransactionStore.t>,
   ~blockStore as blockPage: option<BlockStore.t>,
@@ -830,7 +845,12 @@ let handleQueryResult = (
   | [] => cs.fetchState
   | _ =>
     cs.fetchState->FetchState.registerDynamicContracts(
-      ~indexingAddresses=cs.indexingAddresses,
+      ~addressStore=cs.addressStore,
+      // This response is applied below, after the addresses land. It was routed
+      // before they existed, so whatever it claims has to be inside the
+      // 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,
     )
   }
@@ -906,7 +926,7 @@ let toMetrics = (cs: t): Metrics.chainMetrics => {
   numBatchesFetched: 0,
   startBlock: cs.fetchState.startBlock,
   endBlock: cs.fetchState.endBlock,
-  numAddresses: cs.indexingAddresses->IndexingAddresses.size,
+  numAddresses: cs.addressStore->AddressStore.size,
   isReady: cs->isReady,
   sourceBlockNumber: cs.fetchState.knownHeight,
   progressBlockNumber: cs.committedProgressBlockNumber,
@@ -1065,11 +1085,14 @@ let applyBatchProgress = (cs: t, ~batch: Batch.t, ~blockTimestampName: string) =
 }
 
 // Mark the chain caught up to head/endblock. Called by CrossChainState only once
-// every chain in the indexer is caught up, so no chain flips to ready while
-// another is still backfilling. Sticky: a chain stays ready once set.
-let markReady = (cs: t) =>
+// every chain in the indexer is caught up and the deferred schema indexes are
+// committed, so no chain flips to ready while another is still backfilling or
+// while an index the schema promises is still missing. `readyAt` is the
+// timestamp already committed to `envio_chains.ready_at` in that same
+// transaction. Sticky: a chain stays ready once set.
+let markReady = (cs: t, ~readyAt) =>
   if !(cs->isReady) {
-    cs.timestampCaughtUpToHeadOrEndblock = Date.make()->Some
+    cs.timestampCaughtUpToHeadOrEndblock = Some(readyAt)
   }
 
 // Roll a chain back to a reorg target. With a progress diff, restore fetch/
@@ -1111,7 +1134,7 @@ let rollback = (
     }
     cs.fetchState =
       cs.fetchState->FetchState.rollback(
-        ~indexingAddresses=cs.indexingAddresses,
+        ~addressStore=cs.addressStore,
         ~targetBlockNumber=newProgressBlockNumber,
       )
     cs.transactionStore->TransactionStore.rollback(newProgressBlockNumber)
@@ -1127,7 +1150,7 @@ let rollback = (
         )
       cs.fetchState =
         cs.fetchState->FetchState.rollback(
-          ~indexingAddresses=cs.indexingAddresses,
+          ~addressStore=cs.addressStore,
           ~targetBlockNumber=rollbackTargetBlockNumber,
         )
       cs.transactionStore->TransactionStore.rollback(rollbackTargetBlockNumber)

package/src/ChainState.res.mjs

@@ -11,6 +11,7 @@ import * as FieldMask from "./sources/FieldMask.res.mjs";
 import * as BlockStore from "./sources/BlockStore.res.mjs";
 import * as FetchState from "./FetchState.res.mjs";
 import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
+import * as AddressStore from "./sources/AddressStore.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SourceManager from "./sources/SourceManager.res.mjs";
@@ -20,7 +21,6 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as TransactionStore from "./sources/TransactionStore.res.mjs";
-import * as IndexingAddresses from "./IndexingAddresses.res.mjs";
 import * as SvmHyperSyncSource from "./sources/SvmHyperSyncSource.res.mjs";
 import * as FuelHyperSyncSource from "./sources/FuelHyperSyncSource.res.mjs";
 import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
@@ -47,7 +47,7 @@ function validateOnEventRegistrations(chainId, registrations) {
   });
 }
 
-function make(chainConfig, fetchState, onEventRegistrationsOpt, indexingAddresses, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionStoreOpt, chainDensityOpt, blockStoreOpt, reorgThresholdReadyToleranceOpt, logger) {
+function make(chainConfig, fetchState, onEventRegistrationsOpt, addressStore, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionStoreOpt, chainDensityOpt, blockStoreOpt, reorgThresholdReadyToleranceOpt, logger) {
   let onEventRegistrations = onEventRegistrationsOpt !== undefined ? onEventRegistrationsOpt : [];
   let safeCheckpointTracking = safeCheckpointTrackingOpt !== undefined ? Primitive_option.valFromOption(safeCheckpointTrackingOpt) : undefined;
   let numEventsProcessed = numEventsProcessedOpt !== undefined ? numEventsProcessedOpt : 0;
@@ -62,7 +62,7 @@ function make(chainConfig, fetchState, onEventRegistrationsOpt, indexingAddresse
     logger: logger,
     onEventRegistrations: onEventRegistrations,
     fetchState: fetchState,
-    indexingAddresses: indexingAddresses,
+    addressStore: addressStore,
     sourceManager: sourceManager,
     chainConfig: chainConfig,
     isProgressAtHead: isProgressAtHead,
@@ -89,9 +89,10 @@ function make(chainConfig, fetchState, onEventRegistrationsOpt, indexingAddresse
   };
 }
 
-function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBlockOpt, progressBlockNumber, config, registrationsByChainId, logger, timestampCaughtUpToHeadOrEndblock, numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, maxReorgDepth, knownHeightOpt, reducedPollingInterval) {
+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;
+  let isResumed = isResumedOpt !== undefined ? isResumedOpt : false;
   let match = Stdlib_Option.getOr(registrationsByChainId[chainConfig.id.toString()], {
     onEventRegistrations: [],
     onBlockRegistrations: []
@@ -103,8 +104,8 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
       return Stdlib_JsError.throwWithMessage(`The start block for contract "` + contract.name + `" is less than the chain start block. This is not supported yet.`);
     }
   });
-  let contractConfigs = IndexingAddresses.makeContractConfigs(onEventRegistrations);
-  let indexingAddressIndex = IndexingAddresses.make(contractConfigs, indexingAddresses);
+  let lowercaseAddresses = config.lowercaseAddresses;
+  let addressStore = AddressStore.make(config.ecosystem.name, !lowercaseAddresses, AddressStore.contractsOf(onEventRegistrations));
   let match$1 = config.ecosystem.name;
   let tmp;
   switch (match$1) {
@@ -116,14 +117,13 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
       tmp = undefined;
       break;
   }
-  let fetchState = FetchState.make(startBlock, endBlock, onEventRegistrations, contractConfigs, indexingAddresses, config.maxAddrInPartition, chainConfig.id, (config.batchSize << 1), knownHeight, progressBlockNumber, match.onBlockRegistrations, Primitive_int.max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth, chainConfig.blockLag), Primitive_option.some(firstEventBlock), Primitive_option.some(tmp));
+  let fetchState = FetchState.make(startBlock, endBlock, onEventRegistrations, addressStore, indexingAddresses, config.maxAddrInPartition, chainConfig.id, (config.batchSize << 1), knownHeight, progressBlockNumber, match.onBlockRegistrations, Primitive_int.max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth, chainConfig.blockLag), Primitive_option.some(firstEventBlock), Primitive_option.some(tmp), isResumed);
   let chainReorgCheckpoints = Stdlib_Array.filterMap(reorgCheckpoints, reorgCheckpoint => {
     if (reorgCheckpoint.chain_id === chainConfig.id) {
       return reorgCheckpoint;
     }
   });
   let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
-  let lowercaseAddresses = config.lowercaseAddresses;
   let sources = chainConfig.sourceConfig;
   let sources$1;
   switch (sources.TAG) {
@@ -140,14 +140,15 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
           headers: headers
         };
       });
-      sources$1 = EvmChain.makeSources(chain, onEventRegistrations, sources.hypersync, evmRpcs, lowercaseAddresses);
+      sources$1 = EvmChain.makeSources(chain, onEventRegistrations, sources.hypersync, evmRpcs, lowercaseAddresses, addressStore);
       break;
     case "FuelSourceConfig" :
       sources$1 = [FuelHyperSyncSource.make({
           chain: chain,
           endpointUrl: sources.hypersync,
           apiToken: Env.envioApiToken,
-          onEventRegistrations: onEventRegistrations
+          onEventRegistrations: onEventRegistrations,
+          addressStore: addressStore
         })];
       break;
     case "SvmSourceConfig" :
@@ -158,7 +159,8 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
             endpointUrl: hypersync,
             apiToken: Env.envioApiToken,
             onEventRegistrations: onEventRegistrations,
-            clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis
+            clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
+            addressStore: addressStore
           })] : (
           rpc !== undefined ? [Svm.makeRPCSource(chain, rpc, undefined)] : Stdlib_JsError.throwWithMessage(`Chain ` + chain.toString() + ` has no SVM data source`)
         );
@@ -169,14 +171,14 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
   }
   let firstEventBlock$1 = fetchState.firstEventBlock;
   let chainDensity = firstEventBlock$1 !== undefined && progressBlockNumber > firstEventBlock$1 && numEventsProcessed > 0 ? numEventsProcessed / (progressBlockNumber - firstEventBlock$1 | 0) : undefined;
-  return make(chainConfig, fetchState, onEventRegistrations, indexingAddressIndex, SourceManager.make(sources$1, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), ReorgDetection.make(chainReorgCheckpoints, maxReorgDepth, config.shouldRollbackOnReorg), progressBlockNumber, Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, Primitive_option.some(TransactionStore.make(config.ecosystem.name, !lowercaseAddresses)), Primitive_option.some(chainDensity), Primitive_option.some(BlockStore.make(config.ecosystem.name, !lowercaseAddresses)), config.reorgThresholdReadyTolerance, logger);
+  return make(chainConfig, fetchState, onEventRegistrations, addressStore, SourceManager.make(sources$1, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), ReorgDetection.make(chainReorgCheckpoints, maxReorgDepth, config.shouldRollbackOnReorg), progressBlockNumber, Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, Primitive_option.some(TransactionStore.make(config.ecosystem.name, !lowercaseAddresses)), Primitive_option.some(chainDensity), Primitive_option.some(BlockStore.make(config.ecosystem.name, !lowercaseAddresses)), config.reorgThresholdReadyTolerance, logger);
 }
 
 function makeFromConfig(chainConfig, config, registrationsByChainId, knownHeight) {
   let logger = Logging.createChild({
     chainId: chainConfig.id
   });
-  return makeInternal(chainConfig, configAddresses(chainConfig), chainConfig.startBlock, chainConfig.endBlock, undefined, -1, config, registrationsByChainId, logger, undefined, 0, false, false, [], chainConfig.maxReorgDepth, knownHeight, undefined);
+  return makeInternal(chainConfig, configAddresses(chainConfig), chainConfig.startBlock, chainConfig.endBlock, undefined, -1, config, registrationsByChainId, logger, undefined, 0, false, false, [], chainConfig.maxReorgDepth, knownHeight, undefined, undefined);
 }
 
 function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrationsByChainId, reducedPollingInterval) {
@@ -185,7 +187,7 @@ function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInR
     chainId: chainId
   });
   let progressBlockNumber = resumedChainState.progressBlockNumber >= 0 ? resumedChainState.progressBlockNumber : resumedChainState.startBlock - 1 | 0;
-  return makeInternal(chainConfig, resumedChainState.indexingAddresses, resumedChainState.startBlock, resumedChainState.endBlock, Primitive_option.some(resumedChainState.firstEventBlockNumber), progressBlockNumber, config, registrationsByChainId, logger, Env.updateSyncTimeOnRestart ? undefined : resumedChainState.timestampCaughtUpToHeadOrEndblock, resumedChainState.numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, resumedChainState.maxReorgDepth, resumedChainState.sourceBlockNumber, reducedPollingInterval);
+  return makeInternal(chainConfig, resumedChainState.indexingAddresses, resumedChainState.startBlock, resumedChainState.endBlock, Primitive_option.some(resumedChainState.firstEventBlockNumber), progressBlockNumber, config, registrationsByChainId, logger, Env.updateSyncTimeOnRestart ? undefined : resumedChainState.timestampCaughtUpToHeadOrEndblock, resumedChainState.numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, resumedChainState.maxReorgDepth, resumedChainState.sourceBlockNumber, true, reducedPollingInterval);
 }
 
 function logger(cs) {
@@ -250,7 +252,7 @@ function knownHeight(cs) {
 }
 
 function contractAddresses(cs, contractName) {
-  return IndexingAddresses.getContractAddresses(cs.indexingAddresses, contractName);
+  return cs.addressStore.contractAddresses(contractName);
 }
 
 function bufferSize(cs) {
@@ -541,10 +543,6 @@ async function materializePageItems(items, transactionStore, blockStore, ecosyst
   ]);
 }
 
-function filterByClientAddress(cs, items) {
-  return FetchState.filterByClientAddress(items, cs.indexingAddresses);
-}
-
 function handleQueryResult(cs, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight, txPage, blockPage) {
   if (txPage !== undefined) {
     cs.transactionStore.merge(Primitive_option.valFromOption(txPage));
@@ -552,7 +550,7 @@ function handleQueryResult(cs, query, newItems, newItemsWithDcs, latestFetchedBl
   if (blockPage !== undefined) {
     cs.blockStore.merge(Primitive_option.valFromOption(blockPage));
   }
-  let fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, cs.indexingAddresses, newItemsWithDcs) : cs.fetchState;
+  let fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, cs.addressStore, Primitive_int.max(knownHeight, latestFetchedBlock.blockNumber), newItemsWithDcs) : cs.fetchState;
   cs.fetchState = FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight);
   cs.pendingBudget = Primitive_float.max(0, cs.pendingBudget - query.itemsEst);
 }
@@ -587,7 +585,6 @@ function setEndBlockToFirstEvent(cs, blockNumber) {
       startBlock: init.startBlock,
       endBlock: blockNumber,
       normalSelection: init.normalSelection,
-      contractConfigs: init.contractConfigs,
       chainId: init.chainId,
       latestOnBlockBlockNumber: init.latestOnBlockBlockNumber,
       blockLag: init.blockLag,
@@ -606,7 +603,6 @@ function setEndBlockToFirstEvent(cs, blockNumber) {
     startBlock: init$1.startBlock,
     endBlock: blockNumber,
     normalSelection: init$1.normalSelection,
-    contractConfigs: init$1.contractConfigs,
     chainId: init$1.chainId,
     latestOnBlockBlockNumber: init$1.latestOnBlockBlockNumber,
     blockLag: init$1.blockLag,
@@ -645,7 +641,7 @@ function toMetrics(cs) {
     numBatchesFetched: 0,
     startBlock: cs.fetchState.startBlock,
     endBlock: cs.fetchState.endBlock,
-    numAddresses: IndexingAddresses.size(cs.indexingAddresses),
+    numAddresses: cs.addressStore.size(),
     isReady: cs.timestampCaughtUpToHeadOrEndblock !== undefined,
     sourceBlockNumber: cs.fetchState.knownHeight,
     progressBlockNumber: cs.committedProgressBlockNumber,
@@ -715,7 +711,6 @@ function applyBatchProgress(cs, batch, blockTimestampName) {
         startBlock: init.startBlock,
         endBlock: init.endBlock,
         normalSelection: init.normalSelection,
-        contractConfigs: init.contractConfigs,
         chainId: init.chainId,
         latestOnBlockBlockNumber: init.latestOnBlockBlockNumber,
         blockLag: init.blockLag,
@@ -763,9 +758,9 @@ function applyBatchProgress(cs, batch, blockTimestampName) {
   }
 }
 
-function markReady(cs) {
+function markReady(cs, readyAt) {
   if (cs.timestampCaughtUpToHeadOrEndblock === undefined) {
-    cs.timestampCaughtUpToHeadOrEndblock = new Date();
+    cs.timestampCaughtUpToHeadOrEndblock = readyAt;
     return;
   }
 }
@@ -774,7 +769,7 @@ function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTarge
   if (newProgressBlockNumber === undefined) {
     if (isReorgChain) {
       cs.reorgDetection = ReorgDetection.rollbackToValidBlockNumber(cs.reorgDetection, rollbackTargetBlockNumber);
-      cs.fetchState = FetchState.rollback(cs.fetchState, cs.indexingAddresses, rollbackTargetBlockNumber);
+      cs.fetchState = FetchState.rollback(cs.fetchState, cs.addressStore, rollbackTargetBlockNumber);
       cs.transactionStore.rollback(rollbackTargetBlockNumber);
       cs.blockStore.rollback(rollbackTargetBlockNumber);
       cs.committedProgressBlockNumber = Primitive_int.min(cs.committedProgressBlockNumber, rollbackTargetBlockNumber);
@@ -792,7 +787,7 @@ function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTarge
   if (safeCheckpointTracking !== undefined) {
     cs.safeCheckpointTracking = SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber);
   }
-  cs.fetchState = FetchState.rollback(cs.fetchState, cs.indexingAddresses, newProgressBlockNumber);
+  cs.fetchState = FetchState.rollback(cs.fetchState, cs.addressStore, newProgressBlockNumber);
   cs.transactionStore.rollback(newProgressBlockNumber);
   cs.blockStore.rollback(newProgressBlockNumber);
   cs.committedProgressBlockNumber = newProgressBlockNumber;
@@ -842,7 +837,6 @@ export {
   isReady,
   isFetchingAtHead,
   isAtHeadWithoutEndBlock,
-  filterByClientAddress,
   handleQueryResult,
   materializeBatchItems,
   materializePageItems,