envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/Config.res

@@ -1,5 +1,3 @@
-open Belt
-
 type sourceSyncOptions = {
   initialBlockInterval?: int,
   backoffMultiplicative?: float,
@@ -21,7 +19,7 @@ type contract = {
   eventSignatures: array<string>,
 }
 
-// Source config parsed from internal.config.json - sources are created lazily in ChainFetcher
+// Sources are instantiated lazily in ChainFetcher from this config.
 type evmRpcConfig = {
   url: string,
   sourceFor: Source.sourceFor,
@@ -62,6 +60,11 @@ type multichain = Internal.multichain =
   | @as("ordered") Ordered
   | @as("unordered") Unordered
 
+type storage = {
+  postgres: bool,
+  clickhouse: bool,
+}
+
 type contractHandler = {
   name: string,
   handler: option<string>,
@@ -74,6 +77,7 @@ type t = {
   contractHandlers: array<contractHandler>,
   shouldRollbackOnReorg: bool,
   shouldSaveFullHistory: bool,
+  storage: storage,
   multichain: multichain,
   chainMap: ChainMap.t<chain>,
   defaultChain: option<chain>,
@@ -82,45 +86,44 @@ type t = {
   maxAddrInPartition: int,
   batchSize: int,
   lowercaseAddresses: bool,
-  addContractNameToContractNameMapping: dict<string>,
   userEntitiesByName: dict<Internal.entityConfig>,
   userEntities: array<Internal.entityConfig>,
   allEntities: array<Internal.entityConfig>,
   allEnums: array<Table.enumConfig<Table.enum>>,
 }
 
-module DynamicContractRegistry = {
-  let name = "dynamic_contract_registry"
+module EnvioAddresses = {
+  let name = "envio_addresses"
   let index = -1
 
-  let makeId = (~chainId, ~contractAddress) => {
-    chainId->Belt.Int.toString ++ "-" ++ contractAddress->Address.toString
+  let makeId = (~chainId, ~address) => {
+    chainId->Belt.Int.toString ++ "-" ++ address->Address.toString
   }
 
-  @genType
   type t = {
     id: string,
     @as("chain_id") chainId: int,
-    @as("registering_event_block_number") registeringEventBlockNumber: int,
-    @as("registering_event_log_index") registeringEventLogIndex: int,
-    @as("registering_event_block_timestamp") registeringEventBlockTimestamp: int,
-    @as("registering_event_contract_name") registeringEventContractName: string,
-    @as("registering_event_name") registeringEventName: string,
-    @as("registering_event_src_address") registeringEventSrcAddress: Address.t,
-    @as("contract_address") contractAddress: Address.t,
+    @as("registration_block") registrationBlock: int,
+    // -1 when the address was registered from a block handler (no log index)
+    @as("registration_log_index") registrationLogIndex: int,
     @as("contract_name") contractName: string,
   }
 
+  // Extract the raw contract address from the composite id ({chainId}-{address}).
+  // Inverse of makeId. Keep in sync with makeId above and the SUBSTRING SQL in
+  // InternalTable.Chains.makeGetInitialStateQuery.
+  let getAddress = (entity: t): Address.t => {
+    let sepIdx = entity.id->String.indexOf("-")
+    entity.id
+    ->String.slice(~start=sepIdx + 1, ~end=entity.id->String.length)
+    ->Address.unsafeFromString
+  }
+
   let schema = S.schema(s => {
     id: s.matches(S.string),
     chainId: s.matches(S.int),
-    registeringEventBlockNumber: s.matches(S.int),
-    registeringEventLogIndex: s.matches(S.int),
-    registeringEventContractName: s.matches(S.string),
-    registeringEventName: s.matches(S.string),
-    registeringEventSrcAddress: s.matches(Address.schema),
-    registeringEventBlockTimestamp: s.matches(S.int),
-    contractAddress: s.matches(Address.schema),
+    registrationBlock: s.matches(S.int),
+    registrationLogIndex: s.matches(S.int),
     contractName: s.matches(S.string),
   })
 
@@ -131,13 +134,9 @@ module DynamicContractRegistry = {
     ~fields=[
       Table.mkField("id", String, ~isPrimaryKey=true, ~fieldSchema=S.string),
       Table.mkField("chain_id", Int32, ~fieldSchema=S.int),
-      Table.mkField("registering_event_block_number", Int32, ~fieldSchema=S.int),
-      Table.mkField("registering_event_log_index", Int32, ~fieldSchema=S.int),
-      Table.mkField("registering_event_block_timestamp", Int32, ~fieldSchema=S.int),
-      Table.mkField("registering_event_contract_name", String, ~fieldSchema=S.string),
-      Table.mkField("registering_event_name", String, ~fieldSchema=S.string),
-      Table.mkField("registering_event_src_address", String, ~fieldSchema=Address.schema),
-      Table.mkField("contract_address", String, ~fieldSchema=Address.schema),
+      Table.mkField("registration_block", Int32, ~fieldSchema=S.int),
+      // -1 sentinel when registered from a block handler (no log index)
+      Table.mkField("registration_log_index", Int32, ~fieldSchema=S.int),
       Table.mkField("contract_name", String, ~fieldSchema=S.string),
     ],
   )
@@ -153,7 +152,6 @@ module DynamicContractRegistry = {
   }->Internal.fromGenericEntityConfig
 }
 
-// Types for parsing source config from internal.config.json
 type rpcSourceFor = | @as("sync") Sync | @as("fallback") Fallback | @as("live") Live
 
 let rpcSourceForSchema = S.enum([Sync, Fallback, Live])
@@ -281,18 +279,18 @@ let entityJsonSchema = S.schema(s =>
 
 let getFieldTypeAndSchema = (prop, ~enumConfigsByName: dict<Table.enumConfig<Table.enum>>) => {
   let typ = prop["type"]
-  let isNullable = prop["isNullable"]->Option.getWithDefault(false)
-  let isArray = prop["isArray"]->Option.getWithDefault(false)
-  let isIndex = prop["isIndex"]->Option.getWithDefault(false)
+  let isNullable = prop["isNullable"]->Option.getOr(false)
+  let isArray = prop["isArray"]->Option.getOr(false)
+  let isIndex = prop["isIndex"]->Option.getOr(false)
 
   let (fieldType, baseSchema) = switch typ {
   | "string" => (Table.String, S.string->S.toUnknown)
   | "boolean" => (Table.Boolean, S.bool->S.toUnknown)
   | "int" => (Table.Int32, S.int->S.toUnknown)
-  | "bigint" => (Table.BigInt({precision: ?prop["precision"]}), BigInt.schema->S.toUnknown)
+  | "bigint" => (Table.BigInt({precision: ?prop["precision"]}), Utils.BigInt.schema->S.toUnknown)
   | "bigdecimal" => (
       Table.BigDecimal({
-        config: ?prop["precision"]->Option.map(p => (p, prop["scale"]->Option.getWithDefault(0))),
+        config: ?(prop["precision"]->Option.map(p => (p, prop["scale"]->Option.getOr(0)))),
       }),
       BigDecimal.schema->S.toUnknown,
     )
@@ -301,18 +299,27 @@ let getFieldTypeAndSchema = (prop, ~enumConfigsByName: dict<Table.enumConfig<Tab
   | "json" => (Table.Json, S.json(~validate=false)->S.toUnknown)
   | "date" => (Table.Date, Utils.Schema.dbDate->S.toUnknown)
   | "enum" => {
-      let enumName = prop["enum"]->Option.getExn
-      let enumConfig =
-        enumConfigsByName
-        ->Js.Dict.get(enumName)
-        ->Option.getExn
+      let enumName = prop["enum"]->Option.getOrThrow
+
+      // Build contracts for this chain from per-chain contract data + contract configs
+
+      // Get per-chain contract data (addresses, startBlock)
+
+      // Build event configs from JSON (field selections resolved inline)
+
+      // Build sourceConfig from the parsed chain config
+
+      // Build syncConfig from flattened fields
+
+      // Fuel doesn't have reorgs, SVM reorg handling is not supported
+      let enumConfig = enumConfigsByName->Dict.get(enumName)->Option.getOrThrow
       (Table.Enum({config: enumConfig}), enumConfig.schema->S.toUnknown)
     }
   | "entity" => {
-      let entityName = prop["entity"]->Option.getExn
+      let entityName = prop["entity"]->Option.getOrThrow
       (Table.Entity({name: entityName}), S.string->S.toUnknown)
     }
-  | other => Js.Exn.raiseError("Unknown field type in entity config: " ++ other)
+  | other => JsError.throwWithMessage("Unknown field type in entity config: " ++ other)
   }
 
   let fieldSchema = if isArray {
@@ -331,7 +338,7 @@ let getFieldTypeAndSchema = (prop, ~enumConfigsByName: dict<Table.enumConfig<Tab
 
 let parseEnumsFromJson = (enumsJson: dict<array<string>>): array<Table.enumConfig<Table.enum>> => {
   enumsJson
-  ->Js.Dict.entries
+  ->Dict.toArray
   ->Array.map(((name, variants)) =>
     Table.makeEnumConfig(~name, ~variants)->Table.fromGenericEnumConfig
   )
@@ -341,7 +348,7 @@ let parseEntitiesFromJson = (
   entitiesJson: array<'entityJson>,
   ~enumConfigsByName: dict<Table.enumConfig<Table.enum>>,
 ): array<Internal.entityConfig> => {
-  entitiesJson->Array.mapWithIndex((index, entityJson) => {
+  entitiesJson->Array.mapWithIndex((entityJson, index) => {
     let entityName = entityJson["name"]
 
     let fields: array<Table.fieldOrDerived> = entityJson["properties"]->Array.map(prop => {
@@ -363,7 +370,7 @@ let parseEntitiesFromJson = (
 
     let derivedFields: array<Table.fieldOrDerived> =
       entityJson["derivedFields"]
-      ->Option.getWithDefault([])
+      ->Option.getOr([])
       ->Array.map(df =>
         Table.mkDerivedFromField(
           df["fieldName"],
@@ -374,7 +381,7 @@ let parseEntitiesFromJson = (
 
     let compositeIndices =
       entityJson["compositeIndices"]
-      ->Option.getWithDefault([])
+      ->Option.getOr([])
       ->Array.map(ci =>
         ci->Array.map(
           f => {
@@ -394,7 +401,7 @@ let parseEntitiesFromJson = (
     // Use db field names (with _id suffix for linked entities) as schema locations
     // to match the database column names used in Table.toSqlParams
     let schema = S.schema(s => {
-      let dict = Js.Dict.empty()
+      let dict = Dict.make()
       entityJson["properties"]->Array.forEach(
         prop => {
           let (_, fieldSchema, _, _, _) = getFieldTypeAndSchema(prop, ~enumConfigsByName)
@@ -402,7 +409,7 @@ let parseEntitiesFromJson = (
           | Some(_) => prop["name"] ++ "_id"
           | None => prop["name"]
           }
-          dict->Js.Dict.set(dbFieldName, s.matches(fieldSchema))
+          dict->Dict.set(dbFieldName, s.matches(fieldSchema))
         },
       )
       dict
@@ -420,6 +427,13 @@ let parseEntitiesFromJson = (
   })
 }
 
+let publicConfigStorageSchema = S.schema(s =>
+  {
+    "postgres": s.matches(S.bool),
+    "clickhouse": s.matches(S.option(S.bool)),
+  }
+)
+
 let publicConfigSchema = S.schema(s =>
   {
     "name": s.matches(S.string),
@@ -430,6 +444,7 @@ let publicConfigSchema = S.schema(s =>
     "rollbackOnReorg": s.matches(S.option(S.bool)),
     "saveFullHistory": s.matches(S.option(S.bool)),
     "rawEvents": s.matches(S.option(S.bool)),
+    "storage": s.matches(publicConfigStorageSchema),
     "evm": s.matches(S.option(publicConfigEvmSchema)),
     "fuel": s.matches(S.option(publicConfigEcosystemSchema)),
     "svm": s.matches(S.option(publicConfigEcosystemSchema)),
@@ -438,12 +453,13 @@ let publicConfigSchema = S.schema(s =>
   }
 )
 
-let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
+let fromPublic = (publicConfigJson: JSON.t) => {
+  let maxAddrInPartition = Env.maxAddrInPartition
   // Parse public config
   let publicConfig = try publicConfigJson->S.parseOrThrow(publicConfigSchema) catch {
   | S.Raised(exn) =>
-    Js.Exn.raiseError(
-      `Invalid internal.config.ts: ${exn->Utils.prettifyExn->(Utils.magic: exn => string)}`,
+    JsError.throwWithMessage(
+      `Invalid indexer config: ${exn->Utils.prettifyExn->(Utils.magic: exn => string)}`,
     )
   }
 
@@ -457,16 +473,22 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
   | (None, Some(ecosystemConfig), None) => (ecosystemConfig["chains"], Ecosystem.Fuel)
   | (None, None, Some(ecosystemConfig)) => (ecosystemConfig["chains"], Ecosystem.Svm)
   | (None, None, None) =>
-    Js.Exn.raiseError("Invalid indexer config: No ecosystem configured (evm, fuel, or svm)")
+    JsError.throwWithMessage("Invalid indexer config: No ecosystem configured (evm, fuel, or svm)")
   | _ =>
-    Js.Exn.raiseError(
+    JsError.throwWithMessage(
       "Invalid indexer config: Multiple ecosystems are not supported for a single indexer",
     )
   }
 
+  let ecosystem = switch ecosystemName {
+  | Ecosystem.Evm => Evm.ecosystem
+  | Ecosystem.Fuel => Fuel.ecosystem
+  | Ecosystem.Svm => Svm.ecosystem
+  }
+
   // Extract EVM-specific options with defaults
   let lowercaseAddresses = switch publicConfig["evm"] {
-  | Some(evm) => evm["addressFormat"]->Option.getWithDefault(Checksum) == Lowercase
+  | Some(evm) => evm["addressFormat"]->Option.getOr(Checksum) == Lowercase
   | None => false
   }
 
@@ -483,32 +505,32 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
       Utils.Set.fromArray(
         Array.concat(
           EventConfigBuilder.alwaysIncludedBlockFields,
-          evm["globalBlockFields"]->Option.getWithDefault([]),
+          evm["globalBlockFields"]->Option.getOr([]),
         ),
       ),
-      Utils.Set.fromArray(evm["globalTransactionFields"]->Option.getWithDefault([])),
+      Utils.Set.fromArray(evm["globalTransactionFields"]->Option.getOr([])),
     )
   | None => (Utils.Set.fromArray(EventConfigBuilder.alwaysIncludedBlockFields), Utils.Set.make())
   }
 
   // Build contract data lookup: ABI, event signatures, event configs (keyed by capitalized name)
-  let contractDataByName: Js.Dict.t<{
+  let contractDataByName: dict<{
     "abi": EvmTypes.Abi.t,
     "eventSignatures": array<string>,
     "events": option<array<_>>,
-  }> = Js.Dict.empty()
+  }> = Dict.make()
   switch publicContractsConfig {
   | Some(contractsDict) =>
     contractsDict
-    ->Js.Dict.entries
+    ->Dict.toArray
     ->Array.forEach(((contractName, contractConfig)) => {
       let capitalizedName = contractName->Utils.String.capitalize
-      let abi = contractConfig["abi"]->(Utils.magic: Js.Json.t => EvmTypes.Abi.t)
+      let abi = contractConfig["abi"]->(Utils.magic: JSON.t => EvmTypes.Abi.t)
       let eventSignatures = switch contractConfig["events"] {
       | Some(events) => events->Array.map(eventItem => eventItem["event"])
       | None => []
       }
-      contractDataByName->Js.Dict.set(
+      contractDataByName->Dict.set(
         capitalizedName,
         {"abi": abi, "eventSignatures": eventSignatures, "events": contractConfig["events"]},
       )
@@ -517,19 +539,21 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
   }
 
   // Build event configs for a contract from JSON event items
-  let buildContractEvents = (~contractName, ~events: option<array<_>>, ~abi) => {
+  let buildContractEvents = (
+    ~contractName,
+    ~events: option<array<_>>,
+    ~abi,
+    ~chainId: int,
+    ~startBlock: option<int>,
+  ) => {
     switch events {
     | None => []
     | Some(eventItems) =>
       eventItems->Array.map(eventItem => {
         let eventName = eventItem["name"]
         let sighash = eventItem["sighash"]
-        let params = eventItem["params"]->Option.getWithDefault([])
+        let params = eventItem["params"]->Option.getOr([])
         let kind = eventItem["kind"]
-        // Get handler registration data
-        let isWildcard = HandlerRegister.isWildcard(~contractName, ~eventName)
-        let handler = HandlerRegister.getHandler(~contractName, ~eventName)
-        let contractRegister = HandlerRegister.getContractRegister(~contractName, ~eventName)
 
         switch ecosystemName {
         | Ecosystem.Fuel =>
@@ -540,13 +564,14 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
               ~eventName,
               ~kind=fuelKind,
               ~sighash,
-              ~rawAbi=abi->(Utils.magic: EvmTypes.Abi.t => Js.Json.t),
-              ~isWildcard,
-              ~handler,
-              ~contractRegister,
+              ~rawAbi=abi->(Utils.magic: EvmTypes.Abi.t => JSON.t),
+              ~isWildcard=false,
+              ~handler=None,
+              ~contractRegister=None,
+              ~startBlock?,
             ) :> Internal.eventConfig)
           | None =>
-            Js.Exn.raiseError(
+            JsError.throwWithMessage(
               `Fuel event ${contractName}.${eventName} is missing "kind" in internal config`,
             )
           }
@@ -556,12 +581,15 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
             ~eventName,
             ~sighash,
             ~params,
-            ~isWildcard,
-            ~handler,
-            ~contractRegister,
-            ~eventFilters=HandlerRegister.getEventFilters(~contractName, ~eventName),
+            ~isWildcard=false,
+            ~handler=None,
+            ~contractRegister=None,
+            ~eventFilters=None,
+            ~probeChainId=chainId,
+            ~onEventBlockFilterSchema=ecosystem.onEventBlockFilterSchema,
             ~blockFields=?eventItem["blockFields"],
             ~transactionFields=?eventItem["transactionFields"],
+            ~startBlock?,
             ~globalBlockFieldsSet,
             ~globalTransactionFieldsSet,
           ) :> Internal.eventConfig)
@@ -595,31 +623,35 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
   // Build chains from JSON config (no more codegenChains)
   let chains =
     publicChainsConfig
-    ->Js.Dict.keys
-    ->Js.Array2.map(chainName => {
-      let publicChainConfig = publicChainsConfig->Js.Dict.unsafeGet(chainName)
+    ->Dict.keysToArray
+    ->Array.map(chainName => {
+      let publicChainConfig = publicChainsConfig->Dict.getUnsafe(chainName)
       let chainId = publicChainConfig["id"]
 
-      // Build contracts for this chain from per-chain contract data + contract configs
-      let chainContracts = publicChainConfig["contracts"]->Option.getWithDefault(Js.Dict.empty())
+      let chainContracts = publicChainConfig["contracts"]->Option.getOr(Dict.make())
       let contracts =
         contractDataByName
-        ->Js.Dict.entries
+        ->Dict.toArray
         ->Array.map(((capitalizedName, contractData)) => {
-          // Get per-chain contract data (addresses, startBlock)
-          let chainContract = chainContracts->Js.Dict.get(capitalizedName)
+          let chainContract = chainContracts->Dict.get(capitalizedName)
           let addresses =
             chainContract
             ->Option.flatMap(cc => cc["addresses"])
-            ->Option.getWithDefault([])
+            ->Option.getOr([])
             ->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.
           let events = buildContractEvents(
             ~contractName=capitalizedName,
             ~events=contractData["events"],
             ~abi=contractData["abi"],
+            ~chainId,
+            ~startBlock,
           )
 
           {
@@ -632,14 +664,12 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
           }
         })
 
-      // Build sourceConfig from the parsed chain config
       let sourceConfig = switch ecosystemName {
       | Ecosystem.Evm =>
         let rpcs =
           publicChainConfig["rpcs"]
-          ->Option.getWithDefault([])
+          ->Option.getOr([])
           ->Array.map((rpcConfig): evmRpcConfig => {
-            // Build syncConfig from flattened fields
             let initialBlockInterval = rpcConfig["initialBlockInterval"]
             let backoffMultiplicative = rpcConfig["backoffMultiplicative"]
             let accelerationAdditive = rpcConfig["accelerationAdditive"]
@@ -682,12 +712,13 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
       | Ecosystem.Fuel =>
         switch publicChainConfig["hypersync"] {
         | Some(hypersync) => FuelSourceConfig({hypersync: hypersync})
-        | None => Js.Exn.raiseError(`Chain ${chainName} is missing hypersync endpoint in config`)
+        | None =>
+          JsError.throwWithMessage(`Chain ${chainName} is missing hypersync endpoint in config`)
         }
       | Ecosystem.Svm =>
         switch publicChainConfig["rpc"] {
         | Some(rpc) => SvmSourceConfig({rpc: rpc})
-        | None => Js.Exn.raiseError(`Chain ${chainName} is missing rpc endpoint in config`)
+        | None => JsError.throwWithMessage(`Chain ${chainName} is missing rpc endpoint in config`)
         }
       }
 
@@ -697,11 +728,11 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
         startBlock: publicChainConfig["startBlock"],
         endBlock: ?publicChainConfig["endBlock"],
         maxReorgDepth: switch ecosystemName {
-        | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getWithDefault(200)
-        // Fuel doesn't have reorgs, SVM reorg handling is not supported
+        | Ecosystem.Evm => publicChainConfig["maxReorgDepth"]->Option.getOr(200)
+
         | Ecosystem.Fuel | Ecosystem.Svm => 0
         },
-        blockLag: publicChainConfig["blockLag"]->Option.getWithDefault(0),
+        blockLag: publicChainConfig["blockLag"]->Option.getOr(0),
         contracts,
         sourceConfig,
       }
@@ -709,57 +740,40 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
 
   let chainMap =
     chains
-    ->Js.Array2.map(chain => {
+    ->Array.map(chain => {
       (ChainMap.Chain.makeUnsafe(~chainId=chain.id), chain)
     })
     ->ChainMap.fromArrayUnsafe
 
-  // Build the contract name mapping for efficient lookup
-  let addContractNameToContractNameMapping = Js.Dict.empty()
-  chains->Array.forEach(chainConfig => {
-    chainConfig.contracts->Array.forEach(contract => {
-      let addKey = "add" ++ contract.name->Utils.String.capitalize
-      addContractNameToContractNameMapping->Js.Dict.set(addKey, contract.name)
-    })
-  })
-
-  let ecosystem = switch ecosystemName {
-  | Ecosystem.Evm => Evm.ecosystem
-  | Ecosystem.Fuel => Fuel.ecosystem
-  | Ecosystem.Svm => Svm.ecosystem
-  }
-
   // Parse enums and entities from JSON config
   let allEnums =
     publicConfig["enums"]
-    ->Option.getWithDefault(Js.Dict.empty())
+    ->Option.getOr(Dict.make())
     ->parseEnumsFromJson
 
   let enumConfigsByName =
-    allEnums
-    ->Js.Array2.map(enumConfig => (enumConfig.name, enumConfig))
-    ->Js.Dict.fromArray
+    allEnums->Array.map(enumConfig => (enumConfig.name, enumConfig))->Dict.fromArray
 
   let userEntities =
     publicConfig["entities"]
-    ->Option.getWithDefault([])
+    ->Option.getOr([])
     ->parseEntitiesFromJson(~enumConfigsByName)
 
-  let allEntities = userEntities->Js.Array2.concat([DynamicContractRegistry.entityConfig])
+  let allEntities = userEntities->Array.concat([EnvioAddresses.entityConfig])
 
   let userEntitiesByName =
     userEntities
-    ->Js.Array2.map(entityConfig => {
+    ->Array.map(entityConfig => {
       (entityConfig.name, entityConfig)
     })
-    ->Js.Dict.fromArray
+    ->Dict.fromArray
 
   // Extract contract handlers from the public config
   let contractHandlers = switch publicContractsConfig {
   | Some(contractsDict) =>
     contractsDict
-    ->Js.Dict.entries
-    ->Js.Array2.map(((contractName, contractConfig)) => {
+    ->Dict.toArray
+    ->Array.map(((contractName, contractConfig)) => {
       {
         name: contractName->Utils.String.capitalize,
         handler: contractConfig["handler"],
@@ -771,19 +785,22 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
   {
     name: publicConfig["name"],
     description: publicConfig["description"],
-    handlers: publicConfig["handlers"]->Option.getWithDefault("src/handlers"),
+    handlers: publicConfig["handlers"]->Option.getOr("src/handlers"),
     contractHandlers,
-    shouldRollbackOnReorg: publicConfig["rollbackOnReorg"]->Option.getWithDefault(true),
-    shouldSaveFullHistory: publicConfig["saveFullHistory"]->Option.getWithDefault(false),
-    multichain: publicConfig["multichain"]->Option.getWithDefault(Unordered),
+    shouldRollbackOnReorg: publicConfig["rollbackOnReorg"]->Option.getOr(true),
+    shouldSaveFullHistory: publicConfig["saveFullHistory"]->Option.getOr(false),
+    storage: {
+      postgres: publicConfig["storage"]["postgres"],
+      clickhouse: publicConfig["storage"]["clickhouse"]->Option.getOr(false),
+    },
+    multichain: publicConfig["multichain"]->Option.getOr(Unordered),
     chainMap,
     defaultChain: chains->Array.get(0),
-    enableRawEvents: publicConfig["rawEvents"]->Option.getWithDefault(false),
+    enableRawEvents: publicConfig["rawEvents"]->Option.getOr(false),
     ecosystem,
     maxAddrInPartition,
-    batchSize: publicConfig["fullBatchSize"]->Option.getWithDefault(5000),
+    batchSize: publicConfig["fullBatchSize"]->Option.getOr(5000),
     lowercaseAddresses,
-    addContractNameToContractNameMapping,
     userEntitiesByName,
     userEntities,
     allEntities,
@@ -791,18 +808,32 @@ let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
   }
 }
 
-let getEventConfig = (config: t, ~contractName, ~eventName) => {
-  config.chainMap
-  ->ChainMap.values
-  ->Js.Array2.reduce((acc, chain) => {
+// 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`,
+// falls back to the first chain that declares this event.
+let getEventConfig = (config: t, ~contractName, ~eventName, ~chainId: option<int>=?) => {
+  let chains = switch chainId {
+  | Some(chainId) =>
+    let chain = ChainMap.Chain.makeUnsafe(~chainId)
+    switch config.chainMap->ChainMap.get(chain) {
+    | chainConfig => [chainConfig]
+    | exception _ =>
+      JsError.throwWithMessage(
+        `Chain ${chainId->Int.toString} is not configured. Add it to config.yaml or pass a configured chain.`,
+      )
+    }
+  | None => config.chainMap->ChainMap.values
+  }
+  chains->Array.reduce(None, (acc, chain) => {
     switch acc {
     | Some(_) => acc
     | None =>
       chain.contracts
-      ->Js.Array2.find(c => c.name == contractName)
-      ->Belt.Option.flatMap(contract => contract.events->Js.Array2.find(e => e.name == eventName))
+      ->Array.find(c => c.name == contractName)
+      ->Belt.Option.flatMap(contract => contract.events->Array.find(e => e.name == eventName))
     }
-  }, None)
+  })
 }
 
 let shouldSaveHistory = (config, ~isInReorgThreshold) =>
@@ -815,7 +846,34 @@ let getChain = (config, ~chainId) => {
   let chain = ChainMap.Chain.makeUnsafe(~chainId)
   config.chainMap->ChainMap.has(chain)
     ? chain
-    : Js.Exn.raiseError(
+    : JsError.throwWithMessage(
         "No chain with id " ++ chain->ChainMap.Chain.toString ++ " found in config.yaml",
       )
 }
+
+// A CLI command payload already contains the resolved JSON; priming lets
+// downstream callers skip the NAPI `getConfigJson` round-trip. Calling
+// `prime` again invalidates the memo.
+%%private(let primedJson: ref<option<JSON.t>> = ref(None))
+%%private(let cached: ref<option<t>> = ref(None))
+let prime = (json: JSON.t): unit => {
+  primedJson := Some(json)
+  cached := None
+}
+
+// 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 = () =>
+  switch cached.contents {
+  | Some(c) => c
+  | None => {
+      let c = switch primedJson.contents {
+      | Some(json) => json->fromPublic
+      | None => Core.getConfigJson()->JSON.parseOrThrow->fromPublic
+      }
+      cached := Some(c)
+      c
+    }
+  }