envio 3.12.1 → 3.13.0-rc.0

package/src/Config.res.mjs

@@ -13,6 +13,7 @@ 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";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -470,6 +471,11 @@ function getChain(config, chainId) {
   }
 }
 
+function isPerChain(config) {
+  let match = config.checkpointSequence;
+  return match !== "SharedAcrossChains";
+}
+
 function isolate(config, chainIds) {
   let shared = config.userEntities.filter(entityConfig => entityConfig.crossChain);
   if (shared.length !== 0) {
@@ -907,6 +913,17 @@ function prime(json) {
   cached.contents = undefined;
 }
 
+function withCommandFields(json, chainIds, isDev) {
+  let fields = Stdlib_JSON.Decode.object(json);
+  if (fields === undefined) {
+    return Stdlib_JsError.throwWithMessage("Invalid indexer config: not an object");
+  }
+  let narrowed = Object.assign({}, fields);
+  narrowed["isolatedChains"] = S$RescriptSchema.reverseConvertToJsonOrThrow(chainIds, S$RescriptSchema.array(ChainId.schema));
+  narrowed["isDev"] = isDev;
+  return narrowed;
+}
+
 function getPublicConfigJson() {
   let json = primedJson.contents;
   if (json !== undefined) {
@@ -950,6 +967,10 @@ function stripSensitiveData(json) {
   return cloned;
 }
 
+function envioInfo() {
+  return stripSensitiveData(getPublicConfigJson());
+}
+
 function canonicalJson(json) {
   if (Array.isArray(json)) {
     return json.map(canonicalJson);
@@ -1172,14 +1193,17 @@ export {
   publicConfigSchema,
   contractMappingOf,
   getChain,
+  isPerChain,
   isolate,
   fromPublic,
   normalizeUserAddress,
   normalizeSimulateAddress,
   getEventConfig,
   prime,
+  withCommandFields,
   getPublicConfigJson,
   stripSensitiveData,
+  envioInfo,
   canonicalJson,
   diffPaths,
   throwIfIncompatible,

package/src/Core.res

@@ -166,6 +166,10 @@ let loadDevAddon: ({..}, string) => addon = %raw(`function(req, envioDir) {
     fs.copyFileSync(srcPath, nodePath);
   }
 
+  // Forked workers inherit this, so only the first process in a run pays for
+  // the cargo build (and they don't contend over the cargo lock).
+  process.env.ENVIO_DEV_ADDON = nodePath;
+
   return req(nodePath);
 }`)
 

package/src/Core.res.mjs

@@ -88,6 +88,10 @@ let loadDevAddon = (function(req, envioDir) {
     fs.copyFileSync(srcPath, nodePath);
   }
 
+  // Forked workers inherit this, so only the first process in a run pays for
+  // the cargo build (and they don't contend over the cargo lock).
+  process.env.ENVIO_DEV_ADDON = nodePath;
+
   return req(nodePath);
 });
 

package/src/CrossChainState.res

@@ -17,6 +17,11 @@ type t = {
   mutable isCaughtUp: bool,
   // Indexer-wide fetch buffer pool (item count), shared across all chains.
   targetBufferSize: int,
+  // Set on a process driving part of a split run: the chains it drives may be
+  // at the head while chains in another process are still backfilling, and an
+  // indexer switches to realtime as a whole or not at all. Cleared by the
+  // supervisor once every chain in the run has arrived.
+  mutable holdRealtime: bool,
 }
 
 // The whole-indexer fetch buffer pool, independent of chain count.
@@ -26,16 +31,50 @@ let calculateTargetBufferSize = () =>
   | None => 100_000
   }
 
-let make = (~chainStates, ~isRealtime, ~targetBufferSize=calculateTargetBufferSize()): t => {
+let make = (
+  ~chainStates,
+  ~isRealtime,
+  ~targetBufferSize=calculateTargetBufferSize(),
+  ~holdRealtime=false,
+): t => {
   {
     chainStates,
     chainIds: chainStates->Dict.valuesToArray->Array.map(cs => (cs->ChainState.chainConfig).id),
     isRealtime,
     isCaughtUp: isRealtime,
     targetBufferSize,
+    holdRealtime,
   }
 }
 
+// The supervisor's go-ahead: every chain in the run has reached the head, so
+// this process may make the transitions it has been holding back.
+let releaseRealtime = (crossChainState: t) => crossChainState.holdRealtime = false
+
+let isHoldingRealtime = (crossChainState: t) => crossChainState.holdRealtime
+
+// Whether this process has got as far as it can without the run's leave. What a
+// supervisor reads to decide that a split run may go realtime as one.
+//
+// Three ways to have arrived, because a chain can be as far along as it can get
+// in three different states. Its chains have caught up; or it resumed already
+// realtime; or every chain is waiting to enter the reorg threshold, which is as
+// far as one can fetch while the pre-threshold lag holds it at the safe block —
+// entering the threshold is what lifts that lag, so a run held until its chains
+// reached the head would be holding back the transition that gets them there.
+//
+// The process's own conclusion rather than a reading a supervisor reassembles:
+// a chain committed at what was the head and resumed once the head had moved on
+// has arrived, and no live reading of it can say so — which is the same reason
+// `markCaughtUpOnResume` decides before any source request.
+let hasArrivedAtHead = (crossChainState: t) =>
+  crossChainState.isCaughtUp ||
+  crossChainState.isRealtime || {
+    let chainStates = crossChainState.chainStates->Dict.valuesToArray
+    chainStates->Utils.Array.notEmpty &&
+      chainStates->Array.every(ChainState.isReadyToEnterReorgThreshold)
+  }
+
 // Resolve a chain's state by id. The id always comes from `chainIds`, which is
 // derived from `chainStates`, so the entry is guaranteed present.
 let getChainState = (crossChainState: t, chainId) =>
@@ -122,13 +161,29 @@ let createBatch = (
 
 // Enter the reorg threshold: shrink each chain's buffer by its configured
 // blockLag and flip the flag.
-let enterReorgThreshold = (crossChainState: t) => {
-  Logging.info("Reorg threshold reached")
+// Whether every chain this process drives has buffered close enough to the head
+// to enter the threshold together — and, in a split run, whether the rest of the
+// run has too. Chains enter it as one indexer, so one chain still backfilling
+// holds the others back whatever process it runs in.
+let isReadyToEnterReorgThreshold = (crossChainState: t, ~batch) =>
+  !crossChainState.holdRealtime &&
+  crossChainState.chainStates
+  ->Dict.valuesToArray
+  ->Array.every(cs => cs->ChainState.isReadyToEnterReorgThresholdAfterBatch(~batch))
 
+// Said by each chain rather than once for the indexer: what crossing changes
+// is a chain's own, and the chains of a split run cross in processes that can
+// only speak for the ones they drive.
+let enterReorgThreshold = (crossChainState: t) => {
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
-    crossChainState
-    ->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
-    ->ChainState.enterReorgThreshold
+    let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+    // A chain whose end block sits below these blocks says nothing: crossing
+    // gives it nothing more to index, and it will never reach one of them.
+    let liftsCeiling = cs->ChainState.reorgThresholdLiftsCeiling
+    cs->ChainState.enterReorgThreshold
+    if liftsCeiling {
+      cs->ChainState.logger->Logging.childInfo(ChainState.reorgThresholdEntryMessage)
+    }
   }
 }
 
@@ -150,7 +205,10 @@ let applyBatchProgress = (crossChainState: t, ~batch: Batch.t, ~blockTimestampNa
   }
 
   crossChainState.isCaughtUp =
-    crossChainState.isCaughtUp || (crossChainState->nextItemIsNone && everyChainCaughtUp.contents)
+    crossChainState.isCaughtUp ||
+    (!crossChainState.holdRealtime &&
+    crossChainState->nextItemIsNone &&
+    everyChainCaughtUp.contents)
 }
 
 // Every chain has buffered up to its head (or endblock) with nothing
@@ -174,8 +232,13 @@ let isSettledAtHead = (crossChainState: t) => {
 }
 
 // Enter the FinalizingIndexes phase without a batch, for the resume above.
+// Not while the run holds this process back: the hold keeps the pre-threshold
+// lag in place, and a chain that has fetched to a lagged head it was never
+// going to get past reads as settled without having indexed anything. What a
+// held process may conclude about where it stands, it concludes from what was
+// persisted — see `markCaughtUpOnResume`, which the hold leaves alone.
 let markCaughtUpIfSettled = (crossChainState: t) =>
-  if crossChainState->isSettledAtHead {
+  if !crossChainState.holdRealtime && crossChainState->isSettledAtHead {
     crossChainState.isCaughtUp = true
   }
 
@@ -206,13 +269,48 @@ let markCaughtUpOnResume = (crossChainState: t) => {
 // and switches the indexer to realtime.
 let markReady = (crossChainState: t, ~readyAt) => {
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
-    crossChainState
-    ->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
-    ->ChainState.markReady(~readyAt)
+    let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+    let wasReady = cs->ChainState.isReady
+    cs->ChainState.markReady(~readyAt)
+
+    // One line per chain, because `ready_at` is one column per chain: what the
+    // log says and what a reader finds in the row are the same fact.
+    if !wasReady {
+      cs
+      ->ChainState.logger
+      ->Logging.childInfo("Ready. Fully indexed for queries.")
+    }
   }
   crossChainState.isRealtime = true
 }
 
+// Each chain that has just finished indexing, said once, by the chain it is
+// about — so a chain that finishes early says so then, rather than when the
+// last chain in its process catches up.
+let reportFinished = (crossChainState: t) => {
+  let waitingOnOthers = crossChainState.holdRealtime || crossChainState.chainIds->Array.length > 1
+  crossChainState.chainStates
+  ->Dict.valuesToArray
+  ->Array.forEach(cs =>
+    switch cs->ChainState.takeFinished {
+    | Some(EndBlock(block)) =>
+      cs
+      ->ChainState.logger
+      ->Logging.childInfo({"msg": "Indexed to the end block. This chain is done.", "block": block})
+    | Some(Backfill(block)) =>
+      cs
+      ->ChainState.logger
+      ->Logging.childInfo({
+        "msg": waitingOnOthers
+          ? "Finished backfill. Waiting for the other chains."
+          : "Finished backfill.",
+        "block": block,
+      })
+    | None => ()
+    }
+  )
+}
+
 // --- Fetch control. ---
 
 // Chains ordered furthest-behind first by fetch-frontier progress, so the

package/src/CrossChainState.res.mjs

@@ -20,19 +20,41 @@ function calculateTargetBufferSize() {
   }
 }
 
-function make(chainStates, isRealtime, targetBufferSizeOpt) {
+function make(chainStates, isRealtime, targetBufferSizeOpt, holdRealtimeOpt) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : (
       Env.targetBufferSize !== undefined ? Env.targetBufferSize : 100000
     );
+  let holdRealtime = holdRealtimeOpt !== undefined ? holdRealtimeOpt : false;
   return {
     chainStates: chainStates,
     chainIds: Object.values(chainStates).map(cs => ChainState.chainConfig(cs).id),
     isRealtime: isRealtime,
     isCaughtUp: isRealtime,
-    targetBufferSize: targetBufferSize
+    targetBufferSize: targetBufferSize,
+    holdRealtime: holdRealtime
   };
 }
 
+function releaseRealtime(crossChainState) {
+  crossChainState.holdRealtime = false;
+}
+
+function isHoldingRealtime(crossChainState) {
+  return crossChainState.holdRealtime;
+}
+
+function hasArrivedAtHead(crossChainState) {
+  if (crossChainState.isCaughtUp || crossChainState.isRealtime) {
+    return true;
+  }
+  let chainStates = Object.values(crossChainState.chainStates);
+  if (Utils.$$Array.notEmpty(chainStates)) {
+    return chainStates.every(ChainState.isReadyToEnterReorgThreshold);
+  } else {
+    return false;
+  }
+}
+
 function chainStates(crossChainState) {
   return crossChainState.chainStates;
 }
@@ -94,10 +116,22 @@ function createBatch(crossChainState, config, frontier, batchSizeTarget) {
   return Batch.make(config.checkpointSequence, frontier, Utils.Dict.mapValues(crossChainState.chainStates, none => ChainState.toChainBeforeBatch(none, crossChainState.isRealtime)), batchSizeTarget, HistoryPolicy.decide(config, shouldSaveHistory(crossChainState)));
 }
 
+function isReadyToEnterReorgThreshold(crossChainState, batch) {
+  if (crossChainState.holdRealtime) {
+    return false;
+  } else {
+    return Object.values(crossChainState.chainStates).every(cs => ChainState.isReadyToEnterReorgThresholdAfterBatch(cs, batch));
+  }
+}
+
 function enterReorgThreshold(crossChainState) {
-  Logging.info("Reorg threshold reached");
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
-    ChainState.enterReorgThreshold(crossChainState.chainStates[crossChainState.chainIds[i]]);
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    let liftsCeiling = ChainState.reorgThresholdLiftsCeiling(cs);
+    ChainState.enterReorgThreshold(cs);
+    if (liftsCeiling) {
+      Logging.childInfo(ChainState.logger(cs), ChainState.reorgThresholdEntryMessage);
+    }
   }
 }
 
@@ -111,7 +145,7 @@ function applyBatchProgress(crossChainState, batch, blockTimestampName) {
       everyChainCaughtUp = false;
     }
   }
-  crossChainState.isCaughtUp = crossChainState.isCaughtUp || nextItemIsNone(crossChainState) && everyChainCaughtUp;
+  crossChainState.isCaughtUp = crossChainState.isCaughtUp || !crossChainState.holdRealtime && nextItemIsNone(crossChainState) && everyChainCaughtUp;
 }
 
 function isSettledAtHead(crossChainState) {
@@ -125,7 +159,7 @@ function isSettledAtHead(crossChainState) {
 }
 
 function markCaughtUpIfSettled(crossChainState) {
-  if (isSettledAtHead(crossChainState)) {
+  if (!crossChainState.holdRealtime && isSettledAtHead(crossChainState)) {
     crossChainState.isCaughtUp = true;
     return;
   }
@@ -147,11 +181,36 @@ function markCaughtUpOnResume(crossChainState) {
 
 function markReady(crossChainState, readyAt) {
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
-    ChainState.markReady(crossChainState.chainStates[crossChainState.chainIds[i]], readyAt);
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    let wasReady = ChainState.isReady(cs);
+    ChainState.markReady(cs, readyAt);
+    if (!wasReady) {
+      Logging.childInfo(ChainState.logger(cs), "Ready. Fully indexed for queries.");
+    }
   }
   crossChainState.isRealtime = true;
 }
 
+function reportFinished(crossChainState) {
+  let waitingOnOthers = crossChainState.holdRealtime || crossChainState.chainIds.length > 1;
+  Object.values(crossChainState.chainStates).forEach(cs => {
+    let match = ChainState.takeFinished(cs);
+    if (match !== undefined) {
+      if (match.TAG === "EndBlock") {
+        return Logging.childInfo(ChainState.logger(cs), {
+          msg: "Indexed to the end block. This chain is done.",
+          block: match._0
+        });
+      } else {
+        return Logging.childInfo(ChainState.logger(cs), {
+          msg: waitingOnOthers ? "Finished backfill. Waiting for the other chains." : "Finished backfill.",
+          block: match._0
+        });
+      }
+    }
+  });
+}
+
 function priorityOrder(crossChainState) {
   return Object.values(crossChainState.chainStates).toSorted((a, b) => Primitive_float.compare(ChainState.frontierProgress(a), ChainState.frontierProgress(b)));
 }
@@ -256,12 +315,17 @@ export {
   shouldSaveHistory,
   nextItemIsNone,
   getSafeCheckpointIdByChain,
+  releaseRealtime,
+  isHoldingRealtime,
+  hasArrivedAtHead,
+  isReadyToEnterReorgThreshold,
   createBatch,
   enterReorgThreshold,
   applyBatchProgress,
   markCaughtUpIfSettled,
   markCaughtUpOnResume,
   markReady,
+  reportFinished,
   priorityOrder,
   checkAndFetch,
 }

package/src/CrossChainState.resi

@@ -5,7 +5,12 @@ type t
 
 let calculateTargetBufferSize: unit => int
 
-let make: (~chainStates: dict<ChainState.t>, ~isRealtime: bool, ~targetBufferSize: int=?) => t
+let make: (
+  ~chainStates: dict<ChainState.t>,
+  ~isRealtime: bool,
+  ~targetBufferSize: int=?,
+  ~holdRealtime: bool=?,
+) => t
 
 // Accessors.
 let chainStates: t => dict<ChainState.t>
@@ -25,12 +30,17 @@ let getSafeCheckpointIdByChain: (
 ) => array<(ChainId.t, option<Internal.checkpointId>)>
 
 // Cross-chain transitions.
+let releaseRealtime: t => unit
+let isHoldingRealtime: t => bool
+let hasArrivedAtHead: t => bool
+let isReadyToEnterReorgThreshold: (t, ~batch: Batch.t) => bool
 let createBatch: (t, ~config: Config.t, ~frontier: Frontier.t, ~batchSizeTarget: int) => Batch.t
 let enterReorgThreshold: t => unit
 let applyBatchProgress: (t, ~batch: Batch.t, ~blockTimestampName: string) => unit
 let markCaughtUpIfSettled: t => unit
 let markCaughtUpOnResume: t => unit
 let markReady: (t, ~readyAt: Date.t) => unit
+let reportFinished: t => unit
 
 // Fetch control.
 let priorityOrder: t => array<ChainState.t>

package/src/Env.res

@@ -127,6 +127,10 @@ module Db = {
     //the SSL modes should be provided as string otherwise as 'require' | 'allow' | 'prefer' | 'verify-full'
     ~devFallback=Bool(false),
   )
+  // The budget for the whole run, not for one process: a run that splits across
+  // workers divides it among them, and each caps its own pool to its share.
+  // Splitting takes two workers and a worker takes two connections, so a budget
+  // under 4 — the default among them — keeps the run in one process.
   let maxConnections = envSafe->EnvSafe.get("ENVIO_PG_MAX_CONNECTIONS", S.int, ~fallback=2)
 }
 

package/src/ErrorHandling.res

@@ -11,14 +11,25 @@ let log = (self: t) => {
   }
 }
 
+// The exception to hand to whoever is outside the indexer. A failure raised
+// from a message alone carries no exception of its own, so rethrowing or
+// rejecting with `exn` would hand over a bare `null` and the reason would live
+// only in the logs. Fall back to the message, which is the whole of what such a
+// failure knows.
+let toExn = (self: t) =>
+  switch self.exn->(Utils.magic: exn => Nullable.t<exn>)->Nullable.toOption {
+  | Some(exn) => exn->Utils.prettifyExn
+  | None => Utils.Error.make(self.msg->Option.getOr("Indexer has failed with an unexpected error"))
+  }
+
 let raiseExn = (self: t) => {
-  self.exn->Utils.prettifyExn->throw
+  self->toExn->throw
 }
 
 let mkLogAndRaise = (~logger=?, ~msg=?, exn) => {
-  let exn = exn->Utils.prettifyExn
-  exn->make(~logger?, ~msg?)->log
-  exn->throw
+  let self = exn->Utils.prettifyExn->make(~logger?, ~msg?)
+  self->log
+  self->raiseExn
 }
 
 let unwrapLogAndRaise = (~logger=?, ~msg=?, result) => {

package/src/ErrorHandling.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function make(exn, loggerOpt, msg) {
   let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
@@ -23,14 +24,23 @@ function log(self) {
   }
 }
 
+function toExn(self) {
+  let exn = self.exn;
+  if (exn == null) {
+    return new Error(Stdlib_Option.getOr(self.msg, "Indexer has failed with an unexpected error"));
+  } else {
+    return Utils.prettifyExn(exn);
+  }
+}
+
 function raiseExn(self) {
-  throw Utils.prettifyExn(self.exn);
+  throw toExn(self);
 }
 
 function mkLogAndRaise(logger, msg, exn) {
-  let exn$1 = Utils.prettifyExn(exn);
-  log(make(exn$1, logger, msg));
-  throw exn$1;
+  let self = make(Utils.prettifyExn(exn), logger, msg);
+  log(self);
+  throw toExn(self);
 }
 
 function unwrapLogAndRaise(logger, msg, result) {
@@ -43,12 +53,13 @@ function unwrapLogAndRaise(logger, msg, result) {
 
 function logAndRaise(self) {
   log(self);
-  throw Utils.prettifyExn(self.exn);
+  throw toExn(self);
 }
 
 export {
   make,
   log,
+  toExn,
   raiseExn,
   mkLogAndRaise,
   unwrapLogAndRaise,

package/src/FinalizeBackfill.res

@@ -11,9 +11,15 @@
 // `envio start --chain` process is indexing and never waits on one.
 
 let runOnce = async (state: IndexerState.t) => {
-  Logging.info(
-    "All chains are caught up. Finalizing the indexer before switching to realtime: flushing pending writes, then creating the indexes the schema promises.",
-  )
+  // Said by the process rather than by each of its chains: the indexes are one
+  // build over the tables, and the pause is the whole process's. A chain has
+  // already said it caught up, and says it is ready once this commits. The
+  // chains are named because the pause is theirs, and a split run has a process
+  // saying this for each part of it.
+  Logging.info({
+    "msg": "Building database indexes. Indexing is paused until they are ready, which can take a while on a large database.",
+    "chainIds": state->IndexerState.crossChainState->CrossChainState.chainIds,
+  })
 
   await Writing.flush(state)
 
@@ -32,8 +38,8 @@ let runOnce = async (state: IndexerState.t) => {
 
     // Only after the commit: in-memory readiness must never run ahead of the
     // `ready_at` a restart would read back.
+    // Says so per chain, which is the grain `ready_at` is committed at.
     state->IndexerState.markReady(~readyAt)
-    Logging.info("The indexer is ready. Switching to realtime indexing.")
   }
 }
 

package/src/FinalizeBackfill.res.mjs

@@ -7,7 +7,10 @@ import * as IndexerState from "./IndexerState.res.mjs";
 import * as CrossChainState from "./CrossChainState.res.mjs";
 
 async function runOnce(state) {
-  Logging.info("All chains are caught up. Finalizing the indexer before switching to realtime: flushing pending writes, then creating the indexes the schema promises.");
+  Logging.info({
+    msg: "Building database indexes. Indexing is paused until they are ready, which can take a while on a large database.",
+    chainIds: CrossChainState.chainIds(IndexerState.crossChainState(state))
+  });
   await Writing.flush(state);
   if (IndexerState.hasFailedWrite(state)) {
     return;
@@ -16,8 +19,7 @@ async function runOnce(state) {
   let storage = Persistence.getInitializedStorageOrThrow(persistence);
   let readyAt = new Date();
   await storage.finalizeBackfill(persistence.allEntities, CrossChainState.chainIds(IndexerState.crossChainState(state)), readyAt);
-  IndexerState.markReady(state, readyAt);
-  return Logging.info("The indexer is ready. Switching to realtime indexing.");
+  return IndexerState.markReady(state, readyAt);
 }
 
 function run(state) {

package/src/HandlerRegister.res

@@ -493,41 +493,6 @@ let getSimulateOnEventRegistrations = (
   }
 }
 
-// An RPC source can only deliver the fields it knows how to parse; the rest are
-// silently skipped at materialisation. Every RPC on the chain counts, whatever
-// it's for — a fallback or realtime source runs the same parsers as a sync one,
-// so a field it can't deliver would go missing for whichever blocks it served.
-// The selection can come from either `config.yaml` or the inline `fields`
-// option, so the message names neither. Runs on the registrations a chain
-// actually keeps, so a handler whose `where` opts out of this chain isn't held
-// to its limits.
-//
-// The `config.yaml` half of this is also rejected at codegen, by the
-// `RpcTransactionField` subenum in `system_config.rs`. That one reports every
-// offending field at once and before the project builds; this one is the only
-// check an inline selection reaches. `RpcFieldSelection_test.res` pins the two
-// to the same field set.
-let validateRpcFieldSelection = (
-  chainConfig: Config.chain,
-  registrations: array<Internal.onEventRegistration>,
-) => {
-  let hasRpc = switch chainConfig.sourceConfig {
-  | EvmSourceConfig({rpcs}) => !(rpcs->Utils.Array.isEmpty)
-  | _ => false
-  }
-  if hasRpc {
-    registrations->Array.forEach(reg =>
-      reg.fieldSelection.transactionFields->Utils.Set.forEach(name =>
-        if !RpcSource.isRpcTransactionField(name) {
-          JsError.throwWithMessage(
-            `The "${name}" transaction field selected for the "${reg.eventConfig.name}" event on contract "${reg.eventConfig.contractName}" is unavailable for indexing via RPC. Remove it from the field selection, or remove chain ${chainConfig.id->ChainId.toString}'s RPC source — even an RPC the chain only falls back to has to deliver the selection.`,
-          )
-        }
-      )
-    )
-  }
-}
-
 let finishRegistration = (~config: Config.t): registrationsByChainId => {
   switch getActiveRegistration() {
   | Some(r) => {
@@ -614,8 +579,6 @@ let finishRegistration = (~config: Config.t): registrationsByChainId => {
           }
         })
 
-        validateRpcFieldSelection(chainConfig, onEventRegistrations)
-
         registrationsByChainId->Dict.set(
           key,
           {

package/src/HandlerRegister.res.mjs

@@ -5,7 +5,6 @@ import * as ChainId from "./ChainId.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 RpcSource from "./sources/RpcSource.res.mjs";
 import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -327,22 +326,6 @@ function getSimulateOnEventRegistrations(config, chainId, eventConfig) {
   }
 }
 
-function validateRpcFieldSelection(chainConfig, registrations) {
-  let match = chainConfig.sourceConfig;
-  let hasRpc;
-  hasRpc = match.TAG === "EvmSourceConfig" ? !Utils.$$Array.isEmpty(match.rpcs) : false;
-  if (hasRpc) {
-    registrations.forEach(reg => {
-      reg.fieldSelection.transactionFields.forEach(name => {
-        if (!RpcSource.isRpcTransactionField(name)) {
-          return Stdlib_JsError.throwWithMessage(`The "` + name + `" transaction field selected for the "` + reg.eventConfig.name + `" event on contract "` + reg.eventConfig.contractName + `" is unavailable for indexing via RPC. Remove it from the field selection, or remove chain ` + ChainId.toString(chainConfig.id) + `'s RPC source — even an RPC the chain only falls back to has to deliver the selection.`);
-        }
-      });
-    });
-    return;
-  }
-}
-
 function finishRegistration(config) {
   let r = EnvioGlobal.value.activeRegistration;
   if (r === undefined) {
@@ -389,7 +372,6 @@ function finishRegistration(config) {
       let newrecord = {...reg};
       onEventRegistrations.push((newrecord.index = onEventRegistrations.length, newrecord));
     });
-    validateRpcFieldSelection(chainConfig, onEventRegistrations);
     let chainRegs = r.registrationsByChainId[key];
     registrationsByChainId[key] = {
       onEventRegistrations: onEventRegistrations,