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

package/src/Config.res

@@ -198,6 +198,7 @@ let svmEventDescriptorSchema = S.schema(s =>
     "discriminator": s.matches(S.option(S.string)),
     "discriminatorByteLen": s.matches(S.int),
     "transactionFields": s.matches(S.array(Internal.svmTransactionFieldSchema)),
+    "blockFields": s.matches(S.option(S.array(Internal.svmBlockFieldSchema))),
     "includeLogs": s.matches(S.bool),
     "accountFilters": s.matches(
       S.option(
@@ -654,7 +655,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     ~events: option<array<_>>,
     ~abi,
     ~chainId: int,
-    ~startBlock: option<int>,
     ~addresses: array<string>,
     ~svmDefinedTypes: JSON.t=JSON.Null,
   ) => {
@@ -677,10 +677,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
               ~kind=fuelKind,
               ~sighash,
               ~rawAbi=abi->(Utils.magic: EvmTypes.Abi.t => JSON.t),
-              ~isWildcard=false,
-              ~handler=None,
-              ~contractRegister=None,
-              ~startBlock?,
             ) :> Internal.eventConfig)
           | None =>
             JsError.throwWithMessage(
@@ -706,6 +702,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
                   "discriminator": option<string>,
                   "discriminatorByteLen": int,
                   "transactionFields": array<Internal.svmTransactionField>,
+                  "blockFields": option<array<Internal.svmBlockField>>,
                   "includeLogs": bool,
                   "accountFilters": option<
                     array<array<{"position": int, "values": array<string>}>>,
@@ -741,16 +738,13 @@ let fromPublic = (publicConfigJson: JSON.t) => {
             ~discriminator=svm["discriminator"],
             ~discriminatorByteLen=svm["discriminatorByteLen"],
             ~transactionFields=svm["transactionFields"],
+            ~blockFields=?svm["blockFields"],
             ~includeLogs=svm["includeLogs"],
             ~accountFilters,
             ~isInner=svm["isInner"],
-            ~isWildcard=false,
-            ~handler=None,
-            ~contractRegister=None,
             ~accounts=svm["accounts"]->Option.getOr([]),
             ~args=svm["args"]->Option.getOr(JSON.Null),
             ~definedTypes=svmDefinedTypes,
-            ~startBlock?,
           ) :> Internal.eventConfig)
         | _ =>
           (EventConfigBuilder.buildEvmEventConfig(
@@ -758,15 +752,8 @@ let fromPublic = (publicConfigJson: JSON.t) => {
             ~eventName,
             ~sighash,
             ~params,
-            ~isWildcard=false,
-            ~handler=None,
-            ~contractRegister=None,
-            ~eventFilters=None,
-            ~probeChainId=chainId,
-            ~onEventBlockFilterSchema=ecosystem.onEventBlockFilterSchema,
             ~blockFields=?eventItem["blockFields"],
             ~transactionFields=?eventItem["transactionFields"],
-            ~startBlock?,
             ~globalBlockFieldsSet,
             ~globalTransactionFieldsSet,
           ) :> Internal.eventConfig)
@@ -818,17 +805,14 @@ let fromPublic = (publicConfigJson: JSON.t) => {
           let addresses = rawAddresses->Array.map(parseAddress)
           let startBlock = chainContract->Option.flatMap(cc => cc["startBlock"])
 
-          // Build event configs from JSON (field selections resolved inline)
-          // chainId is threaded in so the where-callback detection probe
-          // exercises the callback with this chain's real id — handlers
-          // that branch on `chain.id` are taken through the same path
-          // they will follow at runtime.
+          // Build event definitions from JSON (field selections resolved
+          // inline). Handlers and per-chain `where` filters are layered on
+          // later as `onEventRegistration`s in `ChainState.makeInternal`.
           let events = buildContractEvents(
             ~contractName=capitalizedName,
             ~events=contractData["events"],
             ~abi=contractData["abi"],
             ~chainId,
-            ~startBlock,
             ~addresses=rawAddresses,
             ~svmDefinedTypes=contractData["svmAbi"]
             ->Option.map(a => a["definedTypes"])
@@ -1018,6 +1002,50 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   }
 }
 
+// Canonicalize a user-provided address to the configured casing so it matches
+// addresses parsed from config.yaml during routing. HyperSync/RPC data arrives
+// already canonical; only user-land input (simulate srcAddress, contractRegister
+// add) can carry arbitrary casing and needs this before comparison.
+let normalizeUserAddress = (config: t, address: Address.t): Address.t =>
+  switch config.ecosystem.name {
+  | Ecosystem.Evm =>
+    if config.lowercaseAddresses {
+      address->Address.Evm.fromAddressLowercaseOrThrow
+    } else {
+      address->Address.Evm.fromAddressOrThrow
+    }
+  // TODO: Ideally we should do the same for other ecosystems
+  | Ecosystem.Fuel | Ecosystem.Svm => address
+  }
+
+// Relaxed counterpart to normalizeUserAddress, used only for simulate srcAddress.
+// Tests commonly use short placeholder strings like "0xfoo" as a stand-in
+// identity (e.g. for a wildcard event whose srcAddress doesn't need to resolve
+// to any real contract), so only the "0x" prefix is enforced here. Under
+// address_format: checksum, a real address is checksummed even if the input
+// casing doesn't match (getAddress doesn't require the input to already be
+// checksummed) — a placeholder that isn't valid hex falls back unchanged.
+let normalizeSimulateAddress = (config: t, address: Address.t): Address.t =>
+  switch config.ecosystem.name {
+  | Ecosystem.Evm =>
+    let str = address->Address.toString
+    if !(str->String.startsWith("0x")) {
+      JsError.throwWithMessage(
+        `simulate: srcAddress "${str}" is invalid. Expected a string starting with "0x".`,
+      )
+    }
+    if config.lowercaseAddresses {
+      address->Address.Evm.fromAddressLowercaseOrThrow
+    } else {
+      try {
+        address->Address.Evm.fromAddressOrThrow
+      } catch {
+      | _ => address
+      }
+    }
+  | Ecosystem.Fuel | Ecosystem.Svm => address
+  }
+
 // Look up an event config by (contract, event) name. When `chainId` is given,
 // returns that chain's per-chain event config (matters for where-callback
 // probe detection, which runs with the chain's real id). Without `chainId`,
@@ -1259,11 +1287,11 @@ let throwIfIncompatible = (
   }
 }
 
-// The returned value is a pure function of the JSON — no handler
-// registrations are applied here. Post-registration configs come from
-// `HandlerLoader.applyRegistrations`. That purity is what lets this
-// memoize without invalidation.
-let loadWithoutRegistrations = () =>
+// The returned value is a pure function of the JSON: it holds only event
+// definitions, never handler/contractRegister/where state (that's layered on
+// separately as `HandlerRegister.registrationsByChainId`). That purity is
+// what lets this memoize without invalidation.
+let load = () =>
   switch cached.contents {
   | Some(c) => c
   | None => {

package/src/Config.res.mjs

@@ -113,6 +113,7 @@ let svmEventDescriptorSchema = S$RescriptSchema.schema(s => ({
   discriminator: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   discriminatorByteLen: s.m(S$RescriptSchema.int),
   transactionFields: s.m(S$RescriptSchema.array(Internal.svmTransactionFieldSchema)),
+  blockFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.svmBlockFieldSchema))),
   includeLogs: s.m(S$RescriptSchema.bool),
   accountFilters: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
     position: s.m(S$RescriptSchema.int),
@@ -490,7 +491,7 @@ function fromPublic(publicConfigJson) {
       };
     });
   }
-  let buildContractEvents = (contractName, events, abi, chainId, startBlock, addresses, svmDefinedTypesOpt) => {
+  let buildContractEvents = (contractName, events, abi, chainId, addresses, svmDefinedTypesOpt) => {
     let svmDefinedTypes = svmDefinedTypesOpt !== undefined ? svmDefinedTypesOpt : null;
     if (events !== undefined) {
       return events.map(eventItem => {
@@ -500,10 +501,10 @@ function fromPublic(publicConfigJson) {
         let kind = eventItem.kind;
         switch (ecosystemName) {
           case "evm" :
-            return EventConfigBuilder.buildEvmEventConfig(contractName, eventName, sighash, params, false, undefined, undefined, undefined, chainId, ecosystem.onEventBlockFilterSchema, eventItem.blockFields, eventItem.transactionFields, startBlock, Primitive_option.some(globalBlockFieldsSet), Primitive_option.some(globalTransactionFieldsSet));
+            return EventConfigBuilder.buildEvmEventConfig(contractName, eventName, sighash, params, eventItem.blockFields, eventItem.transactionFields, Primitive_option.some(globalBlockFieldsSet), Primitive_option.some(globalTransactionFieldsSet));
           case "fuel" :
             if (kind !== undefined) {
-              return EventConfigBuilder.buildFuelEventConfig(contractName, eventName, kind, sighash, abi, false, undefined, undefined, startBlock);
+              return EventConfigBuilder.buildFuelEventConfig(contractName, eventName, kind, sighash, abi);
             } else {
               return Stdlib_JsError.throwWithMessage(`Fuel event ` + contractName + `.` + eventName + ` is missing "kind" in internal config`);
             }
@@ -518,7 +519,7 @@ function fromPublic(publicConfigJson) {
               position: af.position,
               values: af.values
             })));
-            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, svm.includeLogs, svm.transactionFields, accountFilters, svm.isInner, false, undefined, undefined, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes, startBlock);
+            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, svm.includeLogs, svm.transactionFields, svm.blockFields, accountFilters, svm.isInner, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes);
         }
       });
     } else {
@@ -559,7 +560,7 @@ function fromPublic(publicConfigJson) {
       let rawAddresses = Stdlib_Option.getOr(Stdlib_Option.flatMap(chainContract, cc => cc.addresses), []);
       let addresses = rawAddresses.map(parseAddress);
       let startBlock = Stdlib_Option.flatMap(chainContract, cc => cc.startBlock);
-      let events = buildContractEvents(capitalizedName, contractData.events, contractData.abi, chainId, startBlock, rawAddresses, Stdlib_Option.getOr(Stdlib_Option.map(contractData.svmAbi, a => a.definedTypes), null));
+      let events = buildContractEvents(capitalizedName, contractData.events, contractData.abi, chainId, rawAddresses, Stdlib_Option.getOr(Stdlib_Option.map(contractData.svmAbi, a => a.definedTypes), null));
       return {
         name: capitalizedName,
         abi: contractData.abi,
@@ -706,6 +707,42 @@ function fromPublic(publicConfigJson) {
   };
 }
 
+function normalizeUserAddress(config, address) {
+  let match = config.ecosystem.name;
+  switch (match) {
+    case "evm" :
+      if (config.lowercaseAddresses) {
+        return Address.Evm.fromAddressLowercaseOrThrow(address);
+      } else {
+        return Address.Evm.fromAddressOrThrow(address);
+      }
+    case "fuel" :
+    case "svm" :
+      return address;
+  }
+}
+
+function normalizeSimulateAddress(config, address) {
+  let match = config.ecosystem.name;
+  switch (match) {
+    case "evm" :
+      if (!address.startsWith("0x")) {
+        Stdlib_JsError.throwWithMessage(`simulate: srcAddress "` + address + `" is invalid. Expected a string starting with "0x".`);
+      }
+      if (config.lowercaseAddresses) {
+        return Address.Evm.fromAddressLowercaseOrThrow(address);
+      }
+      try {
+        return Address.Evm.fromAddressOrThrow(address);
+      } catch (exn) {
+        return address;
+      }
+    case "fuel" :
+    case "svm" :
+      return address;
+  }
+}
+
 function getEventConfig(config, contractName, eventName, chainId) {
   let chains;
   if (chainId !== undefined) {
@@ -975,7 +1012,7 @@ function throwIfIncompatible(changedPaths, resetCommand, runCommand, hasClickhou
   Stdlib_JsError.throwWithMessage(`The following config changes are incompatible with the existing indexer data:\n\n` + bullets + `\n\nPick one:\n  1. ` + padTo(option1, col) + `# resume indexing where it left off\n  2. ` + padTo(resetCommand, col) + `# delete all indexed data and start over` + option3);
 }
 
-function loadWithoutRegistrations() {
+function load() {
   let c = cached.contents;
   if (c !== undefined) {
     return c;
@@ -1012,6 +1049,8 @@ export {
   publicConfigStorageSchema,
   publicConfigSchema,
   fromPublic,
+  normalizeUserAddress,
+  normalizeSimulateAddress,
   getEventConfig,
   shouldSaveHistory,
   shouldPruneHistory,
@@ -1022,7 +1061,7 @@ export {
   canonicalJson,
   diffPaths,
   throwIfIncompatible,
-  loadWithoutRegistrations,
+  load,
   getPgUserEntities,
 }
 /* schema Not a pure module */

package/src/ContractRegisterContext.res

@@ -22,18 +22,8 @@ let makeAddFunction = (~params: contractRegisterParams, ~contractName: string):
         ~logger=Ecosystem.getItemLogger(params.item, ~ecosystem=params.config.ecosystem),
       )
     }
-    let validatedAddress = if params.config.ecosystem.name === Evm {
-      // The value is passed from the user-land,
-      // so we need to validate and checksum/lowercase the address.
-      if params.config.lowercaseAddresses {
-        contractAddress->Address.Evm.fromAddressLowercaseOrThrow
-      } else {
-        contractAddress->Address.Evm.fromAddressOrThrow
-      }
-    } else {
-      // TODO: Ideally we should do the same for other ecosystems
-      contractAddress
-    }
+    // The value is passed from user-land, so validate and checksum/lowercase it.
+    let validatedAddress = params.config->Config.normalizeUserAddress(contractAddress)
 
     params.onRegister(~item=params.item, ~contractAddress=validatedAddress, ~contractName)
   }

package/src/ContractRegisterContext.res.mjs

@@ -1,6 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Address from "./Address.res.mjs";
+import * as Config from "./Config.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
@@ -12,9 +12,7 @@ function makeAddFunction(params, contractName) {
     if (params.isResolved) {
       ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access context.chain after the contract register is resolved. Make sure you didn't miss an await in the handler.`));
     }
-    let validatedAddress = params.config.ecosystem.name === "evm" ? (
-        params.config.lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(contractAddress) : Address.Evm.fromAddressOrThrow(contractAddress)
-      ) : contractAddress;
+    let validatedAddress = Config.normalizeUserAddress(params.config, contractAddress);
     params.onRegister(params.item, validatedAddress, contractName);
   };
 }
@@ -73,4 +71,4 @@ export {
   getContractRegisterContext,
   getContractRegisterArgs,
 }
-/* Address Not a pure module */
+/* Config Not a pure module */

package/src/Core.res

@@ -9,6 +9,7 @@ type evmRpcClientCtor
 type svmHypersyncClientCtor
 type hyperfuelClientCtor
 type transactionStoreCtor
+type blockStoreCtor
 
 type addon = {
   getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
@@ -23,10 +24,16 @@ type addon = {
   hyperfuelClient: hyperfuelClientCtor,
   @as("TransactionStore")
   transactionStore: transactionStoreCtor,
+  @as("BlockStore")
+  blockStore: blockStoreCtor,
   // Ordered transaction-field names exposed for the field-code contract test
   // (the ReScript `transactionFields` arrays must match the Rust ordinals).
   evmTransactionFieldNames: unit => array<string>,
   svmTransactionFieldNames: unit => array<string>,
+  // Ordered block-field names for the same contract test (`blockFields` arrays
+  // must match the Rust ordinals).
+  evmBlockFieldNames: unit => array<string>,
+  svmBlockFieldNames: unit => array<string>,
 }
 
 @module("node:module") external createRequire: string => {..} = "createRequire"

package/src/CrossChainState.res

@@ -19,7 +19,7 @@ type t = {
 let calculateTargetBufferSize = () =>
   switch Env.targetBufferSize {
   | Some(size) => size
-  | None => 100_000
+  | None => 50_000
   }
 
 let make = (
@@ -135,13 +135,13 @@ let enterReorgThreshold = (crossChainState: t) => {
 // whole indexer. A chain is marked caught up only once EVERY chain is caught up
 // (reached endblock or fetched/processed to head) with no processable events
 // left — so no chain flips to ready while another is still backfilling.
-let applyBatchProgress = (crossChainState: t, ~batch: Batch.t) => {
+let applyBatchProgress = (crossChainState: t, ~batch: Batch.t, ~blockTimestampName: string) => {
   let chainIds = crossChainState.chainIds
 
   let everyChainCaughtUp = ref(true)
   for i in 0 to chainIds->Array.length - 1 {
     let cs = crossChainState->getChainState(chainIds->Array.getUnsafe(i))
-    cs->ChainState.applyBatchProgress(~batch)
+    cs->ChainState.applyBatchProgress(~batch, ~blockTimestampName)
     if !(cs->ChainState.hasProcessedToEndblock || cs->ChainState.isProgressAtHead) {
       everyChainCaughtUp := false
     }
@@ -190,96 +190,71 @@ let totalReservedSize = (crossChainState: t) => {
   total.contents
 }
 
-// Furthest-behind first: order candidate queries by the chain progress % at
-// their fromBlock, so the most behind ranges across all chains are admitted
-// before the rest.
-let compareByProgress = (a: FetchState.query, b: FetchState.query) =>
-  Float.compare(a.progress, b.progress)
-
 // Dispatch a fetch tick across the whole indexer from one shared pool of
-// ~targetBufferSize ready events. Every chain proposes its candidate queries
-// (each carrying an estimated response size) against the full free budget; the
-// candidates are then pooled, ordered by chain progress (furthest-behind first),
-// and admitted until the budget is consumed. So the budget is split per query
-// across chains rather than per chain — a chain that can only use a little
-// leaves the rest for the others automatically.
+// ~targetBufferSize ready events, as a waterfall: visit chains furthest-behind
+// first, hand each the budget remaining at that point (plus its own
+// already-reserved share, since a chain's pending queries aren't "spent" —
+// they're this chain's), let it turn that into queries sized against its own
+// chain-density-derived target block, then subtract what it actually used
+// before moving to the next chain. So a chain that can only use a little
+// (density too low, or already caught up) leaves the rest for the others
+// automatically — unlike a per-query pool, this can starve a near-head chain
+// while an earlier one is deep in backfill, which is the intended tradeoff.
 let checkAndFetch = async (
   crossChainState: t,
   ~dispatchChain: (~chain: ChainMap.Chain.t, ~action: FetchState.nextQuery) => promise<unit>,
 ) => {
-  let remaining = Pervasives.max(
-    0,
-    crossChainState.targetBufferSize -
-    crossChainState->totalReadyCount -
-    crossChainState->totalReservedSize->Float.toInt,
+  let remaining = ref(
+    Pervasives.max(
+      0.,
+      crossChainState.targetBufferSize->Int.toFloat -.
+      crossChainState->totalReadyCount->Int.toFloat -.
+      crossChainState->totalReservedSize,
+    ),
   )
 
-  let chainIds = crossChainState.chainIds
   let actionByChain = Dict.make()
-  // Candidate queries from every chain. Each query carries its chain id and the
-  // chain progress % at its fromBlock (the admission sort key), set here so the
-  // pool can be ordered without a side tuple per query.
-  let candidates = []
-  for i in 0 to chainIds->Array.length - 1 {
-    let chainId = chainIds->Array.getUnsafe(i)
-    let cs = crossChainState->getChainState(chainId)
-    switch cs->ChainState.getNextQuery(~budget=remaining) {
+  crossChainState
+  ->priorityOrder
+  ->Array.forEach(cs => {
+    let chainId = (cs->ChainState.chainConfig).id
+    let chainTargetItems = remaining.contents +. cs->ChainState.pendingBudget
+    switch cs->ChainState.getNextQuery(~chainTargetItems) {
     | (WaitingForNewBlock | NothingToQuery) as action =>
       actionByChain->Utils.Dict.setByInt(chainId, action)
-    | Ready(queries) =>
-      // Default to NothingToQuery; replaced below if any candidate is admitted.
-      actionByChain->Utils.Dict.setByInt(chainId, FetchState.NothingToQuery)
-      queries->Array.forEach(query => {
-        query.chainId = chainId
-        query.progress = cs->ChainState.getProgressPercentageAt(~blockNumber=query.fromBlock)
-        candidates->Array.push(query)
-      })
+    | Ready(queries) => {
+        let consumed =
+          queries->Array.reduce(0., (acc, query: FetchState.query) => acc +. query.itemsTarget)
+
+        let partitions = Dict.make()
+        queries->Array.forEach((query: FetchState.query) =>
+          partitions->Dict.set(
+            query.partitionId,
+            {
+              "fromBlock": query.fromBlock,
+              "targetBlock": query.toBlock,
+              "targetEvents": query.itemsTarget->Math.round->Float.toInt,
+            },
+          )
+        )
+        Logging.trace({
+          "msg": "Started querying",
+          "chainId": chainId,
+          "partitions": partitions,
+        })
+
+        actionByChain->Utils.Dict.setByInt(chainId, FetchState.Ready(queries))
+        // Mark the queries in flight and reserve their size against the shared
+        // budget; released as each response lands in handleQueryResult.
+        cs->ChainState.startFetchingQueries(~queries)
+        remaining := Pervasives.max(0., remaining.contents -. consumed)
+      }
     }
-  }
-
-  candidates->Array.sort(compareByProgress)
-
-  // Admit furthest-behind first until the budget runs out. The condition is
-  // checked before each query, so as long as there's any budget left we admit
-  // the next one even when its estimate alone exceeds the remainder — otherwise a
-  // chain whose only query is bigger than the budget would never make progress.
-  let admittedByChain = Dict.make()
-  let running = ref(0.)
-  let remainingF = remaining->Int.toFloat
-  let idx = ref(0)
-  while running.contents < remainingF && idx.contents < candidates->Array.length {
-    let query = candidates->Array.getUnsafe(idx.contents)
-    admittedByChain->Utils.Dict.push(query.chainId->Int.toString, query)
-    running := running.contents +. query.estResponseSize
-    idx := idx.contents + 1
-  }
-  admittedByChain->Dict.forEachWithKey((queries, chainId) => {
-    let partitions = Dict.make()
-    queries->Array.forEach((query: FetchState.query) =>
-      partitions->Dict.set(
-        query.partitionId,
-        {
-          "fromBlock": query.fromBlock,
-          "targetBlock": query.toBlock,
-        },
-      )
-    )
-    Logging.trace({
-      "msg": "Started querying",
-      "chainId": chainId->Int.fromString->Option.getUnsafe,
-      "partitions": partitions,
-    })
-    actionByChain->Dict.set(chainId, FetchState.Ready(queries))
-    // Mark the admitted queries in flight and reserve their size against the
-    // shared budget; released as each response lands in handleQueryResult.
-    crossChainState
-    ->getChainState(chainId->Int.fromString->Option.getUnsafe)
-    ->ChainState.startFetchingQueries(~queries)
   })
 
   let promises = []
-  for i in 0 to chainIds->Array.length - 1 {
-    let chainId = chainIds->Array.getUnsafe(i)
+  for i in 0 to crossChainState.chainIds->Array.length - 1 {
+    let chainId = crossChainState.chainIds->Array.getUnsafe(i)
     switch actionByChain->Utils.Dict.dangerouslyGetByIntNonOption(chainId) {
     | Some(NothingToQuery)
     | None => ()