envio 3.3.0-alpha.7 → 3.3.0-alpha.8

package/src/IndexerState.res.mjs

@@ -97,7 +97,7 @@ function make$2(config, persistence, chainStates, isInReorgThreshold, isRealtime
   };
 }
 
-function makeFromDbState(config, persistence, initialState, registrations, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, reducedPollingInterval, targetBufferSizeOpt, onError) {
+function makeFromDbState(config, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, reducedPollingInterval, targetBufferSizeOpt, onError) {
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
@@ -123,7 +123,7 @@ function makeFromDbState(config, persistence, initialState, registrations, isDev
   initialState.chains.forEach(resumedChainState => {
     let chain = Config.getChain(config, resumedChainState.id);
     let chainConfig = ChainMap.get(config.chainMap, chain);
-    chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrations, reducedPollingInterval);
+    chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrationsByChainId, reducedPollingInterval);
   });
   let allChainsReady = {
     contents: initialState.chains.length !== 0
@@ -231,7 +231,7 @@ function invalidateInflight(state) {
 }
 
 function applyBatchProgress(state, batch) {
-  CrossChainState.applyBatchProgress(state.crossChainState, batch);
+  CrossChainState.applyBatchProgress(state.crossChainState, batch, state.config.ecosystem.blockTimestampName);
 }
 
 function isProcessing(state) {

package/src/IndexerState.resi

@@ -44,7 +44,7 @@ let makeFromDbState: (
   ~config: Config.t,
   ~persistence: Persistence.t,
   ~initialState: Persistence.initialState,
-  ~registrations: HandlerRegister.registrations,
+  ~registrationsByChainId: HandlerRegister.registrationsByChainId,
   ~isDevelopmentMode: bool=?,
   ~shouldUseTui: bool=?,
   ~exitAfterFirstEventBlock: bool=?,

package/src/IndexingAddresses.res

@@ -8,15 +8,18 @@ let deriveEffectiveStartBlock = (~registrationBlock: int, ~contractStartBlock: o
   Pervasives.max(Pervasives.max(registrationBlock, 0), contractStartBlock->Option.getOr(0))
 }
 
-let makeContractConfigs = (~eventConfigs: array<Internal.eventConfig>): dict<contractConfig> => {
+let makeContractConfigs = (~onEventRegistrations: array<Internal.onEventRegistration>): dict<
+  contractConfig,
+> => {
   let contractConfigs: dict<contractConfig> = Dict.make()
-  eventConfigs->Array.forEach(ec => {
-    switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(ec.contractName) {
+  onEventRegistrations->Array.forEach(reg => {
+    let contractName = reg.eventConfig.contractName
+    switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(contractName) {
     | Some({startBlock}) =>
       contractConfigs->Dict.set(
-        ec.contractName,
+        contractName,
         {
-          startBlock: switch (startBlock, ec.startBlock) {
+          startBlock: switch (startBlock, reg.startBlock) {
           | (Some(a), Some(b)) => Some(Pervasives.min(a, b))
           | (Some(_) as s, None) | (None, Some(_) as s) => s
           | (None, None) => None
@@ -25,9 +28,9 @@ let makeContractConfigs = (~eventConfigs: array<Internal.eventConfig>): dict<con
       )
     | None =>
       contractConfigs->Dict.set(
-        ec.contractName,
+        contractName,
         {
-          startBlock: ec.startBlock,
+          startBlock: reg.startBlock,
         },
       )
     }

package/src/IndexingAddresses.res.mjs

@@ -8,14 +8,15 @@ function deriveEffectiveStartBlock(registrationBlock, contractStartBlock) {
   return Primitive_int.max(Primitive_int.max(registrationBlock, 0), Stdlib_Option.getOr(contractStartBlock, 0));
 }
 
-function makeContractConfigs(eventConfigs) {
+function makeContractConfigs(onEventRegistrations) {
   let contractConfigs = {};
-  eventConfigs.forEach(ec => {
-    let match = contractConfigs[ec.contractName];
+  onEventRegistrations.forEach(reg => {
+    let contractName = reg.eventConfig.contractName;
+    let match = contractConfigs[contractName];
     if (match !== undefined) {
       let startBlock = match.startBlock;
-      let match$1 = ec.startBlock;
-      contractConfigs[ec.contractName] = {
+      let match$1 = reg.startBlock;
+      contractConfigs[contractName] = {
         startBlock: startBlock !== undefined ? (
             match$1 !== undefined ? Primitive_int.min(startBlock, match$1) : startBlock
           ) : (
@@ -24,8 +25,8 @@ function makeContractConfigs(eventConfigs) {
       };
       return;
     }
-    contractConfigs[ec.contractName] = {
-      startBlock: ec.startBlock
+    contractConfigs[contractName] = {
+      startBlock: reg.startBlock
     };
   });
   return contractConfigs;

package/src/IndexingAddresses.resi

@@ -6,7 +6,9 @@ type t
 
 let deriveEffectiveStartBlock: (~registrationBlock: int, ~contractStartBlock: option<int>) => int
 
-let makeContractConfigs: (~eventConfigs: array<Internal.eventConfig>) => dict<contractConfig>
+let makeContractConfigs: (
+  ~onEventRegistrations: array<Internal.onEventRegistration>,
+) => dict<contractConfig>
 
 let makeIndexingAddress: (
   ~contract: Internal.indexingAddress,

package/src/Internal.res

@@ -166,6 +166,19 @@ let allSvmTransactionFields: array<svmTransactionField> = [
 ]
 let svmTransactionFieldSchema = S.enum(allSvmTransactionFields)
 
+// All SVM block fields. `slot`/`time`/`hash` are always included; the rest are
+// selectable via `field_selection.block_fields` (see `allSvmBlockFields`).
+type svmBlockField =
+  | @as("slot") Slot
+  | @as("time") Time
+  | @as("hash") Hash
+  | @as("height") Height
+  | @as("parentSlot") ParentSlot
+  | @as("parentHash") ParentHash
+
+let allSvmBlockFields: array<svmBlockField> = [Height, ParentSlot, ParentHash]
+let svmBlockFieldSchema = S.enum(allSvmBlockFields)
+
 // Static sets of nullable field names — used by RpcSource and HyperSyncSource to wrap schemas with S.nullable
 let evmNullableBlockFields = Utils.Set.fromArray(
   (
@@ -295,8 +308,8 @@ type genericEvent<'params, 'block, 'transaction> = {
   block: 'block,
 }
 
-// Opaque internally — block-level values needed by the runtime
-// (blockNumber, timestamp, blockHash) live on the item instead.
+// Opaque internally — the block number needed by the runtime lives on the
+// item instead.
 type event
 
 // Opaque payload an item carries. A source builds an ecosystem-specific
@@ -312,6 +325,11 @@ type eventPayload
 @get external getPayloadTransaction: eventPayload => Nullable.t<eventTransaction> = "transaction"
 @set external setPayloadTransaction: (eventPayload, eventTransaction) => unit = "transaction"
 
+// Generic access to the payload's `block`: written/enriched at batch prep for
+// store-backed ecosystems (EVM/SVM HyperSync) and present inline otherwise.
+@get external getPayloadBlock: eventPayload => Nullable.t<eventBlock> = "block"
+@set external setPayloadBlock: (eventPayload, eventBlock) => unit = "block"
+
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
   context: 'context,
@@ -390,31 +408,17 @@ type indexingContract = {
   effectiveStartBlock: int,
 }
 
-// This is private so it's not manually constructed internally
-// The idea is that it can only be coerced from fuel/evmEventConfig
-// and it can include their fields. We prevent manual creation,
-// so the fields are not overwritten and we can safely cast the type back to fuel/evmEventConfig
+// Definition of an event/instruction we know how to decode: identity + decode
+// schemas + chain-independent field selection. A pure function of the ABI +
+// config, shared across chains. `private` so it can only be coerced from an
+// ecosystem variant (fields never overwritten), which lets sources cast the
+// base back down to evm/fuel/svm safely.
 type eventConfig = private {
   id: string,
   name: string,
   contractName: string,
-  isWildcard: bool,
-  // Whether the event has an event filter which uses addresses
-  filterByAddresses: bool,
-  // Usually always false for wildcard events
-  // But might be true for wildcard event with dynamic event filter by addresses
-  dependsOnAddresses: bool,
-  // Precompiled predicate (EVM only) for events that filter an indexed address
-  // param by registered addresses. Given the decoded event and the log's block
-  // number, drops an event whose param-address isn't registered at/before that
-  // block — the param-level analogue of EventRouter's srcAddress
-  // `effectiveStartBlock` check. Absent otherwise.
-  clientAddressFilter?: (eventPayload, int, dict<indexingContract>) => bool,
-  handler: option<handler>,
-  contractRegister: option<contractRegister>,
   paramsRawEventSchema: S.schema<eventParams>,
   simulateParamsSchema: S.schema<eventParams>,
-  startBlock: option<int>,
   // Field names selected for the chain's transaction-store materialisation
   // (camelCase, matching the ecosystem's `transactionFields`). Stored as a
   // string set so the shared mask logic is ecosystem-agnostic; sources recover
@@ -425,6 +429,12 @@ type eventConfig = private {
   // so each transaction decodes only the fields its event selected. `0.` when
   // nothing is selected or the ecosystem carries the transaction inline (Fuel).
   transactionFieldMask: float,
+  // Selected block fields precompiled to the block-store selection bitmask (bit
+  // per ecosystem field code). `0.` for ecosystems that carry the block fully
+  // inline (RPC/Fuel). The EVM selection always includes number/timestamp/hash,
+  // so an EVM mask always has their bits set; SVM stamps slot/time/hash inline
+  // from the response and its mask is the user's selection alone.
+  blockFieldMask: float,
 }
 
 type fuelEventKind =
@@ -460,18 +470,16 @@ type eventFilters =
 
 type evmEventConfig = {
   ...eventConfig,
-  getEventFiltersOrThrow: ChainMap.Chain.t => eventFilters,
   selectedBlockFields: Utils.Set.t<evmBlockField>,
   sighash: string,
   topicCount: int,
   paramsMetadata: array<paramMeta>,
 }
 
-// Shared formula for `eventConfig.dependsOnAddresses`. Kept here so
-// `EventConfigBuilder.build{Evm,Fuel}EventConfig` and
-// `HandlerLoader.applyRegistrations` stay in sync when handler state flips
-// the value. Fuel events always have `filterByAddresses=false`, so callers
-// there simply pass it through as `false`.
+// Shared formula for a registration's `dependsOnAddresses`. Kept here so the
+// `EventConfigBuilder.build*OnEventRegistration` builders stay in sync. Fuel
+// and SVM events always have `filterByAddresses=false`, so callers there pass
+// it through as `false`.
 let dependsOnAddresses = (~isWildcard, ~filterByAddresses) => !isWildcard || filterByAddresses
 
 type evmContractConfig = {
@@ -490,6 +498,10 @@ type svmAccountFilterGroup = array<svmAccountFilter>
 
 type svmInstructionEventConfig = {
   ...eventConfig,
+  /** Block fields selected via `field_selection.block_fields` (`slot` is always
+   included and excluded from this set). Drives the block query columns;
+   precompiled to `blockFieldMask` for store materialisation. */
+  selectedBlockFields: Utils.Set.t<svmBlockField>,
   /** Base58 Solana program id this instruction belongs to. */
   programId: SvmTypes.Pubkey.t,
   /** Hex-encoded discriminator. `None` matches every instruction in the program. */
@@ -516,6 +528,44 @@ type svmInstructionEventConfig = {
   definedTypes: JSON.t,
 }
 
+// Per-(event, chain) registration produced when user handler code registers an
+// event (`onEvent`) or a dynamic contract registers. References its definition
+// by value as `.eventConfig` and adds the handler binding plus the
+// registration/`where`-derived fetch state. Not `private`: Fuel/SVM
+// registrations add no ecosystem-specific fields (so they're bare aliases that
+// must stay directly constructable), and the evm→base cast in sources is sound
+// by ecosystem homogeneity — an EVM chain only ever holds `evmOnEventRegistration`s.
+type onEventRegistration = {
+  eventConfig: eventConfig,
+  handler: option<handler>,
+  contractRegister: option<contractRegister>,
+  isWildcard: bool,
+  // Whether the event has an event filter which uses addresses.
+  filterByAddresses: bool,
+  // Usually always false for wildcard events, but might be true for a wildcard
+  // event with a dynamic event filter by addresses.
+  dependsOnAddresses: bool,
+  // Precompiled predicate for events that filter an indexed address param by
+  // registered addresses (see `EventConfigBuilder.buildAddressFilter`); drops a
+  // decoded event whose param-address isn't registered at/before the log's
+  // block. Absent otherwise.
+  clientAddressFilter?: (eventPayload, int, dict<indexingContract>) => bool,
+  // Final start block: the contract/chain config value, overridden by a
+  // `where.block.number._gte` when the registered `where` supplies one.
+  startBlock: option<int>,
+}
+
+type evmOnEventRegistration = {
+  ...onEventRegistration,
+  getEventFiltersOrThrow: ChainMap.Chain.t => eventFilters,
+}
+
+// Fuel and SVM registrations add no ecosystem-specific fetch state (their
+// filters are config-derived and live on the definition), so they're bare
+// aliases of the base registration.
+type fuelOnEventRegistration = onEventRegistration
+type svmOnEventRegistration = onEventRegistration
+
 type svmProgramConfig = {
   name: string,
   programId: SvmTypes.Pubkey.t,
@@ -536,11 +586,9 @@ type dcs = array<indexingAddress>
 // to make item properly unboxed
 type eventItem = private {
   kind: [#0],
-  eventConfig: eventConfig,
-  timestamp: int,
+  onEventRegistration: onEventRegistration,
   chain: ChainMap.Chain.t,
   blockNumber: int,
-  blockHash: string,
   logIndex: int,
   // Within-block transaction index — the key into the per-chain transaction
   // store. Unused (0) for ecosystems that carry the transaction inline (Fuel).
@@ -575,7 +623,7 @@ type onBlockArgs = {
   context: handlerContext,
 }
 
-type onBlockConfig = {
+type onBlockRegistration = {
   // When there are multiple onBlock handlers per chain,
   // we want to use the order they are defined for sorting
   index: int,
@@ -591,16 +639,14 @@ type onBlockConfig = {
 type item =
   | @as(0)
   Event({
-      eventConfig: eventConfig,
-      timestamp: int,
+      onEventRegistration: onEventRegistration,
       chain: ChainMap.Chain.t,
       blockNumber: int,
-      blockHash: string,
       logIndex: int,
       transactionIndex: int,
       payload: eventPayload,
     })
-  | @as(1) Block({onBlockConfig: onBlockConfig, blockNumber: int, logIndex: int})
+  | @as(1) Block({onBlockRegistration: onBlockRegistration, blockNumber: int, logIndex: int})
 
 external castUnsafeEventItem: item => eventItem = "%identity"
 
@@ -612,7 +658,7 @@ external getItemLogIndex: item => int = "logIndex"
 let getItemChainId = item =>
   switch item {
   | Event({chain}) => chain->ChainMap.Chain.toChainId
-  | Block({onBlockConfig: {chainId}}) => chainId
+  | Block({onBlockRegistration: {chainId}}) => chainId
   }
 
 @get

package/src/Internal.res.mjs

@@ -90,6 +90,14 @@ let allSvmTransactionFields = [
 
 let svmTransactionFieldSchema = S$RescriptSchema.$$enum(allSvmTransactionFields);
 
+let allSvmBlockFields = [
+  "height",
+  "parentSlot",
+  "parentHash"
+];
+
+let svmBlockFieldSchema = S$RescriptSchema.$$enum(allSvmBlockFields);
+
 let evmNullableBlockFields = new Set([
   "nonce",
   "difficulty",
@@ -141,7 +149,7 @@ function getItemChainId(item) {
   if (item.kind === 0) {
     return item.chain;
   } else {
-    return item.onBlockConfig.chainId;
+    return item.onBlockRegistration.chainId;
   }
 }
 
@@ -178,6 +186,8 @@ export {
   evmTransactionFieldSchema,
   allSvmTransactionFields,
   svmTransactionFieldSchema,
+  allSvmBlockFields,
+  svmBlockFieldSchema,
   evmNullableBlockFields,
   evmNullableTransactionFields,
   dependsOnAddresses,

package/src/Main.res

@@ -82,7 +82,7 @@ let getInitialChainState = (~chainId: int): option<Persistence.initialChainState
   }
 }
 
-// Importing `generated` must not trigger `Config.loadWithoutRegistrations()`,
+// Importing `generated` must not trigger `Config.load()`,
 // so the exported indexer calls this lazily on first `indexer.chains` access.
 let buildChainsObject = (~config: Config.t) => {
   let chainIds = []
@@ -372,7 +372,7 @@ let getGlobalIndexer = (): 'indexer => {
   // math at `FetchState.res:619` stays untouched.
   let onBlockFn = (rawOptions: 'a, handler: 'b) => {
     HandlerRegister.throwIfFinishedRegistration(~methodName="onBlock")
-    let config = Config.loadWithoutRegistrations()
+    let config = Config.load()
     let ecosystem = config.ecosystem
     let raw =
       rawOptions->(
@@ -471,13 +471,13 @@ let getGlobalIndexer = (): 'indexer => {
   // `Api.res` calls `getGlobalIndexer()` at envio-package load, so the keys
   // array is memoized lazily: an early `createEffect` / `S` import that
   // never touches the indexer must not trigger a config parse. The memo is
-  // safe because `Config.loadWithoutRegistrations` is itself pure.
+  // safe because `Config.load` is itself pure.
   let keysMemo: ref<option<array<string>>> = ref(None)
   let getKeys = () =>
     switch keysMemo.contents {
     | Some(k) => k
     | None => {
-        let keys = switch Config.loadWithoutRegistrations().ecosystem.name {
+        let keys = switch Config.load().ecosystem.name {
         | Evm | Fuel => [
             "name",
             "description",
@@ -505,15 +505,15 @@ let getGlobalIndexer = (): 'indexer => {
 
   let get = (~prop: string) =>
     switch prop {
-    | "name" => Config.loadWithoutRegistrations().name->(Utils.magic: string => unknown)
+    | "name" => Config.load().name->(Utils.magic: string => unknown)
     | "description" =>
-      Config.loadWithoutRegistrations().description->(Utils.magic: option<string> => unknown)
+      Config.load().description->(Utils.magic: option<string> => unknown)
     | "chainIds" => {
-        let (_, chainIds) = buildChainsObject(~config=Config.loadWithoutRegistrations())
+        let (_, chainIds) = buildChainsObject(~config=Config.load())
         chainIds->(Utils.magic: array<int> => unknown)
       }
     | "chains" => {
-        let (chains, _) = buildChainsObject(~config=Config.loadWithoutRegistrations())
+        let (chains, _) = buildChainsObject(~config=Config.load())
         chains->(Utils.magic: {..} => unknown)
       }
     | "onEvent" => onEventFn->Utils.magic
@@ -657,7 +657,7 @@ type mainArgs = Yargs.parsedArgs<args>
 let getEnvioInfo = () => Config.getPublicConfigJson()->Config.stripSensitiveData
 
 let migrate = async (~reset) => {
-  let config = Config.loadWithoutRegistrations()
+  let config = Config.load()
   let persistence = PgStorage.makePersistenceFromConfig(~config)
   await persistence->Persistence.init(
     ~reset,
@@ -670,7 +670,7 @@ let migrate = async (~reset) => {
 }
 
 let dropSchema = async () => {
-  let config = Config.loadWithoutRegistrations()
+  let config = Config.load()
   let persistence = PgStorage.makePersistenceFromConfig(~config)
   await persistence.storage.reset()
   await persistence.storage.close()
@@ -685,7 +685,7 @@ let start = async (
   ~reset=false,
   ~isTest=false,
   ~exitAfterFirstEventBlock=false,
-  ~patchConfig: option<(Config.t, HandlerRegister.registrations) => Config.t>=?,
+  ~patchConfig: option<(Config.t, HandlerRegister.registrationsByChainId) => Config.t>=?,
 ) => {
   let mainArgs: mainArgs = process->argv->Yargs.hideBin->Yargs.yargs->Yargs.argv
   let explicitTui = switch mainArgs.tuiOff {
@@ -699,31 +699,30 @@ let start = async (
   }
   // Initialize persistence first so the exported indexer value contains state from the database
   // when handler files are loaded (they may access the indexer at module top level).
-  let configWithoutRegistrations = Config.loadWithoutRegistrations()
+  let config = Config.load()
   // isDevelopmentMode controls whether the indexer stays alive after all
   // chains finish (keepProcessAlive) and whether the console API is exposed.
   // Set by `envio dev` via the public config's `isDev` field; `envio start`
   // leaves it false so the process exits cleanly when indexing completes.
-  let isDevelopmentMode = !isTest && configWithoutRegistrations.isDev
+  let isDevelopmentMode = !isTest && config.isDev
   let persistence = switch persistence {
   | Some(p) => p
-  | None => PgStorage.makePersistenceFromConfig(~config=configWithoutRegistrations)
+  | None => PgStorage.makePersistenceFromConfig(~config)
   }
   globalPersistenceRef := Some(persistence)
   await persistence->Persistence.init(
     ~reset,
-    ~chainConfigs=configWithoutRegistrations.chainMap->ChainMap.values,
+    ~chainConfigs=config.chainMap->ChainMap.values,
     ~envioInfo=getEnvioInfo(),
     ~resetCommand=isDevelopmentMode ? "envio dev -r" : "envio start -r",
     ~runCommand=Some(isDevelopmentMode ? "envio dev" : "envio start"),
   )
 
-  // `Config.loadWithoutRegistrations` never sees registration state; handler,
-  // contractRegister, and eventFilters are baked into each event config only
-  // by the returned value here.
-  let (config, registrations) = await HandlerLoader.registerAllHandlers(
-    ~config=configWithoutRegistrations,
-  )
+  // Loads user handler files, which register handler/contractRegister/where
+  // state into the global `HandlerRegister` registry as a side effect; this
+  // returns that state resolved into per-chain registrations. `config` itself
+  // is never mutated by registration — it holds only event definitions.
+  let registrationsByChainId = await HandlerLoader.registerAllHandlers(~config)
   let config = if isTest {
     {...config, shouldRollbackOnReorg: false}
   } else {
@@ -731,7 +730,7 @@ let start = async (
   }
 
   let config = switch patchConfig {
-  | Some(patchConfig) => patchConfig(config, registrations)
+  | Some(patchConfig) => patchConfig(config, registrationsByChainId)
   | None => config
   }
   // The single fatal-error handler, invoked once via IndexerState.errorExit.
@@ -778,7 +777,7 @@ let start = async (
     ~config,
     ~persistence,
     ~initialState=persistence->Persistence.getInitializedState,
-    ~registrations,
+    ~registrationsByChainId,
     ~isDevelopmentMode,
     ~shouldUseTui,
     ~exitAfterFirstEventBlock,

package/src/Main.res.mjs

@@ -296,7 +296,7 @@ function getGlobalIndexer() {
   };
   let onBlockFn = (rawOptions, handler) => {
     HandlerRegister.throwIfFinishedRegistration("onBlock");
-    let config = Config.loadWithoutRegistrations();
+    let config = Config.load();
     let ecosystem = config.ecosystem;
     let match = buildChainsObject(config);
     let chains = match[0];
@@ -350,7 +350,7 @@ function getGlobalIndexer() {
     if (k !== undefined) {
       return k;
     }
-    let match = Config.loadWithoutRegistrations().ecosystem.name;
+    let match = Config.load().ecosystem.name;
     let keys;
     let exit = 0;
     switch (match) {
@@ -388,15 +388,15 @@ function getGlobalIndexer() {
   let get = prop => {
     switch (prop) {
       case "chainIds" :
-        return buildChainsObject(Config.loadWithoutRegistrations())[1];
+        return buildChainsObject(Config.load())[1];
       case "chains" :
-        return buildChainsObject(Config.loadWithoutRegistrations())[0];
+        return buildChainsObject(Config.load())[0];
       case "contractRegister" :
         return contractRegisterFn;
       case "description" :
-        return Config.loadWithoutRegistrations().description;
+        return Config.load().description;
       case "name" :
-        return Config.loadWithoutRegistrations().name;
+        return Config.load().name;
       case "onEvent" :
         return onEventFn;
       case "onInstruction" :
@@ -501,14 +501,14 @@ function getEnvioInfo() {
 }
 
 async function migrate(reset) {
-  let config = Config.loadWithoutRegistrations();
+  let config = Config.load();
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
   await Persistence.init(persistence, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), "envio local db-migrate setup", undefined, reset);
   return await persistence.storage.close();
 }
 
 async function dropSchema() {
-  let config = Config.loadWithoutRegistrations();
+  let config = Config.load();
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
   await persistence.storage.reset();
   return await persistence.storage.close();
@@ -526,14 +526,12 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   let shouldUseTui = isTest ? false : (
       explicitTui !== undefined ? explicitTui : !Envio.isNonInteractive()
     );
-  let configWithoutRegistrations = Config.loadWithoutRegistrations();
-  let isDevelopmentMode = !isTest && configWithoutRegistrations.isDev;
-  let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(configWithoutRegistrations, undefined);
+  let config = Config.load();
+  let isDevelopmentMode = !isTest && config.isDev;
+  let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(config, undefined);
   globalPersistenceRef.contents = persistence$1;
-  await Persistence.init(persistence$1, ChainMap.values(configWithoutRegistrations.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset);
-  let match = await HandlerLoader.registerAllHandlers(configWithoutRegistrations);
-  let registrations = match[1];
-  let config = match[0];
+  await Persistence.init(persistence$1, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset);
+  let registrationsByChainId = await HandlerLoader.registerAllHandlers(config);
   let config$1 = isTest ? ({
       name: config.name,
       description: config.description,
@@ -555,7 +553,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
       allEntities: config.allEntities,
       allEnums: config.allEnums
     }) : config;
-  let config$2 = patchConfig !== undefined ? patchConfig(config$1, registrations) : config$1;
+  let config$2 = patchConfig !== undefined ? patchConfig(config$1, registrationsByChainId) : config$1;
   let onErrorReject = {
     contents: undefined
   };
@@ -593,7 +591,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
       };
     }, persistence$1, isDevelopmentMode);
   }
-  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrations, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError);
+  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError);
   if (shouldUseTui) {
     Tui.start(() => state);
   }

package/src/Metrics.res

@@ -18,16 +18,57 @@ let renderGauge = (~name, ~help, ~chains: dict<'a>, ~value: 'a => int) => {
   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."
+
+// Hand-rolls both HELP/TYPE blocks and their samples straight from
+// SourceManager's aggregates — fully our own state, no prom-client registry
+// involved. A leading "\n" on each block since, unlike prom-client's own
+// metrics() output, renderGauge's output right before this doesn't end in one.
+// Skips a method's seconds line when it has no timing (e.g. heightSubscription,
+// which only ever records a count), and skips both blocks entirely when there's
+// nothing to report at all.
+let renderSourceRequests = (~samples: array<SourceManager.requestStatSample>) => {
+  if samples->Utils.Array.isEmpty {
+    ""
+  } else {
+    let countOut = ref(
+      `\n# HELP ${sourceRequestTotalName} ${sourceRequestTotalHelp}\n# TYPE ${sourceRequestTotalName} counter`,
+    )
+    let secondsOut = ref(
+      `\n# HELP ${sourceRequestSecondsTotalName} ${sourceRequestSecondsTotalHelp}\n# TYPE ${sourceRequestSecondsTotalName} counter`,
+    )
+    samples->Array.forEach(sample => {
+      let labels = `{source="${sample.sourceName}",chainId="${sample.chainId->Int.toString}",method="${sample.method}"}`
+      countOut :=
+        countOut.contents ++ `\n${sourceRequestTotalName}${labels} ${sample.count->Int.toString}`
+      if sample.seconds !== 0. {
+        secondsOut :=
+          secondsOut.contents ++
+          `\n${sourceRequestSecondsTotalName}${labels} ${sample.seconds->Float.toString}`
+      }
+    })
+    countOut.contents ++ secondsOut.contents
+  }
+}
+
 let collect = async (~state: option<IndexerState.t>) => {
   let base = await PromClient.defaultRegister->PromClient.metrics
   switch state {
   | None => base
   | Some(state) =>
+    let chainStates = state->IndexerState.chainStates
+    let sourceRequestSamples =
+      chainStates
+      ->Dict.valuesToArray
+      ->Array.flatMap(cs => cs->ChainState.sourceManager->SourceManager.getRequestStatSamples)
     `${base}${renderGauge(
         ~name=indexingAddressesName,
         ~help=indexingAddressesHelp,
-        ~chains=state->IndexerState.chainStates,
+        ~chains=chainStates,
         ~value=cs => (cs->ChainState.toChainData).numAddresses,
-      )}\n`
+      )}${renderSourceRequests(~samples=sourceRequestSamples)}\n`
   }
 }