envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/ChainState.resi

@@ -8,6 +8,8 @@ let configAddresses: Config.chain => array<Internal.indexingAddress>
 let make: (
   ~chainConfig: Config.chain,
   ~fetchState: FetchState.t,
+  ~onEventRegistrations: array<Internal.onEventRegistration>=?,
+  ~indexingAddresses: IndexingAddresses.t,
   ~sourceManager: SourceManager.t,
   ~reorgDetection: ReorgDetection.t,
   ~committedProgressBlockNumber: int,
@@ -15,13 +17,16 @@ let make: (
   ~numEventsProcessed: float=?,
   ~timestampCaughtUpToHeadOrEndblock: option<Date.t>=?,
   ~isProgressAtHead: bool=?,
+  ~transactionStore: TransactionStore.t=?,
+  ~chainDensity: option<float>=?,
+  ~blockStore: BlockStore.t=?,
   ~logger: Pino.t,
 ) => t
 
 let makeFromConfig: (
   Config.chain,
   ~config: Config.t,
-  ~registrations: HandlerRegister.registrations,
+  ~registrationsByChainId: HandlerRegister.registrationsByChainId,
   ~knownHeight: int,
 ) => t
 
@@ -32,13 +37,12 @@ let makeFromDbState: (
   ~isInReorgThreshold: bool,
   ~isRealtime: bool,
   ~config: Config.t,
-  ~registrations: HandlerRegister.registrations,
+  ~registrationsByChainId: HandlerRegister.registrationsByChainId,
   ~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
@@ -50,12 +54,68 @@ let pendingBudget: t => float
 let startFetchingQueries: (t, ~queries: array<FetchState.query>) => unit
 let timestampCaughtUpToHeadOrEndblock: t => option<Date.t>
 
+// Fetch-frontier reads.
+let knownHeight: t => int
+let contractAddresses: (t, ~contractName: string) => array<Address.t>
+let bufferSize: t => int
+let bufferReadyCount: t => int
+let getProgressPercentage: t => float
+let chainDensity: t => option<float>
+let effectiveDensity: t => option<float>
+let hasReadyItem: t => bool
+let isReadyToEnterReorgThreshold: t => bool
+
+// Fetch control.
+let targetBlock: (t, ~chainTargetItems: float) => int
+let progressAtBlock: (t, ~blockNumber: int) => float
+let blockAtProgress: (t, ~progress: float) => int
+let getNextQuery: (
+  t,
+  ~chainTargetItems: float,
+  ~chunkItemsMultiplier: float=?,
+  ~maxTargetBlock: int=?,
+) => FetchState.nextQuery
+let dispatch: (
+  t,
+  ~executeQuery: FetchState.query => promise<unit>,
+  ~waitForNewBlock: (~knownHeight: int) => promise<int>,
+  ~onNewBlock: (~knownHeight: int) => unit,
+  ~action: FetchState.nextQuery,
+  ~stateId: int,
+) => promise<unit>
+
+// Views.
+type chainData = {
+  chainId: float,
+  poweredByHyperSync: bool,
+  firstEventBlockNumber: option<int>,
+  latestProcessedBlock: option<int>,
+  timestampCaughtUpToHeadOrEndblock: option<Date.t>,
+  numEventsProcessed: float,
+  latestFetchedBlockNumber: int,
+  @as("currentBlockHeight")
+  knownHeight: int,
+  numBatchesFetched: int,
+  startBlock: int,
+  endBlock: option<int>,
+  numAddresses: int,
+}
+let toChainData: t => chainData
+let toChainMetadata: t => InternalTable.Chains.metaFields
+let toChainBeforeBatch: t => Batch.chainBeforeBatch
+let isReadyToEnterReorgThresholdAfterBatch: (t, ~batch: Batch.t) => bool
+
 // Derived (pure).
 let hasProcessedToEndblock: t => bool
 let getHighestBlockBelowThreshold: t => int
 let isActivelyIndexing: t => bool
 let isReady: t => bool
 let isFetchingAtHead: t => bool
+let isAtHeadWithoutEndBlock: t => bool
+
+// Drop over-fetched events an address-param filter rejects, before contract
+// registration runs on them. Uses the chain's current indexing addresses.
+let filterByClientAddress: (t, array<Internal.item>) => array<Internal.item>
 
 // State transitions. The chain state is mutated only through these.
 let handleQueryResult: (
@@ -65,7 +125,20 @@ let handleQueryResult: (
   ~newItemsWithDcs: array<Internal.item>,
   ~latestFetchedBlock: FetchState.blockNumberAndTimestamp,
   ~knownHeight: int,
+  ~transactionStore: option<TransactionStore.t>,
+  ~blockStore: option<BlockStore.t>,
 ) => unit
+let materializeBatchItems: (
+  t,
+  ~items: array<Internal.item>,
+  ~ecosystem: Ecosystem.name,
+) => promise<unit>
+let materializePageItems: (
+  ~items: array<Internal.item>,
+  ~transactionStore: option<TransactionStore.t>,
+  ~blockStore: option<BlockStore.t>,
+  ~ecosystem: Ecosystem.name,
+) => promise<unit>
 let registerReorgGuard: (
   t,
   ~blockHashes: array<ReorgDetection.blockData>,
@@ -76,7 +149,7 @@ 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 applyBatchProgress: (t, ~batch: Batch.t, ~blockTimestampName: string) => unit
 let markReady: t => unit
 let rollback: (
   t,

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)),
@@ -195,17 +197,21 @@ let svmEventDescriptorSchema = S.schema(s =>
   {
     "discriminator": s.matches(S.option(S.string)),
     "discriminatorByteLen": s.matches(S.int),
-    "includeTransaction": s.matches(S.bool),
+    "transactionFields": s.matches(S.array(Internal.svmTransactionFieldSchema)),
+    "blockFields": s.matches(S.option(S.array(Internal.svmBlockFieldSchema))),
     "includeLogs": s.matches(S.bool),
-    "includeTokenBalances": s.matches(S.bool),
+    // An array of AND-groups OR-ed together: the CLI normalizes both the flat
+    // and `any_of` YAML shapes to `Vec<Vec<SvmAccountFilterJson>>`.
     "accountFilters": s.matches(
       S.option(
         S.array(
-          S.schema(s =>
-            {
-              "position": s.matches(S.int),
-              "values": s.matches(S.array(S.string)),
-            }
+          S.array(
+            S.schema(s =>
+              {
+                "position": s.matches(S.int),
+                "values": s.matches(S.array(S.string)),
+              }
+            ),
           ),
         ),
       ),
@@ -653,7 +659,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     ~events: option<array<_>>,
     ~abi,
     ~chainId: int,
-    ~startBlock: option<int>,
     ~addresses: array<string>,
     ~svmDefinedTypes: JSON.t=JSON.Null,
   ) => {
@@ -676,10 +681,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(
@@ -704,9 +705,9 @@ let fromPublic = (publicConfigJson: JSON.t) => {
                 "svm": option<{
                   "discriminator": option<string>,
                   "discriminatorByteLen": int,
-                  "includeTransaction": bool,
+                  "transactionFields": array<Internal.svmTransactionField>,
+                  "blockFields": option<array<Internal.svmBlockField>>,
                   "includeLogs": bool,
-                  "includeTokenBalances": bool,
                   "accountFilters": option<
                     array<array<{"position": int, "values": array<string>}>>,
                   >,
@@ -740,18 +741,14 @@ let fromPublic = (publicConfigJson: JSON.t) => {
             ~programId,
             ~discriminator=svm["discriminator"],
             ~discriminatorByteLen=svm["discriminatorByteLen"],
-            ~includeTransaction=svm["includeTransaction"],
+            ~transactionFields=svm["transactionFields"],
+            ~blockFields=?svm["blockFields"],
             ~includeLogs=svm["includeLogs"],
-            ~includeTokenBalances=svm["includeTokenBalances"],
             ~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(
@@ -759,15 +756,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)
@@ -819,17 +809,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"])
@@ -910,6 +897,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
               sourceFor: parseRpcSourceFor(rpcConfig["for"]),
               syncConfig,
               ws: rpcConfig["ws"],
+              headers: rpcConfig["headers"],
             }
           })
         EvmSourceConfig({hypersync: publicChainConfig["hypersync"], rpcs})
@@ -1018,6 +1006,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 +1291,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

@@ -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)),
@@ -111,13 +112,13 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
 let svmEventDescriptorSchema = S$RescriptSchema.schema(s => ({
   discriminator: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   discriminatorByteLen: s.m(S$RescriptSchema.int),
-  includeTransaction: s.m(S$RescriptSchema.bool),
+  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),
-  includeTokenBalances: s.m(S$RescriptSchema.bool),
-  accountFilters: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
+  accountFilters: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
     position: s.m(S$RescriptSchema.int),
     values: s.m(S$RescriptSchema.array(S$RescriptSchema.string))
-  }))))),
+  })))))),
   isInner: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
   accounts: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
   args: s.m(S$RescriptSchema.option(S$RescriptSchema.json(false)))
@@ -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.includeTransaction, svm.includeLogs, svm.includeTokenBalances, 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,
@@ -607,7 +608,8 @@ function fromPublic(publicConfigJson) {
             url: rpcConfig.url,
             sourceFor: parseRpcSourceFor(rpcConfig.for),
             syncConfig: syncConfig,
-            ws: rpcConfig.ws
+            ws: rpcConfig.ws,
+            headers: rpcConfig.headers
           };
         });
         sourceConfig = {
@@ -705,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) {
@@ -974,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;
@@ -1011,6 +1049,8 @@ export {
   publicConfigStorageSchema,
   publicConfigSchema,
   fromPublic,
+  normalizeUserAddress,
+  normalizeSimulateAddress,
   getEventConfig,
   shouldSaveHistory,
   shouldPruneHistory,
@@ -1021,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

@@ -6,23 +6,42 @@
 // tighter `Null.t` captures the exact boundary shape.
 type evmHypersyncClientCtor
 type evmRpcClientCtor
-type evmDecoderCtor
 type svmHypersyncClientCtor
 type hyperfuelClientCtor
+type transactionStoreCtor
+type blockStoreCtor
+type parseConfigYamlOptions = {
+  schema?: string,
+  env?: dict<string>,
+  files?: dict<string>,
+  isRescript?: bool,
+}
 
 type addon = {
   getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
+  encodeIndexedTopic: (~abiType: string, ~value: unknown) => EvmTypes.Hex.t,
+  parseConfigYaml: (string, parseConfigYamlOptions) => string,
   runCli: (~args: array<string>, ~envioPackageDir: Null.t<string>) => promise<Null.t<string>>,
   @as("EvmHypersyncClient")
   evmHypersyncClient: evmHypersyncClientCtor,
   @as("EvmRpcClient")
   evmRpcClient: evmRpcClientCtor,
-  @as("EvmDecoder")
-  evmDecoder: evmDecoderCtor,
   @as("SvmHypersyncClient")
   svmHypersyncClient: svmHypersyncClientCtor,
   @as("HyperfuelClient")
   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"
@@ -186,6 +205,18 @@ let getConfigJson = (~configPath=?, ~directory=?) => {
   )
 }
 
+// Pure config entry point: no cwd, config file, schema file, .env, or process env lookup.
+// A supplied schema is authoritative; omitted or blank schema text means an empty schema.
+let parseConfigYaml = (~schema=?, ~env=?, ~files=?, ~isRescript=false, yaml) => {
+  let addon = getAddon()
+  addon.parseConfigYaml(yaml, {
+    ?schema,
+    ?env,
+    ?files,
+    isRescript,
+  })
+}
+
 let runCli = args => {
   let addon = getAddon()
   addon.runCli(~args, ~envioPackageDir=Null.make(envioPackageDir))

package/src/Core.res.mjs

@@ -180,6 +180,17 @@ function getConfigJson(configPath, directory) {
   return addon.getConfigJson(Stdlib_Null.fromOption(configPath), Stdlib_Null.fromOption(directory));
 }
 
+function parseConfigYaml(schema, env, files, isRescriptOpt, yaml) {
+  let isRescript = isRescriptOpt !== undefined ? isRescriptOpt : false;
+  let addon = getAddon();
+  return addon.parseConfigYaml(yaml, {
+    schema: schema,
+    env: env,
+    files: files,
+    isRescript: isRescript
+  });
+}
+
 function runCli(args) {
   let addon = getAddon();
   return addon.runCli(args, envioPackageDir);
@@ -196,6 +207,7 @@ export {
   addonRef,
   getAddon,
   getConfigJson,
+  parseConfigYaml,
   runCli,
 }
 /* envioPackageDir Not a pure module */