envio 3.0.0-alpha.20 → 3.0.0-alpha.21

package/index.d.ts

@@ -15,6 +15,18 @@ export type {
 import type { Address } from "./src/Types.ts";
 export type { EffectCaller, Address } from "./src/Types.ts";
 
+export const TestHelpers: {
+  Addresses: {
+    readonly mockAddresses: readonly [
+      Address, Address, Address, Address, Address,
+      Address, Address, Address, Address, Address,
+      Address, Address, Address, Address, Address,
+      Address, Address, Address, Address, Address,
+    ];
+    readonly defaultAddress: Address;
+  };
+};
+
 /** Utility type to expand/flatten complex types for better IDE display. */
 export type Prettify<T> = { [K in keyof T]: T[K] } & {};
 
@@ -378,11 +390,11 @@ type SvmChain<Id extends number = number> = {
 type IndexerConfigTypes = {
   evm?: {
     chains: Record<string, { id: number }>;
-    contracts?: Record<string, {}>;
+    contracts?: Record<string, Record<string, { eventName: string }>>;
   };
   fuel?: {
     chains: Record<string, { id: number }>;
-    contracts?: Record<string, {}>;
+    contracts?: Record<string, Record<string, { eventName: string }>>;
   };
   svm?: { chains: Record<string, { id: number }> };
   entities?: Record<string, object>;
@@ -526,12 +538,74 @@ export type IndexerFromConfig<Config extends IndexerConfigTypes> = Prettify<
 
 // ============== Test Indexer Types ==============
 
-/** Configuration for a single chain in the test indexer. */
-export type TestIndexerChainConfig = {
-  /** The block number to start processing from. */
-  startBlock: number;
-  /** The block number to stop processing at. */
-  endBlock: number;
+/** Simulate item type for EVM ecosystem. */
+type EvmSimulateItem<Config extends IndexerConfigTypes> =
+  Config["evm"] extends { contracts: infer Contracts extends Record<string, Record<string, any>> }
+    ? {
+        [C in keyof Contracts]: {
+          [E in keyof Contracts[C]]: {
+            /** The contract name as defined in config.yaml. */
+            contract: C;
+            /** The event name as defined in the contract ABI. */
+            event: E;
+            /** Override the source address. Defaults to the first contract address. */
+            srcAddress?: Address;
+            /** Override the log index. Auto-increments by default. */
+            logIndex?: number;
+            /** Override block fields. */
+            block?: Partial<Contracts[C][E]["block"]>;
+            /** Override transaction fields. */
+            transaction?: Partial<Contracts[C][E]["transaction"]>;
+            /** Event parameters. Keys match the event's parameter names. */
+            params?: Partial<Contracts[C][E]["params"]>;
+          };
+        }[keyof Contracts[C]];
+      }[keyof Contracts]
+    : never;
+
+/** Simulate item type for Fuel ecosystem. */
+type FuelSimulateItem<Config extends IndexerConfigTypes> =
+  Config["fuel"] extends { contracts: infer Contracts extends Record<string, Record<string, any>> }
+    ? {
+        [C in keyof Contracts]: {
+          [E in keyof Contracts[C]]: {
+            /** The contract name as defined in config.yaml. */
+            contract: C;
+            /** The event name as defined in the contract ABI. */
+            event: E;
+            /** Override the source address. Defaults to the first contract address. */
+            srcAddress?: Address;
+            /** Override the log index. Auto-increments by default. */
+            logIndex?: number;
+            /** Override block fields. */
+            block?: Partial<Contracts[C][E]["block"]>;
+            /** Override transaction fields. */
+            transaction?: Partial<Contracts[C][E]["transaction"]>;
+            /** Event parameters. Keys match the event's parameter names. */
+            params: Contracts[C][E]["params"];
+          };
+        }[keyof Contracts[C]];
+      }[keyof Contracts]
+    : never;
+
+/** Configuration for a single EVM chain in the test indexer. */
+type EvmTestIndexerChainConfig<Config extends IndexerConfigTypes> = {
+  /** The block number to start processing from. Defaults to config startBlock or progressBlock+1. */
+  startBlock?: number;
+  /** The block number to stop processing at. Defaults to max simulate block number when simulate is provided. */
+  endBlock?: number;
+  /** Simulate items to process instead of fetching from real sources. */
+  simulate?: EvmSimulateItem<Config>[];
+};
+
+/** Configuration for a single Fuel chain in the test indexer. */
+type FuelTestIndexerChainConfig<Config extends IndexerConfigTypes> = {
+  /** The block number to start processing from. Defaults to config startBlock or progressBlock+1. */
+  startBlock?: number;
+  /** The block number to stop processing at. Defaults to max simulate block height when simulate is provided. */
+  endBlock?: number;
+  /** Simulate items to process instead of fetching from real sources. */
+  simulate?: FuelSimulateItem<Config>[];
 };
 
 /** Entity change value containing sets and/or deleted IDs. */
@@ -555,9 +629,13 @@ type ConfigEntities<Config extends IndexerConfigTypes> =
   Config["entities"] extends Record<string, object> ? Config["entities"] : {};
 
 /** Entity operations available on test indexer for direct entity manipulation. */
-type EntityOps<Entity> = {
+type TestIndexerEntityOperations<Entity> = {
   /** Get an entity by ID. Returns undefined if not found. */
   readonly get: (id: string) => Promise<Entity | undefined>;
+  /** Get an entity by ID or throw if not found. */
+  readonly getOrThrow: (id: string, message?: string) => Promise<Entity>;
+  /** Get all entities. */
+  readonly getAll: () => Promise<Entity[]>;
   /** Set (create or update) an entity. */
   readonly set: (entity: Entity) => void;
 };
@@ -566,8 +644,6 @@ type EntityOps<Entity> = {
 type EntityChange<Config extends IndexerConfigTypes> = {
   /** The block where the changes occurred. */
   readonly block: number;
-  /** The block hash (if available). */
-  readonly blockHash?: string;
   /** The chain ID. */
   readonly chainId: number;
   /** Number of events processed in this block. */
@@ -583,34 +659,39 @@ type EntityChange<Config extends IndexerConfigTypes> = {
 };
 
 
-// Helper to extract chain IDs from config for test indexer
-type TestIndexerChainIds<Config extends IndexerConfigTypes> =
-  HasEvm<Config> extends true
-    ? Config["evm"] extends { chains: infer Chains }
-      ? Chains extends Record<string, { id: number }>
-        ? Chains[keyof Chains]["id"]
-        : never
+// Helper to extract chain IDs per ecosystem
+type EvmChainIds<Config extends IndexerConfigTypes> =
+  Config["evm"] extends { chains: infer Chains }
+    ? Chains extends Record<string, { id: number }>
+      ? Chains[keyof Chains]["id"]
       : never
-    : HasFuel<Config> extends true
-    ? Config["fuel"] extends { chains: infer Chains }
-      ? Chains extends Record<string, { id: number }>
-        ? Chains[keyof Chains]["id"]
-        : never
-      : never
-    : HasSvm<Config> extends true
-    ? Config["svm"] extends { chains: infer Chains }
-      ? Chains extends Record<string, { id: number }>
-        ? Chains[keyof Chains]["id"]
-        : never
+    : never;
+
+type FuelChainIds<Config extends IndexerConfigTypes> =
+  Config["fuel"] extends { chains: infer Chains }
+    ? Chains extends Record<string, { id: number }>
+      ? Chains[keyof Chains]["id"]
       : never
     : never;
 
+// Per-ecosystem chain config mappings
+type EvmTestChains<Config extends IndexerConfigTypes> =
+  HasEvm<Config> extends true
+    ? { [K in EvmChainIds<Config>]?: EvmTestIndexerChainConfig<Config> }
+    : {};
+
+type FuelTestChains<Config extends IndexerConfigTypes> =
+  HasFuel<Config> extends true
+    ? { [K in FuelChainIds<Config>]?: FuelTestIndexerChainConfig<Config> }
+    : {};
+
 /** Process configuration for the test indexer, with chains keyed by chain ID. */
 export type TestIndexerProcessConfig<Config extends IndexerConfigTypes> = {
   /** Chain configurations keyed by chain ID. Each chain specifies start and end blocks. */
-  chains: {
-    [K in TestIndexerChainIds<Config>]?: TestIndexerChainConfig;
-  };
+  chains: Prettify<
+    EvmTestChains<Config> &
+    FuelTestChains<Config>
+  >;
 };
 
 /**
@@ -629,7 +710,7 @@ export type TestIndexerFromConfig<Config extends IndexerConfigTypes> = {
   ? SingleEcosystemChains<Config>
   : MultiEcosystemChains<Config>) & {
   /** Entity operations for direct manipulation outside of handlers. */
-  readonly [K in keyof ConfigEntities<Config>]: EntityOps<
+  readonly [K in keyof ConfigEntities<Config>]: TestIndexerEntityOperations<
     ConfigEntities<Config>[K]
   >;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.0.0-alpha.20",
+  "version": "3.0.0-alpha.21",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -43,7 +43,12 @@
     "@clickhouse/client": "1.17.0",
     "@elastic/ecs-pino-format": "1.4.0",
     "@envio-dev/hyperfuel-client": "1.2.2",
-    "@envio-dev/hypersync-client": "1.1.0",
+    "@envio-dev/hypersync-client": "1.3.0",
+    "@fuel-ts/crypto": "0.96.1",
+    "@fuel-ts/errors": "0.96.1",
+    "@fuel-ts/hasher": "0.96.1",
+    "@fuel-ts/math": "0.96.1",
+    "@fuel-ts/utils": "0.96.1",
     "bignumber.js": "9.3.1",
     "eventsource": "4.1.0",
     "express": "4.19.2",
@@ -65,9 +70,9 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.0.0-alpha.20",
-    "envio-linux-arm64": "3.0.0-alpha.20",
-    "envio-darwin-x64": "3.0.0-alpha.20",
-    "envio-darwin-arm64": "3.0.0-alpha.20"
+    "envio-linux-x64": "3.0.0-alpha.21",
+    "envio-linux-arm64": "3.0.0-alpha.21",
+    "envio-darwin-x64": "3.0.0-alpha.21",
+    "envio-darwin-arm64": "3.0.0-alpha.21"
   }
 }

package/src/Config.res

@@ -21,19 +21,6 @@ type contract = {
   eventSignatures: array<string>,
 }
 
-type codegenContract = {
-  name: string,
-  addresses: array<string>,
-  events: array<Internal.eventConfig>,
-  startBlock: option<int>,
-}
-
-// Source config is now parsed from internal.config.json and sources are created lazily
-type codegenChain = {
-  id: int,
-  contracts: array<codegenContract>,
-}
-
 // Source config parsed from internal.config.json - sources are created lazily in ChainFetcher
 type evmRpcConfig = {
   url: string,
@@ -71,7 +58,9 @@ type sourceSync = {
   pollingInterval: int,
 }
 
-type multichain = | @as("ordered") Ordered | @as("unordered") Unordered
+type multichain = Internal.multichain =
+  | @as("ordered") Ordered
+  | @as("unordered") Unordered
 
 type contractHandler = {
   name: string,
@@ -185,6 +174,13 @@ let rpcConfigSchema = S.schema(s =>
   }
 )
 
+let chainContractSchema = S.schema(s =>
+  {
+    "addresses": s.matches(S.option(S.array(S.string))),
+    "startBlock": s.matches(S.option(S.int)),
+  }
+)
+
 let publicConfigChainSchema = S.schema(s =>
   {
     "id": s.matches(S.int),
@@ -197,6 +193,8 @@ let publicConfigChainSchema = S.schema(s =>
     "rpcs": s.matches(S.option(S.array(rpcConfigSchema))),
     // SVM source config
     "rpc": s.matches(S.option(S.string)),
+    // Per-chain contract data (addresses and optional start block)
+    "contracts": s.matches(S.option(S.dict(chainContractSchema))),
   }
 )
 
@@ -204,8 +202,11 @@ let contractEventItemSchema = S.schema(s =>
   {
     "event": s.matches(S.string),
     "name": s.matches(S.string),
-    "blockFields": s.matches(S.option(S.array(S.string))),
-    "transactionFields": s.matches(S.option(S.array(S.string))),
+    "sighash": s.matches(S.string),
+    "params": s.matches(S.option(S.array(EventConfigBuilder.eventParamSchema))),
+    "kind": s.matches(S.option(S.string)),
+    "blockFields": s.matches(S.option(S.array(Internal.evmBlockFieldSchema))),
+    "transactionFields": s.matches(S.option(S.array(Internal.evmTransactionFieldSchema))),
   }
 )
 
@@ -437,71 +438,7 @@ let publicConfigSchema = S.schema(s =>
   }
 )
 
-// Always-included block fields (number, timestamp, hash) are not in the JSON;
-// they're prepended at runtime so they're always present.
-let alwaysIncludedBlockFields: array<Internal.evmBlockField> = [Number, Timestamp, Hash]
-
-// Enrich EVM event configs with field selections from the JSON config.
-// Mutates the event configs in-place to set selectedBlockFields/selectedTransactionFields.
-let enrichEvmFieldSelections = (
-  events: array<Internal.eventConfig>,
-  ~jsonEvents: option<array<_>>,
-  ~globalBlockFieldsSet: Utils.Set.t<Internal.evmBlockField>,
-  ~globalTransactionFieldsSet: Utils.Set.t<Internal.evmTransactionField>,
-) => {
-  // Build a lookup by event name for events with per-event field overrides
-  let fieldsByName: Js.Dict.t<_> = Js.Dict.empty()
-  switch jsonEvents {
-  | Some(jes) =>
-    jes->Array.forEach(je => {
-      let name = je["name"]
-      if je["blockFields"] != None || je["transactionFields"] != None {
-        fieldsByName->Js.Dict.set(name, je)
-      }
-    })
-  | None => ()
-  }
-  events->Js.Array2.forEachi((event, i) => {
-    let evmEvent = event->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
-    let (selectedBlockFields, selectedTransactionFields) = switch fieldsByName->Js.Dict.get(
-      evmEvent.name,
-    ) {
-    | Some(je) => (
-        switch je["blockFields"] {
-        | Some(fields) =>
-          // Prepend always-included block fields for per-event overrides too
-          Utils.Set.fromArray(
-            Array.concat(
-              alwaysIncludedBlockFields,
-              fields->(Utils.magic: array<string> => array<Internal.evmBlockField>),
-            ),
-          )
-        | None => globalBlockFieldsSet
-        },
-        switch je["transactionFields"] {
-        | Some(fields) =>
-          Utils.Set.fromArray(
-            fields->(Utils.magic: array<string> => array<Internal.evmTransactionField>),
-          )
-        | None => globalTransactionFieldsSet
-        },
-      )
-    | None => (globalBlockFieldsSet, globalTransactionFieldsSet)
-    }
-    events->Js.Array2.unsafe_set(
-      i,
-      {...evmEvent, selectedBlockFields, selectedTransactionFields}->(
-        Utils.magic: Internal.evmEventConfig => Internal.eventConfig
-      ),
-    )
-  })
-}
-
-let fromPublic = (
-  publicConfigJson: Js.Json.t,
-  ~codegenChains: array<codegenChain>=[],
-  ~maxAddrInPartition=5000,
-) => {
+let fromPublic = (publicConfigJson: Js.Json.t, ~maxAddrInPartition=5000) => {
   // Parse public config
   let publicConfig = try publicConfigJson->S.parseOrThrow(publicConfigSchema) catch {
   | S.Raised(exn) =>
@@ -533,7 +470,7 @@ let fromPublic = (
   | None => false
   }
 
-  // Parse ABIs from public config
+  // Parse contract configs (ABIs, events, handlers)
   let publicContractsConfig = switch (ecosystemName, publicConfig["evm"], publicConfig["fuel"]) {
   | (Ecosystem.Evm, Some(evm), _) => evm["contracts"]
   | (Ecosystem.Fuel, _, Some(fuel)) => fuel["contracts"]
@@ -545,19 +482,21 @@ let fromPublic = (
   | Some(evm) => (
       Utils.Set.fromArray(
         Array.concat(
-          alwaysIncludedBlockFields,
+          EventConfigBuilder.alwaysIncludedBlockFields,
           evm["globalBlockFields"]->Option.getWithDefault([]),
         ),
       ),
       Utils.Set.fromArray(evm["globalTransactionFields"]->Option.getWithDefault([])),
     )
-  | None => (Utils.Set.fromArray(alwaysIncludedBlockFields), Utils.Set.make())
+  | None => (Utils.Set.fromArray(EventConfigBuilder.alwaysIncludedBlockFields), Utils.Set.make())
   }
 
-  // Store ABI and event signatures for each contract
-  let contractsWithAbis: Js.Dict.t<(EvmTypes.Abi.t, array<string>)> = Js.Dict.empty()
-  // Per-event field selection overrides, keyed by capitalized contract name
-  let jsonEventsByContract: Js.Dict.t<array<_>> = Js.Dict.empty()
+  // Build contract data lookup: ABI, event signatures, event configs (keyed by capitalized name)
+  let contractDataByName: Js.Dict.t<{
+    "abi": EvmTypes.Abi.t,
+    "eventSignatures": array<string>,
+    "events": option<array<_>>,
+  }> = Js.Dict.empty()
   switch publicContractsConfig {
   | Some(contractsDict) =>
     contractsDict
@@ -569,68 +508,80 @@ let fromPublic = (
       | Some(events) => events->Array.map(eventItem => eventItem["event"])
       | None => []
       }
-      contractsWithAbis->Js.Dict.set(capitalizedName, (abi, eventSignatures))
-      switch contractConfig["events"] {
-      | Some(events) => jsonEventsByContract->Js.Dict.set(capitalizedName, events)
-      | None => ()
-      }
+      contractDataByName->Js.Dict.set(
+        capitalizedName,
+        {"abi": abi, "eventSignatures": eventSignatures, "events": contractConfig["events"]},
+      )
     })
   | None => ()
   }
 
-  // Index codegenChains by id for efficient lookup
-  let codegenChainById = Js.Dict.empty()
-  codegenChains->Array.forEach(codegenChain => {
-    codegenChainById->Js.Dict.set(codegenChain.id->Int.toString, codegenChain)
-  })
-
-  // Create a dictionary to store merged contracts with ABIs by chain id
-  let contractsByChainId: Js.Dict.t<array<contract>> = Js.Dict.empty()
-  codegenChains->Array.forEach(codegenChain => {
-    let mergedContracts = codegenChain.contracts->Array.map(codegenContract => {
-      switch contractsWithAbis->Js.Dict.get(codegenContract.name) {
-      | Some((abi, eventSignatures)) =>
-        // Parse addresses based on ecosystem and address format
-        let parsedAddresses = codegenContract.addresses->Array.map(
-          addressString => {
-            switch ecosystemName {
-            | Ecosystem.Evm =>
-              if lowercaseAddresses {
-                addressString->Address.Evm.fromStringLowercaseOrThrow
-              } else {
-                addressString->Address.Evm.fromStringOrThrow
-              }
-            | Ecosystem.Fuel | Ecosystem.Svm => addressString->Address.unsafeFromString
-            }
-          },
-        )
-
-        // Enrich EVM event configs with field selections from JSON config
-        if ecosystemName == Ecosystem.Evm {
-          enrichEvmFieldSelections(
-            codegenContract.events,
-            ~jsonEvents=jsonEventsByContract->Js.Dict.get(codegenContract.name),
+  // Build event configs for a contract from JSON event items
+  let buildContractEvents = (~contractName, ~events: option<array<_>>, ~abi) => {
+    switch events {
+    | None => []
+    | Some(eventItems) =>
+      eventItems->Array.map(eventItem => {
+        let eventName = eventItem["name"]
+        let sighash = eventItem["sighash"]
+        let params = eventItem["params"]->Option.getWithDefault([])
+        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 =>
+          switch kind {
+          | Some(fuelKind) =>
+            (EventConfigBuilder.buildFuelEventConfig(
+              ~contractName,
+              ~eventName,
+              ~kind=fuelKind,
+              ~sighash,
+              ~rawAbi=abi->(Utils.magic: EvmTypes.Abi.t => Js.Json.t),
+              ~isWildcard,
+              ~handler,
+              ~contractRegister,
+            ) :> Internal.eventConfig)
+          | None =>
+            Js.Exn.raiseError(
+              `Fuel event ${contractName}.${eventName} is missing "kind" in internal config`,
+            )
+          }
+        | _ =>
+          (EventConfigBuilder.buildEvmEventConfig(
+            ~contractName,
+            ~eventName,
+            ~sighash,
+            ~params,
+            ~isWildcard,
+            ~handler,
+            ~contractRegister,
+            ~eventFilters=HandlerRegister.getEventFilters(~contractName, ~eventName),
+            ~blockFields=?eventItem["blockFields"],
+            ~transactionFields=?eventItem["transactionFields"],
             ~globalBlockFieldsSet,
             ~globalTransactionFieldsSet,
-          )
+          ) :> Internal.eventConfig)
         }
-        // Convert codegenContract to contract by adding abi and eventSignatures
-        {
-          name: codegenContract.name,
-          abi,
-          addresses: parsedAddresses,
-          events: codegenContract.events,
-          startBlock: codegenContract.startBlock,
-          eventSignatures,
-        }
-      | None =>
-        Js.Exn.raiseError(
-          `Contract "${codegenContract.name}" is missing ABI in public config (internal.config.ts)`,
-        )
+      })
+    }
+  }
+
+  // Parse address based on ecosystem and address format
+  let parseAddress = addressString => {
+    switch ecosystemName {
+    | Ecosystem.Evm =>
+      if lowercaseAddresses {
+        addressString->Address.Evm.fromStringLowercaseOrThrow
+      } else {
+        addressString->Address.Evm.fromStringOrThrow
       }
-    })
-    contractsByChainId->Js.Dict.set(codegenChain.id->Int.toString, mergedContracts)
-  })
+    | Ecosystem.Fuel | Ecosystem.Svm => addressString->Address.unsafeFromString
+    }
+  }
 
   // Helper to convert parsed RPC config to evmRpcConfig
   let parseRpcSourceFor = (sourceFor: rpcSourceFor): Source.sourceFor => {
@@ -641,25 +592,45 @@ let fromPublic = (
     }
   }
 
-  // Merge codegenChains with names from publicConfig
+  // 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)
       let chainId = publicChainConfig["id"]
-      let codegenChain = switch codegenChainById->Js.Dict.get(chainId->Int.toString) {
-      | Some(c) => c
-      | None =>
-        Js.Exn.raiseError(`Chain with id ${chainId->Int.toString} not found in codegen chains`)
-      }
-      let mergedContracts = switch contractsByChainId->Js.Dict.get(chainId->Int.toString) {
-      | Some(contracts) => contracts
-      | None =>
-        Js.Exn.raiseError(
-          `Contracts for chain with id ${chainId->Int.toString} not found in merged contracts`,
-        )
-      }
+
+      // Build contracts for this chain from per-chain contract data + contract configs
+      let chainContracts = publicChainConfig["contracts"]->Option.getWithDefault(Js.Dict.empty())
+      let contracts =
+        contractDataByName
+        ->Js.Dict.entries
+        ->Array.map(((capitalizedName, contractData)) => {
+          // Get per-chain contract data (addresses, startBlock)
+          let chainContract = chainContracts->Js.Dict.get(capitalizedName)
+          let addresses =
+            chainContract
+            ->Option.flatMap(cc => cc["addresses"])
+            ->Option.getWithDefault([])
+            ->Array.map(parseAddress)
+          let startBlock = chainContract->Option.flatMap(cc => cc["startBlock"])
+
+          // Build event configs from JSON (field selections resolved inline)
+          let events = buildContractEvents(
+            ~contractName=capitalizedName,
+            ~events=contractData["events"],
+            ~abi=contractData["abi"],
+          )
+
+          {
+            name: capitalizedName,
+            abi: contractData["abi"],
+            addresses,
+            events,
+            startBlock,
+            eventSignatures: contractData["eventSignatures"],
+          }
+        })
 
       // Build sourceConfig from the parsed chain config
       let sourceConfig = switch ecosystemName {
@@ -722,7 +693,7 @@ let fromPublic = (
 
       {
         name: chainName,
-        id: codegenChain.id,
+        id: chainId,
         startBlock: publicChainConfig["startBlock"],
         endBlock: ?publicChainConfig["endBlock"],
         maxReorgDepth: switch ecosystemName {
@@ -731,7 +702,7 @@ let fromPublic = (
         | Ecosystem.Fuel | Ecosystem.Svm => 0
         },
         blockLag: publicChainConfig["blockLag"]->Option.getWithDefault(0),
-        contracts: mergedContracts,
+        contracts,
         sourceConfig,
       }
     })
@@ -820,6 +791,20 @@ let fromPublic = (
   }
 }
 
+let getEventConfig = (config: t, ~contractName, ~eventName) => {
+  config.chainMap
+  ->ChainMap.values
+  ->Js.Array2.reduce((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))
+    }
+  }, None)
+}
+
 let shouldSaveHistory = (config, ~isInReorgThreshold) =>
   config.shouldSaveFullHistory || (config.shouldRollbackOnReorg && isInReorgThreshold)