envio 3.2.0 → 3.3.0-alpha.0

package/src/ChainState.res.mjs

@@ -0,0 +1,461 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "./Env.res.mjs";
+import * as Svm from "./sources/Svm.res.mjs";
+import * as Batch from "./Batch.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as EvmChain from "./sources/EvmChain.res.mjs";
+import * as FetchState from "./FetchState.res.mjs";
+import * as Prometheus from "./Prometheus.res.mjs";
+import * as EventRouter from "./sources/EventRouter.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as SourceManager from "./sources/SourceManager.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as ReorgDetection from "./ReorgDetection.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as HyperFuelSource from "./sources/HyperFuelSource.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as SvmHyperSyncSource from "./sources/SvmHyperSyncSource.res.mjs";
+import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
+
+function configAddresses(chainConfig) {
+  let addresses = [];
+  chainConfig.contracts.forEach(contract => {
+    contract.addresses.forEach(address => {
+      addresses.push({
+        address: address,
+        contractName: contract.name,
+        registrationBlock: -1
+      });
+    });
+  });
+  return addresses;
+}
+
+function make(chainConfig, fetchState, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, 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;
+  return {
+    logger: logger,
+    fetchState: fetchState,
+    sourceManager: sourceManager,
+    chainConfig: chainConfig,
+    isProgressAtHead: isProgressAtHead,
+    timestampCaughtUpToHeadOrEndblock: timestampCaughtUpToHeadOrEndblock,
+    committedProgressBlockNumber: committedProgressBlockNumber,
+    numEventsProcessed: numEventsProcessed,
+    reorgDetection: reorgDetection,
+    safeCheckpointTracking: safeCheckpointTracking
+  };
+}
+
+function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBlockOpt, progressBlockNumber, config, registrations, logger, timestampCaughtUpToHeadOrEndblock, numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, maxReorgDepth, knownHeightOpt, reducedPollingInterval) {
+  let firstEventBlock = firstEventBlockOpt !== undefined ? Primitive_option.valFromOption(firstEventBlockOpt) : undefined;
+  let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : 0;
+  let eventRouter = EventRouter.empty();
+  let eventConfigs = [];
+  let notRegisteredEvents = [];
+  chainConfig.contracts.forEach(contract => {
+    let contractName = contract.name;
+    contract.events.forEach(eventConfig => {
+      let hasContractRegister = Stdlib_Option.isSome(eventConfig.contractRegister);
+      EventRouter.addOrThrow(eventRouter, eventConfig.id, undefined, contractName, eventConfig.isWildcard, eventConfig.name, ChainMap.Chain.makeUnsafe(chainConfig.id));
+      let shouldBeIncluded;
+      if (config.enableRawEvents) {
+        shouldBeIncluded = true;
+      } else {
+        let isRegistered = hasContractRegister || Stdlib_Option.isSome(eventConfig.handler);
+        if (!isRegistered) {
+          notRegisteredEvents.push(eventConfig);
+        }
+        shouldBeIncluded = isRegistered;
+      }
+      let shouldSkip;
+      try {
+        let getEventFiltersOrThrow = eventConfig.getEventFiltersOrThrow;
+        if (getEventFiltersOrThrow) {
+          let match = getEventFiltersOrThrow(ChainMap.Chain.makeUnsafe(chainConfig.id));
+          shouldSkip = match.TAG === "Static" ? match._0.length === 0 : false;
+        } else {
+          shouldSkip = false;
+        }
+      } catch (exn) {
+        shouldSkip = false;
+      }
+      if (shouldBeIncluded && !shouldSkip) {
+        eventConfigs.push(eventConfig);
+        return;
+      }
+    });
+    let startBlock = contract.startBlock;
+    if (startBlock !== undefined && startBlock < chainConfig.startBlock) {
+      return Stdlib_JsError.throwWithMessage(`The start block for contract "` + contractName + `" is less than the chain start block. This is not supported yet.`);
+    }
+  });
+  if (Utils.$$Array.notEmpty(notRegisteredEvents)) {
+    Logging.childInfo(logger, `The event` + (
+      notRegisteredEvents.length > 1 ? "s" : ""
+    ) + ` ` + notRegisteredEvents.map(eventConfig => eventConfig.contractName + `.` + eventConfig.name).join(", ") + ` don't have an event handler and skipped for indexing.`);
+  }
+  let onBlockConfigs = registrations.onBlockByChainId[chainConfig.id.toString()];
+  if (onBlockConfigs !== undefined) {
+    onBlockConfigs.forEach(onBlockConfig => {
+      if (Stdlib_Option.getOr(onBlockConfig.startBlock, startBlock) < startBlock) {
+        Stdlib_JsError.throwWithMessage(`The start block for onBlock handler "` + onBlockConfig.name + `" is less than the chain start block (` + startBlock.toString() + `). This is not supported yet.`);
+      }
+      if (endBlock !== undefined && Stdlib_Option.getOr(onBlockConfig.endBlock, endBlock) > endBlock) {
+        return Stdlib_JsError.throwWithMessage(`The end block for onBlock handler "` + onBlockConfig.name + `" is greater than the chain end block (` + endBlock.toString() + `). This is not supported yet.`);
+      }
+    });
+  }
+  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 chainReorgCheckpoints = Stdlib_Array.filterMap(reorgCheckpoints, reorgCheckpoint => {
+    if (reorgCheckpoint.chain_id === chainConfig.id) {
+      return reorgCheckpoint;
+    }
+  });
+  let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
+  let lowercaseAddresses = config.lowercaseAddresses;
+  let sources = chainConfig.sourceConfig;
+  let sources$1;
+  switch (sources.TAG) {
+    case "EvmSourceConfig" :
+      let evmContracts = chainConfig.contracts.map(contract => ({
+        name: contract.name,
+        abi: contract.abi,
+        events: contract.events
+      }));
+      let evmRpcs = sources.rpcs.map(rpc => {
+        let syncConfig = rpc.syncConfig;
+        let ws = rpc.ws;
+        return {
+          url: rpc.url,
+          sourceFor: rpc.sourceFor,
+          syncConfig: syncConfig,
+          ws: ws
+        };
+      });
+      sources$1 = EvmChain.makeSources(chain, evmContracts, sources.hypersync, evmRpcs, lowercaseAddresses);
+      break;
+    case "FuelSourceConfig" :
+      sources$1 = [HyperFuelSource.make({
+          chain: chain,
+          endpointUrl: sources.hypersync,
+          apiToken: Env.envioApiToken
+        })];
+      break;
+    case "SvmSourceConfig" :
+      let rpc = sources.rpc;
+      let hypersync = sources.hypersync;
+      if (hypersync !== undefined) {
+        let svmEventConfigs = chainConfig.contracts.flatMap(contract => contract.events);
+        sources$1 = [SvmHyperSyncSource.make({
+            chain: chain,
+            endpointUrl: hypersync,
+            apiToken: Env.envioApiToken,
+            eventConfigs: svmEventConfigs,
+            clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis
+          })];
+      } else {
+        sources$1 = rpc !== undefined ? [Svm.makeRPCSource(chain, rpc, undefined)] : Stdlib_JsError.throwWithMessage(`Chain ` + chain.toString() + ` has no SVM data source`);
+      }
+      break;
+    case "CustomSources" :
+      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);
+}
+
+function makeFromConfig(chainConfig, config, registrations, knownHeight) {
+  let logger = Logging.createChild({
+    chainId: chainConfig.id
+  });
+  return makeInternal(chainConfig, configAddresses(chainConfig), chainConfig.startBlock, chainConfig.endBlock, undefined, -1, config, registrations, logger, undefined, 0, false, false, [], chainConfig.maxReorgDepth, knownHeight, undefined);
+}
+
+function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrations, reducedPollingInterval) {
+  let chainId = chainConfig.id;
+  let logger = Logging.createChild({
+    chainId: chainId
+  });
+  Prometheus.ProgressEventsCount.set(resumedChainState.numEventsProcessed, chainId);
+  let progressBlockNumber = resumedChainState.progressBlockNumber >= 0 ? resumedChainState.progressBlockNumber : resumedChainState.startBlock - 1 | 0;
+  return makeInternal(chainConfig, resumedChainState.indexingAddresses, resumedChainState.startBlock, resumedChainState.endBlock, Primitive_option.some(resumedChainState.firstEventBlockNumber), progressBlockNumber, config, registrations, logger, Env.updateSyncTimeOnRestart ? undefined : resumedChainState.timestampCaughtUpToHeadOrEndblock, resumedChainState.numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, resumedChainState.maxReorgDepth, resumedChainState.sourceBlockNumber, reducedPollingInterval);
+}
+
+function logger(cs) {
+  return cs.logger;
+}
+
+function fetchState(cs) {
+  return cs.fetchState;
+}
+
+function sourceManager(cs) {
+  return cs.sourceManager;
+}
+
+function chainConfig(cs) {
+  return cs.chainConfig;
+}
+
+function reorgDetection(cs) {
+  return cs.reorgDetection;
+}
+
+function safeCheckpointTracking(cs) {
+  return cs.safeCheckpointTracking;
+}
+
+function isProgressAtHead(cs) {
+  return cs.isProgressAtHead;
+}
+
+function committedProgressBlockNumber(cs) {
+  return cs.committedProgressBlockNumber;
+}
+
+function numEventsProcessed(cs) {
+  return cs.numEventsProcessed;
+}
+
+function timestampCaughtUpToHeadOrEndblock(cs) {
+  return cs.timestampCaughtUpToHeadOrEndblock;
+}
+
+function hasProcessedToEndblock(cs) {
+  let fetchState = cs.fetchState;
+  let committedProgressBlockNumber = cs.committedProgressBlockNumber;
+  let endBlock = fetchState.endBlock;
+  if (endBlock !== undefined) {
+    return committedProgressBlockNumber >= endBlock;
+  } else {
+    return false;
+  }
+}
+
+function getHighestBlockBelowThreshold(cs) {
+  let highestBlockBelowThreshold = cs.fetchState.knownHeight - cs.chainConfig.maxReorgDepth | 0;
+  if (highestBlockBelowThreshold < 0) {
+    return 0;
+  } else {
+    return highestBlockBelowThreshold;
+  }
+}
+
+function isActivelyIndexing(cs) {
+  return FetchState.isActivelyIndexing(cs.fetchState);
+}
+
+function isReady(cs) {
+  return cs.timestampCaughtUpToHeadOrEndblock !== undefined;
+}
+
+function isFetchingAtHead(cs) {
+  return FetchState.isFetchingAtHead(cs.fetchState);
+}
+
+function handleQueryResult(cs, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight) {
+  let fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, newItemsWithDcs) : cs.fetchState;
+  cs.fetchState = FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight);
+}
+
+function registerReorgGuard(cs, blockHashes, knownHeight) {
+  let match = ReorgDetection.registerReorgGuard(cs.reorgDetection, blockHashes, knownHeight);
+  cs.reorgDetection = match[0];
+  return match[1];
+}
+
+function prepareReorg(cs, eventsProcessedDiff) {
+  if (eventsProcessedDiff !== undefined) {
+    cs.numEventsProcessed = cs.numEventsProcessed + eventsProcessedDiff;
+  }
+  cs.fetchState = FetchState.resetPendingQueries(cs.fetchState);
+}
+
+function updateKnownHeight(cs, knownHeight) {
+  cs.fetchState = FetchState.updateKnownHeight(cs.fetchState, knownHeight);
+}
+
+function setEndBlockToFirstEvent(cs, blockNumber) {
+  let currentEndBlock = cs.fetchState.endBlock;
+  if (currentEndBlock !== undefined) {
+    if (blockNumber >= currentEndBlock) {
+      return;
+    }
+    let init = cs.fetchState;
+    cs.fetchState = {
+      optimizedPartitions: init.optimizedPartitions,
+      startBlock: init.startBlock,
+      endBlock: blockNumber,
+      normalSelection: init.normalSelection,
+      indexingAddresses: init.indexingAddresses,
+      contractConfigs: init.contractConfigs,
+      chainId: init.chainId,
+      latestOnBlockBlockNumber: init.latestOnBlockBlockNumber,
+      blockLag: init.blockLag,
+      buffer: init.buffer,
+      maxOnBlockBufferSize: init.maxOnBlockBufferSize,
+      onBlockConfigs: init.onBlockConfigs,
+      knownHeight: init.knownHeight,
+      firstEventBlock: init.firstEventBlock
+    };
+    return;
+  }
+  let init$1 = cs.fetchState;
+  cs.fetchState = {
+    optimizedPartitions: init$1.optimizedPartitions,
+    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,
+    blockLag: init$1.blockLag,
+    buffer: init$1.buffer,
+    maxOnBlockBufferSize: init$1.maxOnBlockBufferSize,
+    onBlockConfigs: init$1.onBlockConfigs,
+    knownHeight: init$1.knownHeight,
+    firstEventBlock: init$1.firstEventBlock
+  };
+}
+
+function enterReorgThreshold(cs) {
+  cs.fetchState = FetchState.updateInternal(cs.fetchState, undefined, undefined, undefined, cs.chainConfig.blockLag, undefined);
+}
+
+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;
+    return;
+  }
+}
+
+function applyBatchProgress(cs, batch) {
+  let chainId = cs.chainConfig.id;
+  let chainAfterBatch = batch.progressedChainsById[chainId];
+  if (chainAfterBatch === undefined) {
+    return;
+  }
+  if (cs.committedProgressBlockNumber !== chainAfterBatch.progressBlockNumber) {
+    Prometheus.ProgressBlockNumber.set(chainAfterBatch.progressBlockNumber, chainId);
+  }
+  if (cs.numEventsProcessed !== chainAfterBatch.totalEventsProcessed) {
+    Prometheus.ProgressEventsCount.set(chainAfterBatch.totalEventsProcessed, chainId);
+  }
+  let eventItem = Batch.findLastEventItem(batch, chainId);
+  if (eventItem !== undefined) {
+    let blockTimestampMs = eventItem.timestamp * 1000 | 0;
+    Prometheus.ProgressLatency.set((Date.now() | 0) - blockTimestampMs | 0, chainId);
+  }
+  let match = cs.fetchState.firstEventBlock;
+  if (match === undefined) {
+    let firstEventBlock = Batch.findFirstEventBlockNumber(batch, chainId);
+    if (firstEventBlock !== undefined) {
+      let init = cs.fetchState;
+      cs.fetchState = {
+        optimizedPartitions: init.optimizedPartitions,
+        startBlock: init.startBlock,
+        endBlock: init.endBlock,
+        normalSelection: init.normalSelection,
+        indexingAddresses: init.indexingAddresses,
+        contractConfigs: init.contractConfigs,
+        chainId: init.chainId,
+        latestOnBlockBlockNumber: init.latestOnBlockBlockNumber,
+        blockLag: init.blockLag,
+        buffer: init.buffer,
+        maxOnBlockBufferSize: init.maxOnBlockBufferSize,
+        onBlockConfigs: init.onBlockConfigs,
+        knownHeight: init.knownHeight,
+        firstEventBlock: firstEventBlock
+      };
+    }
+  }
+  cs.committedProgressBlockNumber = chainAfterBatch.progressBlockNumber;
+  cs.numEventsProcessed = chainAfterBatch.totalEventsProcessed;
+  cs.isProgressAtHead = cs.isProgressAtHead || chainAfterBatch.isProgressAtHeadWhenBatchCreated;
+  let safeCheckpointTracking = cs.safeCheckpointTracking;
+  if (safeCheckpointTracking !== undefined) {
+    cs.safeCheckpointTracking = SafeCheckpointTracking.updateOnNewBatch(safeCheckpointTracking, cs.fetchState.knownHeight, chainId, batch.checkpointIds, batch.checkpointBlockNumbers, batch.checkpointChainIds);
+    return;
+  }
+}
+
+function markReady(cs) {
+  if (cs.timestampCaughtUpToHeadOrEndblock === undefined) {
+    cs.timestampCaughtUpToHeadOrEndblock = new Date();
+    return Prometheus.ProgressReady.set(cs.chainConfig.id);
+  }
+}
+
+function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTargetBlockNumber, isReorgChain) {
+  let chainId = cs.chainConfig.id;
+  if (newProgressBlockNumber === undefined) {
+    if (isReorgChain) {
+      cs.reorgDetection = ReorgDetection.rollbackToValidBlockNumber(cs.reorgDetection, rollbackTargetBlockNumber);
+      cs.fetchState = FetchState.rollback(cs.fetchState, rollbackTargetBlockNumber);
+      cs.committedProgressBlockNumber = Primitive_int.min(cs.committedProgressBlockNumber, rollbackTargetBlockNumber);
+      return;
+    } else {
+      return;
+    }
+  }
+  let newTotalEventsProcessed = cs.numEventsProcessed - Stdlib_Option.getOrThrow(eventsProcessedDiff, "Missing events-processed diff for rolled-back chain");
+  if (cs.committedProgressBlockNumber !== newProgressBlockNumber) {
+    Prometheus.ProgressBlockNumber.set(newProgressBlockNumber, chainId);
+  }
+  if (cs.numEventsProcessed !== newTotalEventsProcessed) {
+    Prometheus.ProgressEventsCount.set(newTotalEventsProcessed, chainId);
+  }
+  if (isReorgChain) {
+    cs.reorgDetection = ReorgDetection.rollbackToValidBlockNumber(cs.reorgDetection, rollbackTargetBlockNumber);
+  }
+  let safeCheckpointTracking = cs.safeCheckpointTracking;
+  if (safeCheckpointTracking !== undefined) {
+    cs.safeCheckpointTracking = SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber);
+  }
+  cs.fetchState = FetchState.rollback(cs.fetchState, newProgressBlockNumber);
+  cs.committedProgressBlockNumber = newProgressBlockNumber;
+  cs.numEventsProcessed = newTotalEventsProcessed;
+}
+
+export {
+  configAddresses,
+  make,
+  makeFromConfig,
+  makeFromDbState,
+  logger,
+  fetchState,
+  sourceManager,
+  chainConfig,
+  reorgDetection,
+  safeCheckpointTracking,
+  isProgressAtHead,
+  committedProgressBlockNumber,
+  numEventsProcessed,
+  timestampCaughtUpToHeadOrEndblock,
+  hasProcessedToEndblock,
+  getHighestBlockBelowThreshold,
+  isActivelyIndexing,
+  isReady,
+  isFetchingAtHead,
+  handleQueryResult,
+  registerReorgGuard,
+  prepareReorg,
+  updateKnownHeight,
+  setEndBlockToFirstEvent,
+  enterReorgThreshold,
+  advanceAfterBatch,
+  applyBatchProgress,
+  markReady,
+  rollback,
+}
+/* Env Not a pure module */

package/src/ChainState.resi

@@ -0,0 +1,85 @@
+// Per-chain runtime state. `t` is opaque: other modules read it through the
+// accessors and change it only through the mutators exposed here.
+
+type t
+
+let configAddresses: Config.chain => array<Internal.indexingAddress>
+
+let make: (
+  ~chainConfig: Config.chain,
+  ~fetchState: FetchState.t,
+  ~sourceManager: SourceManager.t,
+  ~reorgDetection: ReorgDetection.t,
+  ~committedProgressBlockNumber: int,
+  ~safeCheckpointTracking: option<SafeCheckpointTracking.t>=?,
+  ~numEventsProcessed: float=?,
+  ~timestampCaughtUpToHeadOrEndblock: option<Date.t>=?,
+  ~isProgressAtHead: bool=?,
+  ~logger: Pino.t,
+) => t
+
+let makeFromConfig: (
+  Config.chain,
+  ~config: Config.t,
+  ~registrations: HandlerRegister.registrations,
+  ~knownHeight: int,
+) => t
+
+let makeFromDbState: (
+  Config.chain,
+  ~resumedChainState: Persistence.initialChainState,
+  ~reorgCheckpoints: array<Internal.reorgCheckpoint>,
+  ~isInReorgThreshold: bool,
+  ~isRealtime: bool,
+  ~config: Config.t,
+  ~registrations: HandlerRegister.registrations,
+  ~reducedPollingInterval: int=?,
+) => t
+
+// Accessors.
+let logger: t => Pino.t
+let fetchState: t => FetchState.t
+let sourceManager: t => SourceManager.t
+let chainConfig: t => Config.chain
+let reorgDetection: t => ReorgDetection.t
+let safeCheckpointTracking: t => option<SafeCheckpointTracking.t>
+let isProgressAtHead: t => bool
+let committedProgressBlockNumber: t => int
+let numEventsProcessed: t => float
+let timestampCaughtUpToHeadOrEndblock: t => option<Date.t>
+
+// Derived (pure).
+let hasProcessedToEndblock: t => bool
+let getHighestBlockBelowThreshold: t => int
+let isActivelyIndexing: t => bool
+let isReady: t => bool
+let isFetchingAtHead: t => bool
+
+// State transitions. The chain state is mutated only through these.
+let handleQueryResult: (
+  t,
+  ~query: FetchState.query,
+  ~newItems: array<Internal.item>,
+  ~newItemsWithDcs: array<Internal.item>,
+  ~latestFetchedBlock: FetchState.blockNumberAndTimestamp,
+  ~knownHeight: int,
+) => unit
+let registerReorgGuard: (
+  t,
+  ~blockHashes: array<ReorgDetection.blockData>,
+  ~knownHeight: int,
+) => ReorgDetection.reorgResult
+let prepareReorg: (t, ~eventsProcessedDiff: option<float>) => unit
+let updateKnownHeight: (t, ~knownHeight: int) => unit
+let setEndBlockToFirstEvent: (t, ~blockNumber: int) => unit
+let enterReorgThreshold: t => unit
+let advanceAfterBatch: (t, ~batch: Batch.t, ~enteringReorgThreshold: bool) => unit
+let applyBatchProgress: (t, ~batch: Batch.t) => unit
+let markReady: t => unit
+let rollback: (
+  t,
+  ~newProgressBlockNumber: option<int>,
+  ~eventsProcessedDiff: option<float>,
+  ~rollbackTargetBlockNumber: int,
+  ~isReorgChain: bool,
+) => unit

package/src/Config.res

@@ -17,7 +17,7 @@ type contract = {
   startBlock: option<int>,
 }
 
-// Sources are instantiated lazily in ChainFetcher from this config.
+// Sources are instantiated lazily in ChainState from this config.
 type evmRpcConfig = {
   url: string,
   sourceFor: Source.sourceFor,
@@ -546,10 +546,19 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     )
   }
 
+  let logger = Logging.getLogger()
   let ecosystem = switch ecosystemName {
-  | Ecosystem.Evm => Evm.ecosystem
-  | Ecosystem.Fuel => Fuel.ecosystem
-  | Ecosystem.Svm => Svm.ecosystem
+  | Ecosystem.Evm => Evm.make(~logger)
+  | Ecosystem.Fuel => Fuel.make(~logger)
+  | Ecosystem.Svm => Svm.make(~logger)
+  }
+
+  // SVM has no raw-events representation (`Svm.toRawEvent` throws), so reject
+  // it at config time instead of failing mid-indexing.
+  if ecosystemName === Ecosystem.Svm && publicConfig["rawEvents"]->Option.getOr(false) {
+    JsError.throwWithMessage(
+      "Invalid indexer config: rawEvents is not supported for the SVM ecosystem",
+    )
   }
 
   // Extract EVM-specific options with defaults

package/src/Config.res.mjs

@@ -8,6 +8,7 @@ import * as Fuel from "./sources/Fuel.res.mjs";
 import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Address from "./Address.res.mjs";
+import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as BigDecimal from "./bindings/BigDecimal.res.mjs";
@@ -424,18 +425,22 @@ function fromPublic(publicConfigJson) {
     );
   let ecosystemName = match$3[1];
   let publicChainsConfig = match$3[0];
+  let logger = Logging.getLogger();
   let ecosystem;
   switch (ecosystemName) {
     case "evm" :
-      ecosystem = Evm.ecosystem;
+      ecosystem = Evm.make(logger);
       break;
     case "fuel" :
-      ecosystem = Fuel.ecosystem;
+      ecosystem = Fuel.make(logger);
       break;
     case "svm" :
-      ecosystem = Svm.ecosystem;
+      ecosystem = Svm.make(logger);
       break;
   }
+  if (ecosystemName === "svm" && Stdlib_Option.getOr(publicConfig.rawEvents, false)) {
+    Stdlib_JsError.throwWithMessage("Invalid indexer config: rawEvents is not supported for the SVM ecosystem");
+  }
   let evm = publicConfig.evm;
   let lowercaseAddresses = evm !== undefined ? Stdlib_Option.getOr(Primitive_option.valFromOption(evm).addressFormat, "checksum") === "lowercase" : false;
   let match$4 = publicConfig.evm;