envio 3.3.0-alpha.3 → 3.3.0-alpha.5

package/evm.schema.json

@@ -548,6 +548,16 @@
             "null"
           ]
         },
+        "headers": {
+          "description": "Optional HTTP headers sent with every request to this RPC endpoint, e.g. an Authorization bearer token for gated endpoints. Values support ${ENV_VAR} interpolation.",
+          "type": [
+            "object",
+            "null"
+          ],
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
         "initial_block_interval": {
           "description": "The starting interval in range of blocks per query",
           "type": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.3.0-alpha.3",
+  "version": "3.3.0-alpha.5",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -57,7 +57,7 @@
     "yargs": "17.7.2",
     "@rescript/runtime": "12.2.0",
     "rescript-schema": "9.5.1",
-    "viem": "2.46.2",
+    "viem": "2.54.0",
     "dotenv": "16.4.5",
     "date-fns": "3.3.1",
     "@rescript/react": "0.14.1",
@@ -69,10 +69,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.3.0-alpha.3",
-    "envio-linux-x64-musl": "3.3.0-alpha.3",
-    "envio-linux-arm64": "3.3.0-alpha.3",
-    "envio-darwin-x64": "3.3.0-alpha.3",
-    "envio-darwin-arm64": "3.3.0-alpha.3"
+    "envio-linux-x64": "3.3.0-alpha.5",
+    "envio-linux-x64-musl": "3.3.0-alpha.5",
+    "envio-linux-arm64": "3.3.0-alpha.5",
+    "envio-darwin-x64": "3.3.0-alpha.5",
+    "envio-darwin-arm64": "3.3.0-alpha.5"
   }
 }

package/src/Batch.res.mjs

@@ -27,7 +27,7 @@ function getProgressedChainsById(chainsBeforeBatch, batchSizePerChain, progressB
     let progressedChain;
     if (batchSize !== undefined) {
       let leftItems = fetchState.buffer.slice(batchSize);
-      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, undefined, leftItems, undefined, undefined), batchSize);
+      progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, leftItems, undefined, undefined), batchSize);
     } else {
       progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, chainBeforeBatch.fetchState, 0);
     }

package/src/Bin.res

@@ -71,6 +71,9 @@ let run = async args => {
       }
     }
   } catch {
+  | Main.FatalError(_) =>
+    // Already logged with full context by Main.start's onError; just exit.
+    NodeJs.process->NodeJs.exitWithCode(Failure)
   | exn =>
     // Log just the exception's own message — wrapping it in "Failed at
     // initialization" and pino's err serializer buries the real cause under

package/src/Bin.res.mjs

@@ -79,6 +79,10 @@ async function run(args) {
     }
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
+    if (exn.RE_EXN_ID === Main.FatalError) {
+      Process.exit(1);
+      return;
+    }
     let e = Primitive_exceptions.internalToException(exn);
     let message = e.RE_EXN_ID === "JsExn" ? Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "Failed at initialization") : "Failed at initialization";
     Logging.error(message);

package/src/ChainFetching.res

@@ -11,13 +11,12 @@ type partitionQueryResponse = {
 let runContractRegistersOrThrow = async (
   ~itemsWithContractRegister: array<Internal.item>,
   ~config: Config.t,
-  ~chainState: ChainState.t,
   ~page: option<TransactionStore.t>,
 ) => {
   // contractRegister handlers can read event.transaction, so materialise the
   // selected fields onto the payloads before running them. All items belong to
   // the chain being fetched, hence its single page store and mask.
-  await chainState->ChainState.materializePageItems(~items=itemsWithContractRegister, ~page)
+  await ChainState.materializePageItems(~items=itemsWithContractRegister, ~page)
 
   let itemsWithDcs = []
 
@@ -233,7 +232,6 @@ let rec onQueryResponse = async (
         switch await runContractRegistersOrThrow(
           ~itemsWithContractRegister,
           ~config=state->IndexerState.config,
-          ~chainState,
           ~page=transactionStore,
         ) {
         | exception exn => IndexerState.errorExit(state, exn->ErrorHandling.make)

package/src/ChainFetching.res.mjs

@@ -16,8 +16,8 @@ import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as ContractRegisterContext from "./ContractRegisterContext.res.mjs";
 
-async function runContractRegistersOrThrow(itemsWithContractRegister, config, chainState, page) {
-  await ChainState.materializePageItems(chainState, itemsWithContractRegister, page);
+async function runContractRegistersOrThrow(itemsWithContractRegister, config, page) {
+  await ChainState.materializePageItems(itemsWithContractRegister, page);
   let itemsWithDcs = [];
   let onRegister = (item, contractAddress, contractName) => {
     let dc_registrationBlock = item.blockNumber;
@@ -145,7 +145,7 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   }
   let newItemsWithDcs;
   try {
-    newItemsWithDcs = await runContractRegistersOrThrow(itemsWithContractRegister, IndexerState.config(state), chainState, transactionStore);
+    newItemsWithDcs = await runContractRegistersOrThrow(itemsWithContractRegister, IndexerState.config(state), transactionStore);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, undefined));

package/src/ChainState.res

@@ -5,6 +5,9 @@
 type t = {
   logger: Pino.t,
   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,
   sourceManager: SourceManager.t,
   chainConfig: Config.chain,
   mutable isProgressAtHead: bool,
@@ -21,8 +24,6 @@ type t = {
   // transactionIndex). Fetch responses merge their page in; entries are pruned
   // as the chain progresses and dropped above the target on rollback.
   transactionStore: TransactionStore.t,
-  // Bitmask of the transaction fields the store materialises at batch prep.
-  transactionFieldMask: float,
 }
 
 // Per-chain shape returned by the status API.
@@ -60,6 +61,7 @@ let configAddresses = (chainConfig: Config.chain): array<Internal.indexingAddres
 let make = (
   ~chainConfig: Config.chain,
   ~fetchState: FetchState.t,
+  ~indexingAddresses: IndexingAddresses.t,
   ~sourceManager: SourceManager.t,
   ~reorgDetection: ReorgDetection.t,
   ~committedProgressBlockNumber: int,
@@ -67,11 +69,12 @@ let make = (
   ~numEventsProcessed=0.,
   ~timestampCaughtUpToHeadOrEndblock=None,
   ~isProgressAtHead=false,
-  ~transactionFieldMask=0.,
+  ~transactionStore=TransactionStore.make(~ecosystem=Ecosystem.Evm, ~shouldChecksum=false),
   ~logger: Pino.t,
 ): t => {
   logger,
   fetchState,
+  indexingAddresses,
   sourceManager,
   chainConfig,
   isProgressAtHead,
@@ -81,8 +84,7 @@ let make = (
   pendingBudget: 0.,
   reorgDetection,
   safeCheckpointTracking,
-  transactionStore: TransactionStore.make(),
-  transactionFieldMask,
+  transactionStore,
 }
 
 let makeInternal = (
@@ -220,8 +222,12 @@ let makeInternal = (
   | None => ()
   }
 
+  let contractConfigs = IndexingAddresses.makeContractConfigs(~eventConfigs)
+  let indexingAddressIndex = IndexingAddresses.make(~contractConfigs, ~addresses=indexingAddresses)
+
   let fetchState = FetchState.make(
     ~maxAddrInPartition=config.maxAddrInPartition,
+    ~contractConfigs,
     ~addresses=indexingAddresses,
     ~progressBlockNumber,
     ~startBlock,
@@ -265,11 +271,13 @@ let makeInternal = (
     let evmRpcs: array<EvmChain.rpc> = rpcs->Array.map((rpc): EvmChain.rpc => {
       let syncConfig = rpc.syncConfig
       let ws = rpc.ws
+      let headers = rpc.headers
       {
         url: rpc.url,
         sourceFor: rpc.sourceFor,
         ?syncConfig,
         ?ws,
+        ?headers,
       }
     })
     EvmChain.makeSources(
@@ -314,6 +322,7 @@ let makeInternal = (
   make(
     ~chainConfig,
     ~fetchState,
+    ~indexingAddresses=indexingAddressIndex,
     ~sourceManager=SourceManager.make(~sources, ~isRealtime, ~reducedPollingInterval?),
     ~reorgDetection=ReorgDetection.make(
       ~chainReorgCheckpoints,
@@ -328,7 +337,10 @@ let makeInternal = (
     ~committedProgressBlockNumber=progressBlockNumber,
     ~timestampCaughtUpToHeadOrEndblock,
     ~numEventsProcessed,
-    ~transactionFieldMask=config.ecosystem.transactionFieldMask(eventConfigs),
+    ~transactionStore=TransactionStore.make(
+      ~ecosystem=config.ecosystem.name,
+      ~shouldChecksum=!lowercaseAddresses,
+    ),
     ~logger,
   )
 }
@@ -418,7 +430,8 @@ let timestampCaughtUpToHeadOrEndblock = (cs: t) => cs.timestampCaughtUpToHeadOrE
 // Fetch-frontier reads. The FetchState is owned here; callers go through these
 // rather than reaching into it.
 let knownHeight = (cs: t) => cs.fetchState.knownHeight
-let indexingAddresses = (cs: t) => cs.fetchState.indexingAddresses
+let contractAddresses = (cs: t, ~contractName) =>
+  cs.indexingAddresses->IndexingAddresses.getContractAddresses(~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
@@ -503,18 +516,14 @@ let isAtHeadWithoutEndBlock = (cs: t) =>
 // Materialise the chain store's selected transaction fields onto a batch's
 // items at batch prep (the persistent-store path).
 let materializeBatchItems = (cs: t, ~items: array<Internal.item>) =>
-  cs.transactionStore->TransactionStore.materializeItems(~items, ~mask=cs.transactionFieldMask)
+  cs.transactionStore->TransactionStore.materializeItems(~items)
 
 // Materialise a fetch-response page's transactions onto its items before
 // contract-register handlers read them. `None` pages (RPC/Fuel/Simulate keep the
 // transaction inline) are a no-op.
-let materializePageItems = (
-  cs: t,
-  ~items: array<Internal.item>,
-  ~page: option<TransactionStore.t>,
-) =>
+let materializePageItems = (~items: array<Internal.item>, ~page: option<TransactionStore.t>) =>
   switch page {
-  | Some(store) => store->TransactionStore.materializeItems(~items, ~mask=cs.transactionFieldMask)
+  | Some(store) => store->TransactionStore.materializeItems(~items)
   | None => Promise.resolve()
   }
 
@@ -536,12 +545,21 @@ let handleQueryResult = (
 
   let fs = switch newItemsWithDcs {
   | [] => cs.fetchState
-  | _ => cs.fetchState->FetchState.registerDynamicContracts(newItemsWithDcs)
+  | _ =>
+    cs.fetchState->FetchState.registerDynamicContracts(
+      ~indexingAddresses=cs.indexingAddresses,
+      newItemsWithDcs,
+    )
   }
 
   cs.fetchState =
     fs
-    ->FetchState.handleQueryResult(~query, ~latestFetchedBlock, ~newItems)
+    ->FetchState.handleQueryResult(
+      ~indexingAddresses=cs.indexingAddresses,
+      ~query,
+      ~latestFetchedBlock,
+      ~newItems,
+    )
     ->FetchState.updateKnownHeight(~knownHeight)
 
   // The query is no longer in flight, so release its reservation.
@@ -611,7 +629,7 @@ let toChainData = (cs: t): chainData => {
   numBatchesFetched: 0,
   startBlock: cs.fetchState.startBlock,
   endBlock: cs.fetchState.endBlock,
-  numAddresses: cs.fetchState->FetchState.numAddresses,
+  numAddresses: cs.indexingAddresses->IndexingAddresses.size,
 }
 
 // Snapshot the inputs a batch build needs from this chain.
@@ -770,7 +788,11 @@ let rollback = (
       )
     | None => ()
     }
-    cs.fetchState = cs.fetchState->FetchState.rollback(~targetBlockNumber=newProgressBlockNumber)
+    cs.fetchState =
+      cs.fetchState->FetchState.rollback(
+        ~indexingAddresses=cs.indexingAddresses,
+        ~targetBlockNumber=newProgressBlockNumber,
+      )
     cs.transactionStore->TransactionStore.rollback(newProgressBlockNumber)
     cs.committedProgressBlockNumber = newProgressBlockNumber
     cs.numEventsProcessed = newTotalEventsProcessed
@@ -781,7 +803,10 @@ let rollback = (
           ~blockNumber=rollbackTargetBlockNumber,
         )
       cs.fetchState =
-        cs.fetchState->FetchState.rollback(~targetBlockNumber=rollbackTargetBlockNumber)
+        cs.fetchState->FetchState.rollback(
+          ~indexingAddresses=cs.indexingAddresses,
+          ~targetBlockNumber=rollbackTargetBlockNumber,
+        )
       cs.transactionStore->TransactionStore.rollback(rollbackTargetBlockNumber)
       cs.committedProgressBlockNumber = Pervasives.min(
         cs.committedProgressBlockNumber,

package/src/ChainState.res.mjs

@@ -21,6 +21,7 @@ import * as HyperFuelSource from "./sources/HyperFuelSource.res.mjs";
 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 SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
 
@@ -38,15 +39,16 @@ function configAddresses(chainConfig) {
   return addresses;
 }
 
-function make(chainConfig, fetchState, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionFieldMaskOpt, logger) {
+function make(chainConfig, fetchState, indexingAddresses, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionStoreOpt, logger) {
   let safeCheckpointTracking = safeCheckpointTrackingOpt !== undefined ? Primitive_option.valFromOption(safeCheckpointTrackingOpt) : undefined;
   let numEventsProcessed = numEventsProcessedOpt !== undefined ? numEventsProcessedOpt : 0;
   let timestampCaughtUpToHeadOrEndblock = timestampCaughtUpToHeadOrEndblockOpt !== undefined ? Primitive_option.valFromOption(timestampCaughtUpToHeadOrEndblockOpt) : undefined;
   let isProgressAtHead = isProgressAtHeadOpt !== undefined ? isProgressAtHeadOpt : false;
-  let transactionFieldMask = transactionFieldMaskOpt !== undefined ? transactionFieldMaskOpt : 0;
+  let transactionStore = transactionStoreOpt !== undefined ? Primitive_option.valFromOption(transactionStoreOpt) : TransactionStore.make("evm", false);
   return {
     logger: logger,
     fetchState: fetchState,
+    indexingAddresses: indexingAddresses,
     sourceManager: sourceManager,
     chainConfig: chainConfig,
     isProgressAtHead: isProgressAtHead,
@@ -56,8 +58,7 @@ function make(chainConfig, fetchState, sourceManager, reorgDetection, committedP
     pendingBudget: 0,
     reorgDetection: reorgDetection,
     safeCheckpointTracking: safeCheckpointTracking,
-    transactionStore: TransactionStore.make(),
-    transactionFieldMask: transactionFieldMask
+    transactionStore: transactionStore
   };
 }
 
@@ -120,7 +121,9 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
       }
     });
   }
-  let fetchState = FetchState.make(startBlock, endBlock, eventConfigs, indexingAddresses, config.maxAddrInPartition, chainConfig.id, (config.batchSize << 1), knownHeight, progressBlockNumber, onBlockConfigs, Primitive_int.max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth, chainConfig.blockLag), Primitive_option.some(firstEventBlock));
+  let contractConfigs = IndexingAddresses.makeContractConfigs(eventConfigs);
+  let indexingAddressIndex = IndexingAddresses.make(contractConfigs, indexingAddresses);
+  let fetchState = FetchState.make(startBlock, endBlock, eventConfigs, contractConfigs, indexingAddresses, config.maxAddrInPartition, chainConfig.id, (config.batchSize << 1), knownHeight, progressBlockNumber, onBlockConfigs, Primitive_int.max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth, chainConfig.blockLag), Primitive_option.some(firstEventBlock));
   let chainReorgCheckpoints = Stdlib_Array.filterMap(reorgCheckpoints, reorgCheckpoint => {
     if (reorgCheckpoint.chain_id === chainConfig.id) {
       return reorgCheckpoint;
@@ -140,11 +143,13 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
       let evmRpcs = sources.rpcs.map(rpc => {
         let syncConfig = rpc.syncConfig;
         let ws = rpc.ws;
+        let headers = rpc.headers;
         return {
           url: rpc.url,
           sourceFor: rpc.sourceFor,
           syncConfig: syncConfig,
-          ws: ws
+          ws: ws,
+          headers: headers
         };
       });
       sources$1 = EvmChain.makeSources(chain, evmContracts, sources.hypersync, evmRpcs, lowercaseAddresses);
@@ -176,7 +181,7 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
       sources$1 = sources._0;
       break;
   }
-  return make(chainConfig, fetchState, 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, config.ecosystem.transactionFieldMask(eventConfigs), logger);
+  return make(chainConfig, fetchState, 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)), logger);
 }
 
 function makeFromConfig(chainConfig, config, registrations, knownHeight) {
@@ -240,8 +245,8 @@ function knownHeight(cs) {
   return cs.fetchState.knownHeight;
 }
 
-function indexingAddresses(cs) {
-  return cs.fetchState.indexingAddresses;
+function contractAddresses(cs, contractName) {
+  return IndexingAddresses.getContractAddresses(cs.indexingAddresses, contractName);
 }
 
 function bufferSize(cs) {
@@ -326,12 +331,12 @@ function isAtHeadWithoutEndBlock(cs) {
 }
 
 function materializeBatchItems(cs, items) {
-  return TransactionStore.materializeItems(cs.transactionStore, items, cs.transactionFieldMask);
+  return TransactionStore.materializeItems(cs.transactionStore, items);
 }
 
-function materializePageItems(cs, items, page) {
+function materializePageItems(items, page) {
   if (page !== undefined) {
-    return TransactionStore.materializeItems(Primitive_option.valFromOption(page), items, cs.transactionFieldMask);
+    return TransactionStore.materializeItems(Primitive_option.valFromOption(page), items);
   } else {
     return Promise.resolve();
   }
@@ -341,8 +346,8 @@ function handleQueryResult(cs, query, newItems, newItemsWithDcs, latestFetchedBl
   if (page !== undefined) {
     cs.transactionStore.merge(Primitive_option.valFromOption(page));
   }
-  let fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, newItemsWithDcs) : cs.fetchState;
-  cs.fetchState = FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight);
+  let fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, cs.indexingAddresses, newItemsWithDcs) : cs.fetchState;
+  cs.fetchState = FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, cs.indexingAddresses, query, latestFetchedBlock, newItems), knownHeight);
   cs.pendingBudget = Primitive_float.max(0, cs.pendingBudget - query.estResponseSize);
 }
 
@@ -376,7 +381,6 @@ function setEndBlockToFirstEvent(cs, blockNumber) {
       startBlock: init.startBlock,
       endBlock: blockNumber,
       normalSelection: init.normalSelection,
-      indexingAddresses: init.indexingAddresses,
       contractConfigs: init.contractConfigs,
       chainId: init.chainId,
       latestOnBlockBlockNumber: init.latestOnBlockBlockNumber,
@@ -395,7 +399,6 @@ function setEndBlockToFirstEvent(cs, blockNumber) {
     startBlock: init$1.startBlock,
     endBlock: blockNumber,
     normalSelection: init$1.normalSelection,
-    indexingAddresses: init$1.indexingAddresses,
     contractConfigs: init$1.contractConfigs,
     chainId: init$1.chainId,
     latestOnBlockBlockNumber: init$1.latestOnBlockBlockNumber,
@@ -409,7 +412,7 @@ function setEndBlockToFirstEvent(cs, blockNumber) {
 }
 
 function enterReorgThreshold(cs) {
-  cs.fetchState = FetchState.updateInternal(cs.fetchState, undefined, undefined, undefined, cs.chainConfig.blockLag, undefined);
+  cs.fetchState = FetchState.updateInternal(cs.fetchState, undefined, undefined, cs.chainConfig.blockLag, undefined);
 }
 
 function toChainMetadata(cs) {
@@ -434,7 +437,7 @@ function toChainData(cs) {
     numBatchesFetched: 0,
     startBlock: cs.fetchState.startBlock,
     endBlock: cs.fetchState.endBlock,
-    numAddresses: FetchState.numAddresses(cs.fetchState)
+    numAddresses: IndexingAddresses.size(cs.indexingAddresses)
   };
 }
 
@@ -457,7 +460,7 @@ function isReadyToEnterReorgThresholdAfterBatch(cs, batch) {
 function advanceAfterBatch(cs, batch, enteringReorgThreshold) {
   let chainAfterBatch = batch.progressedChainsById[cs.fetchState.chainId];
   if (chainAfterBatch !== undefined) {
-    cs.fetchState = enteringReorgThreshold ? FetchState.updateInternal(chainAfterBatch.fetchState, undefined, undefined, undefined, cs.chainConfig.blockLag, undefined) : chainAfterBatch.fetchState;
+    cs.fetchState = enteringReorgThreshold ? FetchState.updateInternal(chainAfterBatch.fetchState, undefined, undefined, cs.chainConfig.blockLag, undefined) : chainAfterBatch.fetchState;
     return;
   }
 }
@@ -489,7 +492,6 @@ function applyBatchProgress(cs, batch) {
         startBlock: init.startBlock,
         endBlock: init.endBlock,
         normalSelection: init.normalSelection,
-        indexingAddresses: init.indexingAddresses,
         contractConfigs: init.contractConfigs,
         chainId: init.chainId,
         latestOnBlockBlockNumber: init.latestOnBlockBlockNumber,
@@ -525,7 +527,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, rollbackTargetBlockNumber);
+      cs.fetchState = FetchState.rollback(cs.fetchState, cs.indexingAddresses, rollbackTargetBlockNumber);
       cs.transactionStore.rollback(rollbackTargetBlockNumber);
       cs.committedProgressBlockNumber = Primitive_int.min(cs.committedProgressBlockNumber, rollbackTargetBlockNumber);
       return;
@@ -547,7 +549,7 @@ function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTarge
   if (safeCheckpointTracking !== undefined) {
     cs.safeCheckpointTracking = SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber);
   }
-  cs.fetchState = FetchState.rollback(cs.fetchState, newProgressBlockNumber);
+  cs.fetchState = FetchState.rollback(cs.fetchState, cs.indexingAddresses, newProgressBlockNumber);
   cs.transactionStore.rollback(newProgressBlockNumber);
   cs.committedProgressBlockNumber = newProgressBlockNumber;
   cs.numEventsProcessed = newTotalEventsProcessed;
@@ -570,7 +572,7 @@ export {
   startFetchingQueries,
   timestampCaughtUpToHeadOrEndblock,
   knownHeight,
-  indexingAddresses,
+  contractAddresses,
   bufferSize,
   bufferReadyCount,
   getProgressPercentage,

package/src/ChainState.resi

@@ -8,6 +8,7 @@ let configAddresses: Config.chain => array<Internal.indexingAddress>
 let make: (
   ~chainConfig: Config.chain,
   ~fetchState: FetchState.t,
+  ~indexingAddresses: IndexingAddresses.t,
   ~sourceManager: SourceManager.t,
   ~reorgDetection: ReorgDetection.t,
   ~committedProgressBlockNumber: int,
@@ -15,7 +16,7 @@ let make: (
   ~numEventsProcessed: float=?,
   ~timestampCaughtUpToHeadOrEndblock: option<Date.t>=?,
   ~isProgressAtHead: bool=?,
-  ~transactionFieldMask: float=?,
+  ~transactionStore: TransactionStore.t=?,
   ~logger: Pino.t,
 ) => t
 
@@ -52,7 +53,7 @@ let timestampCaughtUpToHeadOrEndblock: t => option<Date.t>
 
 // Fetch-frontier reads.
 let knownHeight: t => int
-let indexingAddresses: t => dict<FetchState.indexingAddress>
+let contractAddresses: (t, ~contractName: string) => array<Address.t>
 let bufferSize: t => int
 let bufferReadyCount: t => int
 let getProgressPercentage: t => float
@@ -112,7 +113,6 @@ let handleQueryResult: (
 ) => unit
 let materializeBatchItems: (t, ~items: array<Internal.item>) => promise<unit>
 let materializePageItems: (
-  t,
   ~items: array<Internal.item>,
   ~page: option<TransactionStore.t>,
 ) => promise<unit>

package/src/Config.res

@@ -23,6 +23,7 @@ type evmRpcConfig = {
   sourceFor: Source.sourceFor,
   syncConfig: option<sourceSyncOptions>,
   ws: option<string>,
+  headers: option<dict<string>>,
 }
 
 type sourceConfig =
@@ -156,6 +157,7 @@ let rpcConfigSchema = S.schema(s =>
     "url": s.matches(S.string),
     "for": s.matches(rpcSourceForSchema),
     "ws": s.matches(S.option(S.string)),
+    "headers": s.matches(S.option(S.dict(S.string))),
     "initialBlockInterval": s.matches(S.option(S.int)),
     "backoffMultiplicative": s.matches(S.option(S.float)),
     "accelerationAdditive": s.matches(S.option(S.int)),
@@ -907,6 +909,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
               sourceFor: parseRpcSourceFor(rpcConfig["for"]),
               syncConfig,
               ws: rpcConfig["ws"],
+              headers: rpcConfig["headers"],
             }
           })
         EvmSourceConfig({hypersync: publicChainConfig["hypersync"], rpcs})

package/src/Config.res.mjs

@@ -81,6 +81,7 @@ let rpcConfigSchema = S$RescriptSchema.schema(s => ({
   url: s.m(S$RescriptSchema.string),
   for: s.m(rpcSourceForSchema),
   ws: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
+  headers: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(S$RescriptSchema.string))),
   initialBlockInterval: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
   backoffMultiplicative: s.m(S$RescriptSchema.option(S$RescriptSchema.float)),
   accelerationAdditive: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
@@ -606,7 +607,8 @@ function fromPublic(publicConfigJson) {
             url: rpcConfig.url,
             sourceFor: parseRpcSourceFor(rpcConfig.for),
             syncConfig: syncConfig,
-            ws: rpcConfig.ws
+            ws: rpcConfig.ws,
+            headers: rpcConfig.headers
           };
         });
         sourceConfig = {

package/src/Core.res

@@ -6,7 +6,6 @@
 // tighter `Null.t` captures the exact boundary shape.
 type evmHypersyncClientCtor
 type evmRpcClientCtor
-type evmDecoderCtor
 type svmHypersyncClientCtor
 type hyperfuelClientCtor
 type transactionStoreCtor
@@ -18,8 +17,6 @@ type addon = {
   evmHypersyncClient: evmHypersyncClientCtor,
   @as("EvmRpcClient")
   evmRpcClient: evmRpcClientCtor,
-  @as("EvmDecoder")
-  evmDecoder: evmDecoderCtor,
   @as("SvmHypersyncClient")
   svmHypersyncClient: svmHypersyncClientCtor,
   @as("HyperfuelClient")

package/src/Ecosystem.res

@@ -34,10 +34,6 @@ type t = {
       registration from an item's opaque payload. `event.transaction` is written
       onto the payload at batch prep (HyperSync) or inline (RPC/simulate). */
   toEvent: Internal.eventItem => Internal.event,
-  /** Bitmask (as a float) of the transaction fields selected across the chain's
-      events — the set the store materialises at batch prep. `0.` when the
-      ecosystem carries transactions inline. */
-  transactionFieldMask: array<Internal.eventConfig> => float,
   /** Build the per-item child logger for an event item, with
       ecosystem-specific log fields (EVM/Fuel: contract/event/address; SVM:
       program/instruction/programId). Closes over the injected logger. */

package/src/EventConfigBuilder.res

@@ -442,6 +442,7 @@ let buildEvmEventConfig = (
     startBlock: resolvedStartBlock,
     selectedBlockFields,
     selectedTransactionFields,
+    transactionFieldMask: Evm.eventTransactionFieldMask(selectedTransactionFields),
     sighash,
     topicCount,
     paramsMetadata: params,
@@ -500,6 +501,7 @@ let buildSvmInstructionEventConfig = (
     discriminatorByteLen,
     includeLogs,
     selectedTransactionFields,
+    transactionFieldMask: Svm.eventTransactionFieldMask(selectedTransactionFields),
     accountFilters,
     isInner,
     accounts,
@@ -568,6 +570,7 @@ let buildFuelEventConfig = (
     startBlock,
     // Fuel keeps the transaction inline on the payload; nothing to materialise.
     selectedTransactionFields: Utils.Set.make(),
+    transactionFieldMask: 0.,
     kind: fuelKind,
   }
 }