envio 3.3.0-alpha.6 → 3.3.0-alpha.8

package/src/Metrics.res.mjs

@@ -4,6 +4,7 @@ import * as Utils from "./Utils.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as PromClient from "prom-client";
 import * as IndexerState from "./IndexerState.res.mjs";
+import * as SourceManager from "./sources/SourceManager.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
 let indexingAddressesName = "envio_indexing_addresses";
@@ -21,19 +22,54 @@ function renderGauge(name, help, chains, value) {
   return out.contents;
 }
 
+let sourceRequestTotalName = "envio_source_request_total";
+
+let sourceRequestTotalHelp = "The number of requests made to data sources.";
+
+let sourceRequestSecondsTotalName = "envio_source_request_seconds_total";
+
+let sourceRequestSecondsTotalHelp = "Cumulative time spent on data source requests.";
+
+function renderSourceRequests(samples) {
+  if (Utils.$$Array.isEmpty(samples)) {
+    return "";
+  }
+  let countOut = {
+    contents: `\n# HELP ` + sourceRequestTotalName + ` ` + sourceRequestTotalHelp + `\n# TYPE ` + sourceRequestTotalName + ` counter`
+  };
+  let secondsOut = {
+    contents: `\n# HELP ` + sourceRequestSecondsTotalName + ` ` + sourceRequestSecondsTotalHelp + `\n# TYPE ` + sourceRequestSecondsTotalName + ` counter`
+  };
+  samples.forEach(sample => {
+    let labels = `{source="` + sample.sourceName + `",chainId="` + sample.chainId.toString() + `",method="` + sample.method + `"}`;
+    countOut.contents = countOut.contents + (`\n` + sourceRequestTotalName + labels + ` ` + sample.count.toString());
+    if (sample.seconds !== 0) {
+      secondsOut.contents = secondsOut.contents + (`\n` + sourceRequestSecondsTotalName + labels + ` ` + sample.seconds.toString());
+      return;
+    }
+  });
+  return countOut.contents + secondsOut.contents;
+}
+
 async function collect(state) {
   let base = await PromClient.register.metrics();
-  if (state !== undefined) {
-    return base + renderGauge(indexingAddressesName, indexingAddressesHelp, IndexerState.chainStates(Primitive_option.valFromOption(state)), cs => ChainState.toChainData(cs).numAddresses) + `\n`;
-  } else {
+  if (state === undefined) {
     return base;
   }
+  let chainStates = IndexerState.chainStates(Primitive_option.valFromOption(state));
+  let sourceRequestSamples = Object.values(chainStates).flatMap(cs => SourceManager.getRequestStatSamples(ChainState.sourceManager(cs)));
+  return base + renderGauge(indexingAddressesName, indexingAddressesHelp, chainStates, cs => ChainState.toChainData(cs).numAddresses) + renderSourceRequests(sourceRequestSamples) + `\n`;
 }
 
 export {
   indexingAddressesName,
   indexingAddressesHelp,
   renderGauge,
+  sourceRequestTotalName,
+  sourceRequestTotalHelp,
+  sourceRequestSecondsTotalName,
+  sourceRequestSecondsTotalHelp,
+  renderSourceRequests,
   collect,
 }
 /* Utils Not a pure module */

package/src/Prometheus.res

@@ -438,41 +438,6 @@ let sourceLabelsSchema = S.schema(s =>
   }
 )
 
-let sourceRequestLabelsSchema = S.schema(s =>
-  {
-    "source": s.matches(S.string),
-    "chainId": s.matches(S.string->S.coerce(S.int)),
-    "method": s.matches(S.string),
-  }
-)
-
-module SourceRequestCount = {
-  let counter = SafeCounter.makeOrThrow(
-    ~name="envio_source_request_total",
-    ~help="The number of requests made to data sources.",
-    ~labelSchema=sourceRequestLabelsSchema,
-  )
-
-  let sumTimeCounter = SafeCounter.makeOrThrow(
-    ~name="envio_source_request_seconds_total",
-    ~help="Cumulative time spent on data source requests.",
-    ~labelSchema=sourceRequestLabelsSchema,
-  )
-
-  let increment = (~sourceName, ~chainId, ~method) => {
-    counter->SafeCounter.increment(
-      ~labels={"source": sourceName, "chainId": chainId, "method": method},
-    )
-  }
-
-  let addSeconds = (~sourceName, ~chainId, ~method, ~seconds) => {
-    sumTimeCounter->SafeCounter.handleFloat(
-      ~labels={"source": sourceName, "chainId": chainId, "method": method},
-      ~value=seconds,
-    )
-  }
-}
-
 module SourceHeight = {
   let gauge = SafeGauge.makeOrThrow(
     ~name="envio_source_known_height",

package/src/Prometheus.res.mjs

@@ -481,39 +481,6 @@ let sourceLabelsSchema = S$RescriptSchema.schema(s => ({
   chainId: s.m(S$RescriptSchema.coerce(S$RescriptSchema.string, S$RescriptSchema.int))
 }));
 
-let sourceRequestLabelsSchema = S$RescriptSchema.schema(s => ({
-  source: s.m(S$RescriptSchema.string),
-  chainId: s.m(S$RescriptSchema.coerce(S$RescriptSchema.string, S$RescriptSchema.int)),
-  method: s.m(S$RescriptSchema.string)
-}));
-
-let counter$3 = makeOrThrow("envio_source_request_total", "The number of requests made to data sources.", sourceRequestLabelsSchema);
-
-let sumTimeCounter$1 = makeOrThrow("envio_source_request_seconds_total", "Cumulative time spent on data source requests.", sourceRequestLabelsSchema);
-
-function increment$4(sourceName, chainId, method) {
-  increment(counter$3, {
-    source: sourceName,
-    chainId: chainId,
-    method: method
-  });
-}
-
-function addSeconds(sourceName, chainId, method, seconds) {
-  handleFloat(sumTimeCounter$1, {
-    source: sourceName,
-    chainId: chainId,
-    method: method
-  }, seconds);
-}
-
-let SourceRequestCount = {
-  counter: counter$3,
-  sumTimeCounter: sumTimeCounter$1,
-  increment: increment$4,
-  addSeconds: addSeconds
-};
-
 let gauge$10 = makeOrThrow$1("envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", sourceLabelsSchema);
 
 function set$10(sourceName, chainId, blockNumber) {
@@ -528,15 +495,15 @@ let SourceHeight = {
   set: set$10
 };
 
-let counter$4 = makeOrThrow("envio_reorg_detected_total", "Total number of reorgs detected", chainIdLabelsSchema);
+let counter$3 = makeOrThrow("envio_reorg_detected_total", "Total number of reorgs detected", chainIdLabelsSchema);
 
-function increment$5(chain) {
-  increment(counter$4, chain);
+function increment$4(chain) {
+  increment(counter$3, chain);
 }
 
 let ReorgCount = {
-  counter: counter$4,
-  increment: increment$5
+  counter: counter$3,
+  increment: increment$4
 };
 
 let gauge$11 = makeOrThrow$1("envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", chainIdLabelsSchema);
@@ -583,7 +550,7 @@ let timeCounter$3 = PromClient.Counter.makeCounter({
   help: "Rollback on reorg total time."
 });
 
-let counter$5 = PromClient.Counter.makeCounter({
+let counter$4 = PromClient.Counter.makeCounter({
   name: "envio_rollback_total",
   help: "Number of successful rollbacks on reorg"
 });
@@ -593,35 +560,35 @@ let eventsCounter = PromClient.Counter.makeCounter({
   help: "Number of events rollbacked on reorg"
 });
 
-function increment$6(timeSeconds, rollbackedProcessedEvents) {
+function increment$5(timeSeconds, rollbackedProcessedEvents) {
   timeCounter$3.inc(timeSeconds);
-  counter$5.inc();
+  counter$4.inc();
   eventsCounter.inc(Math.trunc(rollbackedProcessedEvents));
 }
 
 let RollbackSuccess = {
   timeCounter: timeCounter$3,
-  counter: counter$5,
+  counter: counter$4,
   eventsCounter: eventsCounter,
-  increment: increment$6
+  increment: increment$5
 };
 
 let entityNameLabelsSchema = S$RescriptSchema.object(s => s.f("entity", S$RescriptSchema.string));
 
 let timeCounter$4 = makeOrThrow("envio_rollback_history_prune_seconds", "The total time spent pruning entity history which is not in the reorg threshold.", entityNameLabelsSchema);
 
-let counter$6 = makeOrThrow("envio_rollback_history_prune_total", "Number of successful entity history prunes", entityNameLabelsSchema);
+let counter$5 = makeOrThrow("envio_rollback_history_prune_total", "Number of successful entity history prunes", entityNameLabelsSchema);
 
-function increment$7(timeSeconds, entityName) {
+function increment$6(timeSeconds, entityName) {
   handleFloat(timeCounter$4, entityName, timeSeconds);
-  increment(counter$6, entityName);
+  increment(counter$5, entityName);
 }
 
 let RollbackHistoryPrune = {
   entityNameLabelsSchema: entityNameLabelsSchema,
   timeCounter: timeCounter$4,
-  counter: counter$6,
-  increment: increment$7
+  counter: counter$5,
+  increment: increment$6
 };
 
 let gauge$14 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
@@ -686,7 +653,7 @@ let effectLabelsSchema = S$RescriptSchema.object(s => s.f("effect", S$RescriptSc
 
 let timeCounter$5 = makeOrThrow("envio_effect_call_seconds", "Processing time taken to call the Effect function.", effectLabelsSchema);
 
-let sumTimeCounter$2 = makeOrThrow("envio_effect_call_seconds_total", "Cumulative time spent calling the Effect function during the indexing process.", effectLabelsSchema);
+let sumTimeCounter$1 = makeOrThrow("envio_effect_call_seconds_total", "Cumulative time spent calling the Effect function during the indexing process.", effectLabelsSchema);
 
 let totalCallsCount = makeOrThrow("envio_effect_call_total", "Cumulative number of resolved Effect function calls during the indexing process.", effectLabelsSchema);
 
@@ -694,7 +661,7 @@ let activeCallsCount = makeOrThrow$1("envio_effect_active_calls", "The number of
 
 let EffectCalls = {
   timeCounter: timeCounter$5,
-  sumTimeCounter: sumTimeCounter$2,
+  sumTimeCounter: sumTimeCounter$1,
   totalCallsCount: totalCallsCount,
   activeCallsCount: activeCallsCount
 };
@@ -710,15 +677,15 @@ let EffectCacheCount = {
   set: set$19
 };
 
-let counter$7 = makeOrThrow("envio_effect_cache_invalidations", "The number of effect cache invalidations.", effectLabelsSchema);
+let counter$6 = makeOrThrow("envio_effect_cache_invalidations", "The number of effect cache invalidations.", effectLabelsSchema);
 
-function increment$8(effectName) {
-  increment(counter$7, effectName);
+function increment$7(effectName) {
+  increment(counter$6, effectName);
 }
 
 let EffectCacheInvalidationsCount = {
-  counter: counter$7,
-  increment: increment$8
+  counter: counter$6,
+  increment: increment$7
 };
 
 let gauge$20 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
@@ -742,9 +709,9 @@ let loadLabelsSchema = S$RescriptSchema.schema(s => ({
 
 let timeCounter$7 = makeOrThrow("envio_storage_load_seconds", "Processing time taken to load data from storage.", loadLabelsSchema);
 
-let sumTimeCounter$3 = makeOrThrow("envio_storage_load_seconds_total", "Cumulative time spent loading data from storage during the indexing process.", loadLabelsSchema);
+let sumTimeCounter$2 = makeOrThrow("envio_storage_load_seconds_total", "Cumulative time spent loading data from storage during the indexing process.", loadLabelsSchema);
 
-let counter$8 = makeOrThrow("envio_storage_load_total", "Cumulative number of successful storage load operations during the indexing process.", loadLabelsSchema);
+let counter$7 = makeOrThrow("envio_storage_load_total", "Cumulative number of successful storage load operations during the indexing process.", loadLabelsSchema);
 
 let whereSizeCounter = makeOrThrow("envio_storage_load_where_size", "Cumulative number of filter conditions ('where' items) used in storage load operations during the indexing process.", loadLabelsSchema);
 
@@ -782,8 +749,8 @@ function endOperation$1(timerRef, storage, operation, whereSize, size) {
     handleFloat(timeCounter$7, labels, Performance.secondsSince(operationRef.timerRef));
     Utils.Dict.deleteInPlace(operations$1, key);
   }
-  handleFloat(sumTimeCounter$3, labels, Performance.secondsSince(timerRef));
-  increment(counter$8, labels);
+  handleFloat(sumTimeCounter$2, labels, Performance.secondsSince(timerRef));
+  increment(counter$7, labels);
   handleInt(whereSizeCounter, labels, whereSize);
   handleInt(sizeCounter$1, labels, size);
 }
@@ -791,8 +758,8 @@ function endOperation$1(timerRef, storage, operation, whereSize, size) {
 let StorageLoad = {
   loadLabelsSchema: loadLabelsSchema,
   timeCounter: timeCounter$7,
-  sumTimeCounter: sumTimeCounter$3,
-  counter: counter$8,
+  sumTimeCounter: sumTimeCounter$2,
+  counter: counter$7,
   whereSizeCounter: whereSizeCounter,
   sizeCounter: sizeCounter$1,
   operations: operations$1,
@@ -805,18 +772,18 @@ let storageLabelsSchema = S$RescriptSchema.object(s => s.f("storage", S$Rescript
 
 let timeCounter$8 = makeOrThrow("envio_storage_write_seconds", "Cumulative time spent writing batch data to storage.", storageLabelsSchema);
 
-let counter$9 = makeOrThrow("envio_storage_write_total", "Cumulative number of successful storage write operations during the indexing process.", storageLabelsSchema);
+let counter$8 = makeOrThrow("envio_storage_write_total", "Cumulative number of successful storage write operations during the indexing process.", storageLabelsSchema);
 
-function increment$9(storage, timeSeconds) {
+function increment$8(storage, timeSeconds) {
   handleFloat(timeCounter$8, storage, timeSeconds);
-  increment(counter$9, storage);
+  increment(counter$8, storage);
 }
 
 let StorageWrite = {
   storageLabelsSchema: storageLabelsSchema,
   timeCounter: timeCounter$8,
-  counter: counter$9,
-  increment: increment$9
+  counter: counter$8,
+  increment: increment$8
 };
 
 export {
@@ -845,8 +812,6 @@ export {
   IndexingBufferBlockNumber,
   IndexingEndBlock,
   sourceLabelsSchema,
-  sourceRequestLabelsSchema,
-  SourceRequestCount,
   SourceHeight,
   ReorgCount,
   ReorgDetectionBlockNumber,

package/src/RawEvent.res

@@ -19,16 +19,21 @@ let convertFieldsToJson = (fields: option<dict<unknown>>) => {
 
 // Block and transaction are passed already extracted from the ecosystem's
 // concrete payload (EVM or Fuel) — `RawEvent` stays payload-shape-agnostic and
-// only needs them as opaque field bags to serialise.
+// only needs them as opaque field bags to serialise. The dedicated
+// `block_hash`/`block_timestamp` column values are extracted from the payload
+// block by the ecosystem caller (the field names differ per ecosystem).
 let make = (
   eventItem: Internal.eventItem,
   ~block,
   ~transaction,
   ~params: Internal.eventParams,
   ~srcAddress: Address.t,
+  ~blockHash: string,
+  ~blockTimestamp: int,
   ~cleanUpRawEventFieldsInPlace: JSON.t => unit,
 ): Internal.rawEvent => {
-  let {eventConfig, chain, blockNumber, blockHash, timestamp: blockTimestamp, logIndex} = eventItem
+  let {onEventRegistration, chain, blockNumber, logIndex} = eventItem
+  let eventConfig = onEventRegistration.eventConfig
   let chainId = chain->ChainMap.Chain.toChainId
   let eventId = EventUtils.packEventIndex(~logIndex, ~blockNumber)
   let blockFields =

package/src/RawEvent.res.mjs

@@ -18,10 +18,10 @@ function convertFieldsToJson(fields) {
   }
 }
 
-function make(eventItem, block, transaction, params, srcAddress, cleanUpRawEventFieldsInPlace) {
+function make(eventItem, block, transaction, params, srcAddress, blockHash, blockTimestamp, cleanUpRawEventFieldsInPlace) {
   let logIndex = eventItem.logIndex;
   let blockNumber = eventItem.blockNumber;
-  let eventConfig = eventItem.eventConfig;
+  let eventConfig = eventItem.onEventRegistration.eventConfig;
   let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
   let blockFields = convertFieldsToJson(block);
   let transactionFields = convertFieldsToJson(transaction);
@@ -36,8 +36,8 @@ function make(eventItem, block, transaction, params, srcAddress, cleanUpRawEvent
     block_number: blockNumber,
     log_index: logIndex,
     src_address: srcAddress,
-    block_hash: eventItem.blockHash,
-    block_timestamp: eventItem.timestamp,
+    block_hash: blockHash,
+    block_timestamp: blockTimestamp,
     block_fields: blockFields,
     transaction_fields: transactionFields,
     params: params$2

package/src/SimulateItems.res

@@ -216,11 +216,20 @@ let deriveSrcAddress = (
   ~providedSrcAddress: option<Address.t>,
   ~eventConfig: Internal.eventConfig,
   ~chainConfig: Config.chain,
+  ~config: Config.t,
 ): Address.t => {
   switch providedSrcAddress {
-  | Some(addr) => addr
+  // Canonicalize to the configured casing; the fallback addresses below already
+  // come from the parsed config and need no normalization. Relaxed (not
+  // Config.normalizeUserAddress) so test placeholders like "0xfoo" are allowed.
+  | Some(addr) => config->Config.normalizeSimulateAddress(addr)
   | None =>
-    if eventConfig.isWildcard {
+    if (
+      HandlerRegister.isWildcard(
+        ~contractName=eventConfig.contractName,
+        ~eventName=eventConfig.name,
+      )
+    ) {
       dummySrcAddress
     } else {
       switch firstContractAddress(~chainConfig, ~contractName=eventConfig.contractName) {
@@ -287,6 +296,7 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
         ~providedSrcAddress=item.srcAddress,
         ~eventConfig,
         ~chainConfig,
+        ~config,
       )
 
       let rawItem = rawJson->(Utils.magic: JSON.t => {..})
@@ -294,15 +304,15 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
         rawItem["block"]->(Utils.magic: 'a => Nullable.t<JSON.t>)->Nullable.toOption
       let transactionJson: option<JSON.t> =
         rawItem["transaction"]->(Utils.magic: 'a => Nullable.t<JSON.t>)->Nullable.toOption
-      let (block, blockNumber, timestamp, blockHash) = switch config.ecosystem.name {
+      let (block, blockNumber) = switch config.ecosystem.name {
       | Fuel =>
         let block = parseFuelSimulateBlock(~defaultBlockNumber=currentBlock.contents, ~blockJson)
         let blockFields = block->(Utils.magic: Internal.eventBlock => fuelSimulateBlock)
-        (block, blockFields.height, blockFields.time, blockFields.id)
+        (block, blockFields.height)
       | Evm =>
         let block = parseEvmSimulateBlock(~defaultBlockNumber=currentBlock.contents, ~blockJson)
         let blockFields = block->(Utils.magic: Internal.eventBlock => evmSimulateBlock)
-        (block, blockFields.number, blockFields.timestamp, blockFields.hash)
+        (block, blockFields.number)
       | Svm => JsError.throwWithMessage("simulate is not supported for SVM ecosystem")
       }
       let transaction = switch config.ecosystem.name {
@@ -326,14 +336,22 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
       | None => seenCoordinates->Dict.set(coordinate, itemIndex)
       }
 
+      // Build a real registration the same way `HandlerRegister.buildOnEventRegistrations`
+      // does at startup (not a stub), so the address filter and `where`
+      // behave identically to real indexing — the dead-input tracker relies
+      // on `clientAddressFilter` actually gating unrouted items.
+      let onEventRegistration = HandlerRegister.buildOnEventRegistration(
+        ~config,
+        ~chainId,
+        ~eventConfig,
+      )
+
       items
       ->Array.push(
         Internal.Event({
-          eventConfig,
-          timestamp,
+          onEventRegistration,
           chain,
           blockNumber,
-          blockHash,
           logIndex,
           // Simulate keeps the transaction inline on the payload, so the store
           // key is unused.

package/src/SimulateItems.res.mjs

@@ -1,10 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Config from "./Config.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as SimulateSource from "./sources/SimulateSource.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
@@ -150,11 +152,11 @@ function firstContractAddress(chainConfig, contractName) {
   return found.contents;
 }
 
-function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig) {
+function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig, config) {
   if (providedSrcAddress !== undefined) {
-    return Primitive_option.valFromOption(providedSrcAddress);
+    return Config.normalizeSimulateAddress(config, Primitive_option.valFromOption(providedSrcAddress));
   }
-  if (eventConfig.isWildcard) {
+  if (HandlerRegister.isWildcard(eventConfig.contractName, eventConfig.name)) {
     return dummySrcAddress;
   }
   let addr = firstContractAddress(chainConfig, eventConfig.contractName);
@@ -203,7 +205,7 @@ function parse(simulateItems, config, chainConfig) {
       currentLogIndex.contents = li$1 + 1 | 0;
       logIndex = li$1;
     }
-    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig);
+    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig, config);
     let blockJson = rawJson.block;
     let blockJson$1 = (blockJson == null) ? undefined : Primitive_option.some(blockJson);
     let transactionJson = rawJson.transaction;
@@ -215,18 +217,14 @@ function parse(simulateItems, config, chainConfig) {
         let block = parseEvmSimulateBlock(currentBlock.contents, blockJson$1);
         match$3 = [
           block,
-          block.number,
-          block.timestamp,
-          block.hash
+          block.number
         ];
         break;
       case "fuel" :
         let block$1 = parseFuelSimulateBlock(currentBlock.contents, blockJson$1);
         match$3 = [
           block$1,
-          block$1.height,
-          block$1.time,
-          block$1.id
+          block$1.height
         ];
         break;
       case "svm" :
@@ -255,13 +253,12 @@ function parse(simulateItems, config, chainConfig) {
     } else {
       seenCoordinates[coordinate] = itemIndex;
     }
+    let onEventRegistration = HandlerRegister.buildOnEventRegistration(config, chainId, eventConfig, undefined);
     items.push({
       kind: 0,
-      eventConfig: eventConfig,
-      timestamp: match$3[2],
+      onEventRegistration: onEventRegistration,
       chain: chain,
       blockNumber: blockNumber,
-      blockHash: match$3[3],
       logIndex: logIndex,
       transactionIndex: 0,
       payload: {
@@ -272,7 +269,7 @@ function parse(simulateItems, config, chainConfig) {
         srcAddress: srcAddress,
         logIndex: logIndex,
         transaction: Primitive_option.some(transaction),
-        block: match$3[0]
+        block: Primitive_option.some(match$3[0])
       }
     });
   });

package/src/TestIndexer.res

@@ -850,7 +850,7 @@ let initTestWorker = () => {
     // Create proxy storage that communicates with main thread
     let proxy = TestIndexerProxyStorage.make(~parentPort, ~initialState)
     let storage = TestIndexerProxyStorage.makeStorage(proxy)
-    let config = Config.loadWithoutRegistrations()
+    let config = Config.load()
     let persistence = Persistence.make(
       ~userEntities=config.userEntities,
       ~allEnums=config.allEnums,

package/src/TestIndexer.res.mjs

@@ -605,7 +605,7 @@ function initTestWorker() {
   };
   let proxy = TestIndexerProxyStorage.make(parentPort, workerData.initialState);
   let storage = TestIndexerProxyStorage.makeStorage(proxy);
-  let config = Config.loadWithoutRegistrations();
+  let config = Config.load();
   let persistence = Persistence.make(config.userEntities, config.allEnums, storage);
   if (Env.userLogLevel !== undefined) {
     

package/src/sources/BlockStore.res

@@ -0,0 +1,46 @@
+// Binding to the Rust `BlockStore` napi class. Blocks are kept in Rust as raw
+// structs (their large fields never enter JS until read) keyed by block number.
+// One store lives per chain on `ChainState`; each fetch response contributes a
+// page that is merged in. At batch preparation the selected fields are
+// materialised in bulk, off the JS thread, in columnar form and zipped into
+// plain JS objects on the main thread.
+type t
+
+@send external newEvm: (Core.blockStoreCtor, ~shouldChecksum: bool) => t = "newEvm"
+@send external newSvm: Core.blockStoreCtor => t = "newSvm"
+@send external newFuel: Core.blockStoreCtor => t = "newFuel"
+
+// The store's ecosystem is fixed here, from the chain's config. EVM carries the
+// chain's address-checksumming setting; SVM/Fuel need no extra data.
+let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool): t => {
+  let ctor = Core.getAddon().blockStore
+  switch ecosystem {
+  | Evm => ctor->newEvm(~shouldChecksum)
+  | Svm => ctor->newSvm
+  | Fuel => ctor->newFuel
+  }
+}
+
+// One event's selected block fields → store selection bitmask, built from the
+// ecosystem's ordered field-name array (the bit index is the field code shared
+// with the Rust store, `EvmBlockField`).
+let makeMaskFn = FieldMask.makeMaskFn
+
+// Drain another store (a fetch-response page) into this one.
+@send external merge: (t, t) => unit = "merge"
+
+// Bulk-materialise blocks off the JS thread, one row per `blockNumbers[i]` key,
+// decoding only the fields set in that row's own `masks[i]`. Result is aligned
+// with the input.
+@send
+external materialize: (
+  t,
+  ~blockNumbers: array<int>,
+  ~masks: array<float>,
+) => promise<array<Internal.eventBlock>> = "materialize"
+
+// Drop blocks at or below the given block (already processed).
+@send external prune: (t, int) => unit = "prune"
+
+// Drop blocks above the given block (rolled back).
+@send external rollback: (t, int) => unit = "rollback"

package/src/sources/BlockStore.res.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.res.mjs";
+import * as FieldMask from "./FieldMask.res.mjs";
+
+function make(ecosystem, shouldChecksum) {
+  let ctor = Core.getAddon().BlockStore;
+  switch (ecosystem) {
+    case "evm" :
+      return ctor.newEvm(shouldChecksum);
+    case "fuel" :
+      return ctor.newFuel();
+    case "svm" :
+      return ctor.newSvm();
+  }
+}
+
+let makeMaskFn = FieldMask.makeMaskFn;
+
+export {
+  make,
+  makeMaskFn,
+}
+/* Core Not a pure module */