envio 3.3.0-alpha.4 → 3.3.0-alpha.6

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.4",
+  "version": "3.3.0-alpha.6",
   "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.4",
-    "envio-linux-x64-musl": "3.3.0-alpha.4",
-    "envio-linux-arm64": "3.3.0-alpha.4",
-    "envio-darwin-x64": "3.3.0-alpha.4",
-    "envio-darwin-arm64": "3.3.0-alpha.4"
+    "envio-linux-x64": "3.3.0-alpha.6",
+    "envio-linux-x64-musl": "3.3.0-alpha.6",
+    "envio-linux-arm64": "3.3.0-alpha.6",
+    "envio-darwin-x64": "3.3.0-alpha.6",
+    "envio-darwin-arm64": "3.3.0-alpha.6"
   }
 }

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/BatchProcessing.res

@@ -127,6 +127,11 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
     | Ok() =>
       state->IndexerState.recordProcessedBatch
 
+      switch state->IndexerState.simulateDeadInputTracker {
+      | Some(tracker) => tracker->SimulateDeadInputTracker.recordProcessed(~batch)
+      | None => ()
+      }
+
       if state->IndexerState.isResolvingReorg {
         // A reorg landed while this batch was processing. Apply its progress so
         // the rollback diff is computed against up-to-date chain progress, but

package/src/BatchProcessing.res.mjs

@@ -10,8 +10,10 @@ import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as ExitOnCaughtUp from "./ExitOnCaughtUp.res.mjs";
 import * as EventProcessing from "./EventProcessing.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as PruneStaleHistory from "./PruneStaleHistory.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
 function yieldTick() {
   return new Promise((resolve, param) => {
@@ -55,6 +57,10 @@ async function processNextBatch(state, scheduleFetch) {
     return IndexerState.errorExit(state, errHandler._0);
   }
   IndexerState.recordProcessedBatch(state);
+  let tracker = IndexerState.simulateDeadInputTracker(state);
+  if (tracker !== undefined) {
+    SimulateDeadInputTracker.recordProcessed(Primitive_option.valFromOption(tracker), batch);
+  }
   if (IndexerState.isResolvingReorg(state)) {
     return IndexerState.applyBatchProgress(state, batch);
   }

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,
@@ -58,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,
@@ -65,10 +69,12 @@ let make = (
   ~numEventsProcessed=0.,
   ~timestampCaughtUpToHeadOrEndblock=None,
   ~isProgressAtHead=false,
+  ~transactionStore=TransactionStore.make(~ecosystem=Ecosystem.Evm, ~shouldChecksum=false),
   ~logger: Pino.t,
 ): t => {
   logger,
   fetchState,
+  indexingAddresses,
   sourceManager,
   chainConfig,
   isProgressAtHead,
@@ -78,7 +84,7 @@ let make = (
   pendingBudget: 0.,
   reorgDetection,
   safeCheckpointTracking,
-  transactionStore: TransactionStore.make(),
+  transactionStore,
 }
 
 let makeInternal = (
@@ -216,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,
@@ -261,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(
@@ -310,6 +322,7 @@ let makeInternal = (
   make(
     ~chainConfig,
     ~fetchState,
+    ~indexingAddresses=indexingAddressIndex,
     ~sourceManager=SourceManager.make(~sources, ~isRealtime, ~reducedPollingInterval?),
     ~reorgDetection=ReorgDetection.make(
       ~chainReorgCheckpoints,
@@ -324,6 +337,10 @@ let makeInternal = (
     ~committedProgressBlockNumber=progressBlockNumber,
     ~timestampCaughtUpToHeadOrEndblock,
     ~numEventsProcessed,
+    ~transactionStore=TransactionStore.make(
+      ~ecosystem=config.ecosystem.name,
+      ~shouldChecksum=!lowercaseAddresses,
+    ),
     ~logger,
   )
 }
@@ -413,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
@@ -527,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.
@@ -602,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.
@@ -761,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
@@ -772,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,14 +39,16 @@ function configAddresses(chainConfig) {
   return addresses;
 }
 
-function make(chainConfig, fetchState, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, 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 transactionStore = transactionStoreOpt !== undefined ? Primitive_option.valFromOption(transactionStoreOpt) : TransactionStore.make("evm", false);
   return {
     logger: logger,
     fetchState: fetchState,
+    indexingAddresses: indexingAddresses,
     sourceManager: sourceManager,
     chainConfig: chainConfig,
     isProgressAtHead: isProgressAtHead,
@@ -55,7 +58,7 @@ function make(chainConfig, fetchState, sourceManager, reorgDetection, committedP
     pendingBudget: 0,
     reorgDetection: reorgDetection,
     safeCheckpointTracking: safeCheckpointTracking,
-    transactionStore: TransactionStore.make()
+    transactionStore: transactionStore
   };
 }
 
@@ -118,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;
@@ -138,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);
@@ -174,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, 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) {
@@ -238,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) {
@@ -339,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);
 }
 
@@ -374,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,
@@ -393,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,
@@ -407,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) {
@@ -432,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)
   };
 }
 
@@ -455,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;
   }
 }
@@ -487,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,
@@ -523,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;
@@ -545,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;
@@ -568,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,6 +16,7 @@ let make: (
   ~numEventsProcessed: float=?,
   ~timestampCaughtUpToHeadOrEndblock: option<Date.t>=?,
   ~isProgressAtHead: bool=?,
+  ~transactionStore: TransactionStore.t=?,
   ~logger: Pino.t,
 ) => t
 
@@ -51,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

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/ExitOnCaughtUp.res

@@ -4,7 +4,15 @@ let run = async (state: IndexerState.t) => {
   ChainMetadata.stage(state)
   await state->Writing.flush
   if !(state->IndexerState.isStopped) && !(state->IndexerState.isResolvingReorg) {
-    Logging.info("Exiting with success")
-    NodeJs.process->NodeJs.exitWithCode(Success)
+    // A simulate run fails here when a provided item never reached a handler —
+    // dead test code. The tracker is None (a no-op) off the simulate path.
+    switch state
+    ->IndexerState.simulateDeadInputTracker
+    ->Option.flatMap(SimulateDeadInputTracker.failureMessage) {
+    | None =>
+      Logging.info("Exiting with success")
+      NodeJs.process->NodeJs.exitWithCode(Success)
+    | Some(message) => state->IndexerState.errorExit(ErrorHandling.make(Utils.Error.make(message)))
+    }
   }
 }

package/src/ExitOnCaughtUp.res.mjs

@@ -5,11 +5,20 @@ import * as Writing from "./Writing.res.mjs";
 import * as Process from "process";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ChainMetadata from "./ChainMetadata.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
 async function run(state) {
   ChainMetadata.stage(state);
   await Writing.flush(state);
-  if (!IndexerState.isStopped(state) && !IndexerState.isResolvingReorg(state)) {
+  if (IndexerState.isStopped(state) || IndexerState.isResolvingReorg(state)) {
+    return;
+  }
+  let message = Stdlib_Option.flatMap(IndexerState.simulateDeadInputTracker(state), SimulateDeadInputTracker.failureMessage);
+  if (message !== undefined) {
+    return IndexerState.errorExit(state, ErrorHandling.make(new Error(message), undefined, undefined));
+  } else {
     Logging.info("Exiting with success");
     Process.exit(0);
     return;