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

package/src/sources/EventRouter.res

@@ -96,16 +96,16 @@ let getEvmEventId = (~sighash, ~topicCount) => {
   sighash ++ "_" ++ topicCount->Int.toString
 }
 
-let fromEvmEventModsOrThrow = (events: array<Internal.evmEventConfig>, ~chain): t<
-  Internal.evmEventConfig,
+let fromEvmEventModsOrThrow = (events: array<Internal.evmOnEventRegistration>, ~chain): t<
+  Internal.evmOnEventRegistration,
 > => {
   let router = empty()
   events->Array.forEach(config => {
     router->addOrThrow(
-      config.id,
+      config.eventConfig.id,
       config,
-      ~contractName=config.contractName,
-      ~eventName=config.name,
+      ~contractName=config.eventConfig.contractName,
+      ~eventName=config.eventConfig.name,
       ~chain,
       ~isWildcard=config.isWildcard,
     )
@@ -131,21 +131,26 @@ type svmProgramOrdering = {
   byteLengthsDesc: array<int>,
 }
 
-let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConfig>, ~chain): (
-  t<Internal.svmInstructionEventConfig>,
+let fromSvmEventConfigsOrThrow = (events: array<Internal.svmOnEventRegistration>, ~chain): (
+  t<Internal.svmOnEventRegistration>,
   array<svmProgramOrdering>,
 ) => {
   let router = empty()
   events->Array.forEach(config => {
+    let eventConfig =
+      config.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
     // The router tag must include the programId so two programs declaring the
     // same discriminator coexist. The source-side lookup uses the same shape
     // via `getSvmEventId(~programId, ~discriminator)`.
-    let routerTag = getSvmEventId(~programId=config.programId, ~discriminator=config.discriminator)
+    let routerTag = getSvmEventId(
+      ~programId=eventConfig.programId,
+      ~discriminator=eventConfig.discriminator,
+    )
     router->addOrThrow(
       routerTag,
       config,
-      ~contractName=config.contractName,
-      ~eventName=config.name,
+      ~contractName=eventConfig.contractName,
+      ~eventName=eventConfig.name,
       ~chain,
       ~isWildcard=config.isWildcard,
     )
@@ -154,7 +159,9 @@ let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConf
   // Per-program list of declared discriminator byte lengths, sorted desc.
   let byProgram: dict<Utils.Set.t<int>> = Dict.make()
   events->Array.forEach(config => {
-    let key = config.programId->SvmTypes.Pubkey.toString
+    let eventConfig =
+      config.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+    let key = eventConfig.programId->SvmTypes.Pubkey.toString
     let set = switch byProgram->Utils.Dict.dangerouslyGetNonOption(key) {
     | Some(s) => s
     | None =>
@@ -162,7 +169,7 @@ let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConf
       byProgram->Dict.set(key, s)
       s
     }
-    let _ = set->Utils.Set.add(config.discriminatorByteLen)
+    let _ = set->Utils.Set.add(eventConfig.discriminatorByteLen)
   })
   let ordering =
     byProgram

package/src/sources/EventRouter.res.mjs

@@ -103,7 +103,7 @@ function getEvmEventId(sighash, topicCount) {
 
 function fromEvmEventModsOrThrow(events, chain) {
   let router = {};
-  events.forEach(config => addOrThrow$1(router, config.id, config, config.contractName, config.isWildcard, config.name, chain));
+  events.forEach(config => addOrThrow$1(router, config.eventConfig.id, config, config.eventConfig.contractName, config.isWildcard, config.eventConfig.name, chain));
   return router;
 }
 
@@ -118,12 +118,14 @@ function getSvmEventId(programId, discriminator) {
 function fromSvmEventConfigsOrThrow(events, chain) {
   let router = {};
   events.forEach(config => {
-    let routerTag = getSvmEventId(config.programId, config.discriminator);
-    addOrThrow$1(router, routerTag, config, config.contractName, config.isWildcard, config.name, chain);
+    let eventConfig = config.eventConfig;
+    let routerTag = getSvmEventId(eventConfig.programId, eventConfig.discriminator);
+    addOrThrow$1(router, routerTag, config, eventConfig.contractName, config.isWildcard, eventConfig.name, chain);
   });
   let byProgram = {};
   events.forEach(config => {
-    let key = config.programId;
+    let eventConfig = config.eventConfig;
+    let key = eventConfig.programId;
     let s = byProgram[key];
     let set;
     if (s !== undefined) {
@@ -133,7 +135,7 @@ function fromSvmEventConfigsOrThrow(events, chain) {
       byProgram[key] = s$1;
       set = s$1;
     }
-    set.add(config.discriminatorByteLen);
+    set.add(eventConfig.discriminatorByteLen);
   });
   let ordering = Object.entries(byProgram).map(param => {
     let sorted = Array.from(param[1]).toSorted((a, b) => b - a | 0);

package/src/sources/Evm.res

@@ -10,7 +10,9 @@ type payload = {
   srcAddress: Address.t,
   logIndex: int,
   transaction?: Internal.eventTransaction,
-  block: Internal.eventBlock,
+  // HyperSync omits `block` (it lives raw in the per-chain store and is written
+  // onto the payload at batch prep); RPC/simulate build it inline.
+  block?: Internal.eventBlock,
 }
 external fromPayload: payload => Internal.eventPayload = "%identity"
 external toPayload: Internal.eventPayload => payload = "%identity"
@@ -27,6 +29,42 @@ let transactionFields =
 // per event at config build and cached on the event config.
 let eventTransactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
 
+// Ordered block field names. The index of each is the field code shared with the
+// Rust store (`EvmBlockField`) — keep this order in sync.
+let blockFields = [
+  "number",
+  "timestamp",
+  "hash",
+  "parentHash",
+  "nonce",
+  "sha3Uncles",
+  "logsBloom",
+  "transactionsRoot",
+  "stateRoot",
+  "receiptsRoot",
+  "miner",
+  "difficulty",
+  "totalDifficulty",
+  "extraData",
+  "size",
+  "gasLimit",
+  "gasUsed",
+  "uncles",
+  "baseFeePerGas",
+  "blobGasUsed",
+  "excessBlobGas",
+  "parentBeaconBlockRoot",
+  "withdrawalsRoot",
+  "l1BlockNumber",
+  "sendCount",
+  "sendRoot",
+  "mixHash",
+]
+
+// One event's selected block fields → store selection bitmask. Computed per
+// event at config build and cached on the event config.
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields)
+
 let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.hash
     delete fields.number
@@ -63,8 +101,8 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     Logging.createChildFrom(
       ~logger,
       ~params={
-        "contract": eventItem.eventConfig.contractName,
-        "event": eventItem.eventConfig.name,
+        "contract": eventItem.onEventRegistration.eventConfig.contractName,
+        "event": eventItem.onEventRegistration.eventConfig.name,
         "chainId": eventItem.chain->ChainMap.Chain.toChainId,
         "block": eventItem.blockNumber,
         "logIndex": eventItem.logIndex,
@@ -74,7 +112,17 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   toRawEvent: eventItem => {
     let payload = eventItem.payload->toPayload
     let eventConfig =
-      eventItem.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
+      eventItem.onEventRegistration.eventConfig->(
+        Utils.magic: Internal.eventConfig => Internal.evmEventConfig
+      )
+    // Store-backed payloads get `block` written at batch prep and inline
+    // sources carry it from the start, with hash/timestamp always selected —
+    // so both are present by the time a raw event is built.
+    let header = switch payload.block {
+    | Some(block) => block->(Utils.magic: Internal.eventBlock => {"hash": string, "timestamp": int})
+    | None =>
+      JsError.throwWithMessage("Unexpected case: The event block is missing for a raw event")
+    }
     eventItem->RawEvent.make(
       ~block=payload.block,
       ~transaction=payload.transaction,
@@ -84,6 +132,8 @@ let make = (~logger: Pino.t): Ecosystem.t => {
         ? ()->(Utils.magic: unit => Internal.eventParams)
         : payload.params,
       ~srcAddress=payload.srcAddress,
+      ~blockHash=header["hash"],
+      ~blockTimestamp=header["timestamp"],
       ~cleanUpRawEventFieldsInPlace,
     )
   },

package/src/sources/Evm.res.mjs

@@ -3,11 +3,46 @@
 import * as Logging from "../Logging.res.mjs";
 import * as Internal from "../Internal.res.mjs";
 import * as RawEvent from "../RawEvent.res.mjs";
+import * as BlockStore from "./BlockStore.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as TransactionStore from "./TransactionStore.res.mjs";
 
 let eventTransactionFieldMask = TransactionStore.makeMaskFn(Internal.allEvmTransactionFields);
 
+let blockFields = [
+  "number",
+  "timestamp",
+  "hash",
+  "parentHash",
+  "nonce",
+  "sha3Uncles",
+  "logsBloom",
+  "transactionsRoot",
+  "stateRoot",
+  "receiptsRoot",
+  "miner",
+  "difficulty",
+  "totalDifficulty",
+  "extraData",
+  "size",
+  "gasLimit",
+  "gasUsed",
+  "uncles",
+  "baseFeePerGas",
+  "blobGasUsed",
+  "excessBlobGas",
+  "parentBeaconBlockRoot",
+  "withdrawalsRoot",
+  "l1BlockNumber",
+  "sendCount",
+  "sendRoot",
+  "mixHash"
+];
+
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields);
+
 let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.hash
     delete fields.number
@@ -27,8 +62,8 @@ function make(logger) {
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {
-      contract: eventItem.eventConfig.contractName,
-      event: eventItem.eventConfig.name,
+      contract: eventItem.onEventRegistration.eventConfig.contractName,
+      event: eventItem.onEventRegistration.eventConfig.name,
       chainId: eventItem.chain,
       block: eventItem.blockNumber,
       logIndex: eventItem.logIndex,
@@ -36,8 +71,10 @@ function make(logger) {
     }),
     toRawEvent: eventItem => {
       let payload = eventItem.payload;
-      let eventConfig = eventItem.eventConfig;
-      return RawEvent.make(eventItem, payload.block, payload.transaction, eventConfig.paramsMetadata.length === 0 ? undefined : payload.params, payload.srcAddress, cleanUpRawEventFieldsInPlace);
+      let eventConfig = eventItem.onEventRegistration.eventConfig;
+      let block = payload.block;
+      let header = block !== undefined ? Primitive_option.valFromOption(block) : Stdlib_JsError.throwWithMessage("Unexpected case: The event block is missing for a raw event");
+      return RawEvent.make(eventItem, payload.block, payload.transaction, eventConfig.paramsMetadata.length === 0 ? undefined : payload.params, payload.srcAddress, header.hash, header.timestamp, cleanUpRawEventFieldsInPlace);
     }
   };
 }
@@ -47,6 +84,8 @@ let transactionFields = Internal.allEvmTransactionFields;
 export {
   transactionFields,
   eventTransactionFieldMask,
+  blockFields,
+  eventBlockFieldMask,
   cleanUpRawEventFieldsInPlace,
   make,
 }

package/src/sources/EvmChain.res

@@ -39,39 +39,35 @@ let getSyncConfig = (
   }
 }
 
-let collectEventParams = (contracts: array<Internal.evmContractConfig>): array<
+let collectEventParams = (onEventRegistrations: array<Internal.evmOnEventRegistration>): array<
   HyperSyncClient.Decoder.eventParamsInput,
 > => {
   let result = []
-  contracts->Array.forEach(contract => {
-    contract.events->Array.forEach(event => {
-      result
-      ->Array.push({
-        HyperSyncClient.Decoder.sighash: event.sighash,
-        topicCount: event.topicCount,
-        eventName: event.name,
-        contractName: contract.name,
-        params: event.paramsMetadata,
-      })
-      ->ignore
+  onEventRegistrations->Array.forEach(reg => {
+    let event = reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
+    result
+    ->Array.push({
+      HyperSyncClient.Decoder.sighash: event.sighash,
+      topicCount: event.topicCount,
+      eventName: event.name,
+      contractName: event.contractName,
+      params: event.paramsMetadata,
     })
+    ->ignore
   })
   result
 }
 
 let makeSources = (
   ~chain,
-  ~contracts: array<Internal.evmContractConfig>,
+  ~onEventRegistrations: array<Internal.evmOnEventRegistration>,
   ~hyperSync,
   ~rpcs: array<rpc>,
   ~lowercaseAddresses,
 ) => {
-  let eventRouter =
-    contracts
-    ->Array.flatMap(contract => contract.events)
-    ->EventRouter.fromEvmEventModsOrThrow(~chain)
+  let eventRouter = onEventRegistrations->EventRouter.fromEvmEventModsOrThrow(~chain)
 
-  let allEventParams = collectEventParams(contracts)
+  let allEventParams = collectEventParams(onEventRegistrations)
 
   let sources = switch hyperSync {
   | Some(endpointUrl) => [

package/src/sources/EvmChain.res.mjs

@@ -20,25 +20,24 @@ function getSyncConfig(param) {
   };
 }
 
-function collectEventParams(contracts) {
+function collectEventParams(onEventRegistrations) {
   let result = [];
-  contracts.forEach(contract => {
-    contract.events.forEach(event => {
-      result.push({
-        sighash: event.sighash,
-        topicCount: event.topicCount,
-        eventName: event.name,
-        contractName: contract.name,
-        params: event.paramsMetadata
-      });
+  onEventRegistrations.forEach(reg => {
+    let event = reg.eventConfig;
+    result.push({
+      sighash: event.sighash,
+      topicCount: event.topicCount,
+      eventName: event.name,
+      contractName: event.contractName,
+      params: event.paramsMetadata
     });
   });
   return result;
 }
 
-function makeSources(chain, contracts, hyperSync, rpcs, lowercaseAddresses) {
-  let eventRouter = EventRouter.fromEvmEventModsOrThrow(contracts.flatMap(contract => contract.events), chain);
-  let allEventParams = collectEventParams(contracts);
+function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses) {
+  let eventRouter = EventRouter.fromEvmEventModsOrThrow(onEventRegistrations, chain);
+  let allEventParams = collectEventParams(onEventRegistrations);
   let sources = hyperSync !== undefined ? [HyperSyncSource.make({
         chain: chain,
         endpointUrl: hyperSync,

package/src/sources/FieldMask.res

@@ -0,0 +1,39 @@
+// Selection-bitmask helpers shared by the per-chain field stores
+// (`TransactionStore`, `BlockStore`). A field's bit index is its position in the
+// ecosystem's ordered field-name array — the same code the Rust store uses.
+
+// Field-name → bit-index map from an ordered field-name array.
+let fieldCodes = (fields: array<string>): dict<int> => {
+  let codes = Dict.make()
+  fields->Array.forEachWithIndex((name, i) => codes->Dict.set(name, i))
+  codes
+}
+
+let pow2: int => float = %raw(`c => Math.pow(2, c)`)
+
+// One event's selected fields as a bitmask float (bit `code` set ⇔ selected).
+// Each field appears once, so summing `pow2(code)` sets distinct bits with no
+// overlap; the result stays exact in f64 (codes span 0..31, so a mask is at most
+// 2^32-1).
+let maskFromFields = (selectedFields: Utils.Set.t<string>, ~codes: dict<int>): float => {
+  let mask = ref(0.)
+  selectedFields->Utils.Set.forEach(name =>
+    switch codes->Utils.Dict.dangerouslyGetNonOption(name) {
+    | Some(code) => mask := mask.contents +. pow2(code)
+    | None => ()
+    }
+  )
+  mask.contents
+}
+
+// Build an ecosystem's per-event mask function from its ordered field-name
+// array. The field codes are derived once and closed over.
+let makeMaskFn = (fields: array<string>): (Utils.Set.t<string> => float) => {
+  let codes = fieldCodes(fields)
+  selectedFields => selectedFields->maskFromFields(~codes)
+}
+
+// Bitwise OR of two per-event masks. Masks fit in 32 bits (≤32 fields), so
+// `>>> 0` recovers the unsigned value that a plain `|` renders negative once bit
+// 31 is set.
+let orMask: (float, float) => float = %raw(`(a, b) => (a | b) >>> 0`)

package/src/sources/FieldMask.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function fieldCodes(fields) {
+  let codes = {};
+  fields.forEach((name, i) => {
+    codes[name] = i;
+  });
+  return codes;
+}
+
+let pow2 = (c => Math.pow(2, c));
+
+function maskFromFields(selectedFields, codes) {
+  let mask = {
+    contents: 0
+  };
+  selectedFields.forEach(name => {
+    let code = codes[name];
+    if (code !== undefined) {
+      mask.contents = mask.contents + pow2(code);
+      return;
+    }
+  });
+  return mask.contents;
+}
+
+function makeMaskFn(fields) {
+  let codes = fieldCodes(fields);
+  return selectedFields => maskFromFields(selectedFields, codes);
+}
+
+let orMask = ((a, b) => (a | b) >>> 0);
+
+export {
+  fieldCodes,
+  pow2,
+  maskFromFields,
+  makeMaskFn,
+  orMask,
+}
+/* No side effect */

package/src/sources/Fuel.res

@@ -44,8 +44,8 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     Logging.createChildFrom(
       ~logger,
       ~params={
-        "contract": eventItem.eventConfig.contractName,
-        "event": eventItem.eventConfig.name,
+        "contract": eventItem.onEventRegistration.eventConfig.contractName,
+        "event": eventItem.onEventRegistration.eventConfig.name,
         "chainId": eventItem.chain->ChainMap.Chain.toChainId,
         "block": eventItem.blockNumber,
         "logIndex": eventItem.logIndex,
@@ -54,11 +54,14 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     ),
   toRawEvent: eventItem => {
     let payload = eventItem.payload->toPayload
+    let header = payload.block->(Utils.magic: Internal.eventBlock => {"id": string, "time": int})
     eventItem->RawEvent.make(
       ~block=payload.block,
       ~transaction=payload.transaction,
       ~params=payload.params,
       ~srcAddress=payload.srcAddress,
+      ~blockHash=header["id"],
+      ~blockTimestamp=header["time"],
       ~cleanUpRawEventFieldsInPlace,
     )
   },

package/src/sources/Fuel.res.mjs

@@ -23,8 +23,8 @@ function make(logger) {
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {
-      contract: eventItem.eventConfig.contractName,
-      event: eventItem.eventConfig.name,
+      contract: eventItem.onEventRegistration.eventConfig.contractName,
+      event: eventItem.onEventRegistration.eventConfig.name,
       chainId: eventItem.chain,
       block: eventItem.blockNumber,
       logIndex: eventItem.logIndex,
@@ -32,7 +32,8 @@ function make(logger) {
     }),
     toRawEvent: eventItem => {
       let payload = eventItem.payload;
-      return RawEvent.make(eventItem, payload.block, payload.transaction, payload.params, payload.srcAddress, cleanUpRawEventFieldsInPlace);
+      let header = payload.block;
+      return RawEvent.make(eventItem, payload.block, payload.transaction, payload.params, payload.srcAddress, header.id, header.time, cleanUpRawEventFieldsInPlace);
     }
   };
 }

package/src/sources/HyperFuelSource.res

@@ -13,7 +13,7 @@ type selectionConfig = {
   getRecieptsSelection: (
     ~addressesByContractName: dict<array<Address.t>>,
   ) => array<HyperFuelClient.QueryTypes.receiptSelection>,
-  eventRouter: EventRouter.t<Internal.fuelEventConfig>,
+  eventRouter: EventRouter.t<Internal.fuelOnEventRegistration>,
 }
 
 let logDataReceiptTypeSelection: array<FuelSDK.receiptType> = [LogData]
@@ -127,39 +127,40 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
 
   let contractNames = Utils.Set.make()
 
-  selection.eventConfigs
-  ->(Utils.magic: array<Internal.eventConfig> => array<Internal.fuelEventConfig>)
-  ->Array.forEach(eventConfig => {
+  selection.onEventRegistrations->Array.forEach(reg => {
+    let eventConfig =
+      reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.fuelEventConfig)
     let contractName = eventConfig.contractName
-    if !eventConfig.isWildcard {
+    let isWildcard = reg.isWildcard
+    if !isWildcard {
       let _ = contractNames->Utils.Set.add(contractName)
     }
     eventRouter->EventRouter.addOrThrow(
       eventConfig.id,
-      eventConfig,
+      reg,
       ~contractName,
       ~eventName=eventConfig.name,
       ~chain,
-      ~isWildcard=eventConfig.isWildcard,
+      ~isWildcard,
     )
 
-    switch eventConfig {
-    | {kind: Mint, isWildcard: true} => addNonLogDataWildcardReceiptTypes(Mint)
-    | {kind: Mint} => addNonLogDataReceiptType(contractName, Mint)
-    | {kind: Burn, isWildcard: true} => addNonLogDataWildcardReceiptTypes(Burn)
-    | {kind: Burn} => addNonLogDataReceiptType(contractName, Burn)
-    | {kind: Transfer, isWildcard: true} => {
+    switch (eventConfig.kind, isWildcard) {
+    | (Mint, true) => addNonLogDataWildcardReceiptTypes(Mint)
+    | (Mint, false) => addNonLogDataReceiptType(contractName, Mint)
+    | (Burn, true) => addNonLogDataWildcardReceiptTypes(Burn)
+    | (Burn, false) => addNonLogDataReceiptType(contractName, Burn)
+    | (Transfer, true) => {
         addNonLogDataWildcardReceiptTypes(Transfer)
         addNonLogDataWildcardReceiptTypes(TransferOut)
       }
-    | {kind: Transfer} => {
+    | (Transfer, false) => {
         addNonLogDataReceiptType(contractName, Transfer)
         addNonLogDataReceiptType(contractName, TransferOut)
       }
-    | {kind: Call, isWildcard: true} => addNonLogDataWildcardReceiptTypes(Call)
-    | {kind: Call} =>
+    | (Call, true) => addNonLogDataWildcardReceiptTypes(Call)
+    | (Call, false) =>
       JsError.throwWithMessage("Call receipt indexing currently supported only in wildcard mode")
-    | {kind: LogData({logId}), isWildcard} => {
+    | (LogData({logId}), _) => {
         let rb = logId->BigInt.fromStringOrThrow
         if isWildcard {
           wildcardLogDataRbs->Array.push(rb)->ignore
@@ -239,6 +240,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     ~knownHeight,
     ~partitionId as _,
     ~selection: FetchState.selection,
+    ~itemsTarget as _,
     ~retry,
     ~logger,
   ) => {
@@ -250,11 +252,6 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     let startFetchingBatchTimeRef = Performance.now()
 
     //fetch batch
-    Prometheus.SourceRequestCount.increment(
-      ~sourceName=name,
-      ~chainId=chain->ChainMap.Chain.toChainId,
-      ~method="getLogs",
-    )
     let pageUnsafe = try await HyperFuel.GetLogs.query(
       ~client,
       ~fromBlock,
@@ -306,6 +303,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     }
 
     let pageFetchTime = startFetchingBatchTimeRef->Performance.secondsSince
+    let requestStats = [{Source.method: "getLogs", seconds: pageFetchTime}]
 
     //set height and next from block
     let knownHeight = pageUnsafe.archiveHeight
@@ -330,7 +328,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       | Call(_) => callEventTag
       }
 
-      let eventConfig = switch selectionConfig.eventRouter->EventRouter.get(
+      let onEventRegistration = switch selectionConfig.eventRouter->EventRouter.get(
         ~tag=eventId,
         ~contractNameByAddress,
         ~contractAddress,
@@ -351,9 +349,14 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
             ~logger,
           )
         }
-      | Some(eventConfig) => eventConfig
+      | Some(onEventRegistration) => onEventRegistration
       }
 
+      let eventConfig =
+        onEventRegistration.eventConfig->(
+          Utils.magic: Internal.eventConfig => Internal.fuelEventConfig
+        )
+
       let params = switch (eventConfig, receipt) {
       | ({kind: LogData({decode})}, LogData({data})) =>
         try decode(data) catch {
@@ -407,11 +410,9 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       }
 
       Internal.Event({
-        eventConfig: (eventConfig :> Internal.eventConfig),
-        timestamp: block.time,
+        onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
         chain,
         blockNumber: block.height,
-        blockHash: block.id,
         logIndex: receiptIndex,
         // Fuel carries the transaction inline on the payload; the store key is
         // unused (Fuel identifies transactions by hash, kept on the payload).
@@ -458,13 +459,15 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     {
       latestFetchedBlockTimestamp,
       parsedQueueItems,
-      // Fuel keeps transaction on the payload; no store page.
+      // Fuel keeps transaction and block on the payload; no store pages.
       transactionStore: None,
+      blockStore: None,
       latestFetchedBlockNumber: heighestBlockQueried,
       stats,
       knownHeight,
       blockHashes,
       fromBlockQueried: fromBlock,
+      requestStats,
     }
   }
 
@@ -492,18 +495,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
         }
       }
       let seconds = timerRef->Performance.secondsSince
-      Prometheus.SourceRequestCount.increment(
-        ~sourceName=name,
-        ~chainId=chain->ChainMap.Chain.toChainId,
-        ~method="getHeight",
-      )
-      Prometheus.SourceRequestCount.addSeconds(
-        ~sourceName=name,
-        ~chainId=chain->ChainMap.Chain.toChainId,
-        ~method="getHeight",
-        ~seconds,
-      )
-      height
+      {height, requestStats: [{method: "getHeight", seconds}]}
     },
     getItemsOrThrow,
   }