envio 3.3.0-alpha.0 → 3.3.0-alpha.10

package/src/TestIndexer.res

@@ -43,6 +43,33 @@ let toIndexingAddress = (dc: InternalTable.EnvioAddresses.t): Internal.indexingA
   registrationBlock: dc.registrationBlock,
 }
 
+// All indexing addresses (config-seeded + dynamically registered) grouped by
+// chain id string, derived from the envio_addresses entities.
+let getIndexingAddressesByChain = (state: testIndexerState): dict<
+  array<Internal.indexingAddress>,
+> => {
+  let byChain = Dict.make()
+  switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
+  | Some(dcDict) =>
+    dcDict
+    ->Dict.valuesToArray
+    ->Array.forEach(entity => {
+      let dc = entity->castToEnvioAddresses
+      let chainIdStr = dc.chainId->Int.toString
+      let contracts = switch byChain->Dict.get(chainIdStr) {
+      | Some(arr) => arr
+      | None =>
+        let arr = []
+        byChain->Dict.set(chainIdStr, arr)
+        arr
+      }
+      contracts->Array.push(dc->toIndexingAddress)->ignore
+    })
+  | None => ()
+  }
+  byChain
+}
+
 let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFilter.t): JSON.t => {
   // Loads for non-entity tables (e.g. effect caches `envio_effect_<name>`) reach
   // here too. TestIndexer never persists those, so there's nothing to return —
@@ -566,22 +593,10 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
                   `Cannot access ${contract.name}.addresses while indexer.process() is running. ` ++ "Wait for process() to complete before reading contract addresses.",
                 )
               }
-              let addresses = []
-              switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
-              | Some(dcDict) =>
-                dcDict
-                ->Dict.valuesToArray
-                ->Array.forEach(
-                  entity => {
-                    let dc = entity->castToEnvioAddresses
-                    if dc.contractName === contract.name && dc.chainId === chainConfig.id {
-                      addresses->Array.push(dc->Config.EnvioAddresses.getAddress)->ignore
-                    }
-                  },
-                )
-              | None => ()
-              }
-              addresses
+              getIndexingAddressesByChain(state)
+              ->Dict.get(chainConfig.id->Int.toString)
+              ->Option.getOr([])
+              ->Array.filterMap(ia => ia.contractName === contract.name ? Some(ia.address) : None)
             },
           },
         )
@@ -652,7 +667,7 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             Int.compare(aId, bId)
           })
 
-          // Parse and validate all chain configs upfront before starting any workers
+          // Parse and validate the block ranges upfront before starting any workers.
           let chainEntries = sortedChainKeys->Array.map(chainIdStr => {
             let rawChainConfig = rawChains->Dict.getUnsafe(chainIdStr)
             let chainId = switch chainIdStr->Int.fromString {
@@ -684,26 +699,9 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             let chains: dict<chainConfig> = Dict.make()
             chains->Dict.set(chainIdStr, processChainConfig)
 
-            // Extract dynamic contracts from state.entities for each chain
-            let indexingAddressesByChain: dict<array<Internal.indexingAddress>> = Dict.make()
-            switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
-            | Some(dcDict) =>
-              dcDict
-              ->Dict.valuesToArray
-              ->Array.forEach(entity => {
-                let dc = entity->castToEnvioAddresses
-                let dcChainIdStr = dc.chainId->Int.toString
-                let contracts = switch indexingAddressesByChain->Dict.get(dcChainIdStr) {
-                | Some(arr) => arr
-                | None =>
-                  let arr = []
-                  indexingAddressesByChain->Dict.set(dcChainIdStr, arr)
-                  arr
-                }
-                contracts->Array.push(dc->toIndexingAddress)->ignore
-              })
-            | None => ()
-            }
+            // Rebuilt per chain so workers see contracts registered by earlier
+            // chains in the same process() call.
+            let indexingAddressesByChain = getIndexingAddressesByChain(state)
 
             let initialState = makeInitialState(
               ~config,
@@ -852,7 +850,7 @@ let initTestWorker = () => {
     // Create proxy storage that communicates with main thread
     let proxy = TestIndexerProxyStorage.make(~parentPort, ~initialState)
     let storage = TestIndexerProxyStorage.makeStorage(proxy)
-    let config = Config.loadWithoutRegistrations()
+    let config = Config.load()
     let persistence = Persistence.make(
       ~userEntities=config.userEntities,
       ~allEnums=config.allEnums,
@@ -865,7 +863,7 @@ let initTestWorker = () => {
     | Some(_) => ()
     }
 
-    let patchConfig = (config, _registrations) => {
+    let patchConfig = (config: Config.t, _registrations) => {
       let config = SimulateItems.patchConfig(~config, ~processConfig)
 
       // In auto-exit mode, set batchSize=1 to process one block checkpoint at a time
@@ -875,7 +873,23 @@ let initTestWorker = () => {
         config
       }
     }
-    Main.start(~persistence, ~isTest=true, ~patchConfig, ~exitAfterFirstEventBlock)->ignore
+    Main.start(~persistence, ~isTest=true, ~patchConfig, ~exitAfterFirstEventBlock)
+    ->Promise.catch(exn => {
+      // `Main.start` rejects on any fatal error: a runtime failure arrives wrapped
+      // in `Main.FatalError` (already logged), a setup throw (e.g. an invalid
+      // simulate item) arrives raw. The parent only learns of failures
+      // through the worker `error` event, which fires on an *uncaught* exception.
+      // Throwing synchronously in this catch would just reject the catch's own
+      // promise (swallowed by `ignore`); `setImmediate` re-throws outside the
+      // promise chain so it becomes uncaught and reaches the parent.
+      let toThrow = switch exn {
+      | Main.FatalError(inner) => inner
+      | _ => exn->Utils.prettifyExn
+      }
+      NodeJs.setImmediate(() => throw(toThrow))
+      Promise.resolve()
+    })
+    ->ignore
   | None =>
     Logging.error("TestIndexerWorker: No worker data provided")
     NodeJs.process->NodeJs.exitWithCode(Failure)

package/src/TestIndexer.res.mjs

@@ -12,6 +12,7 @@ import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SimulateItems from "./SimulateItems.res.mjs";
@@ -32,6 +33,27 @@ function toIndexingAddress(dc) {
   };
 }
 
+function getIndexingAddressesByChain(state) {
+  let byChain = {};
+  let dcDict = state.entities[Config.EnvioAddresses.name];
+  if (dcDict !== undefined) {
+    Object.values(dcDict).forEach(entity => {
+      let chainIdStr = entity.chain_id.toString();
+      let arr = byChain[chainIdStr];
+      let contracts;
+      if (arr !== undefined) {
+        contracts = arr;
+      } else {
+        let arr$1 = [];
+        byChain[chainIdStr] = arr$1;
+        contracts = arr$1;
+      }
+      contracts.push(toIndexingAddress(entity));
+    });
+  }
+  return byChain;
+}
+
 function handleLoad(state, tableName, filter) {
   let entityConfig = state.entityConfigs[tableName];
   if (entityConfig === undefined) {
@@ -403,17 +425,11 @@ function makeCreateTestIndexer(config, workerPath) {
             if (state.processInProgress) {
               Stdlib_JsError.throwWithMessage(`Cannot access ` + contract.name + `.addresses while indexer.process() is running. ` + "Wait for process() to complete before reading contract addresses.");
             }
-            let addresses = [];
-            let dcDict = state.entities[Config.EnvioAddresses.name];
-            if (dcDict !== undefined) {
-              Object.values(dcDict).forEach(entity => {
-                if (entity.contract_name === contract.name && entity.chain_id === chainConfig.id) {
-                  addresses.push(Config.EnvioAddresses.getAddress(entity));
-                  return;
-                }
-              });
-            }
-            return addresses;
+            return Stdlib_Array.filterMap(Stdlib_Option.getOr(getIndexingAddressesByChain(state)[chainConfig.id.toString()], []), ia => {
+              if (ia.contractName === contract.name) {
+                return Primitive_option.some(ia.address);
+              }
+            });
           }
         });
         Object.defineProperty(chainObj, contract.name, {
@@ -484,23 +500,7 @@ function makeCreateTestIndexer(config, workerPath) {
         let chainId = param[1];
         let chains = {};
         chains[param[0]] = processChainConfig;
-        let indexingAddressesByChain = {};
-        let dcDict = state.entities[Config.EnvioAddresses.name];
-        if (dcDict !== undefined) {
-          Object.values(dcDict).forEach(entity => {
-            let dcChainIdStr = entity.chain_id.toString();
-            let arr = indexingAddressesByChain[dcChainIdStr];
-            let contracts;
-            if (arr !== undefined) {
-              contracts = arr;
-            } else {
-              let arr$1 = [];
-              indexingAddressesByChain[dcChainIdStr] = arr$1;
-              contracts = arr$1;
-            }
-            contracts.push(toIndexingAddress(entity));
-          });
-        }
+        let indexingAddressesByChain = getIndexingAddressesByChain(state);
         let initialState = makeInitialState(config, chains, indexingAddressesByChain);
         return new Promise((resolve, reject) => {
           let workerData_startBlock = processChainConfig.startBlock;
@@ -605,7 +605,7 @@ function initTestWorker() {
   };
   let proxy = TestIndexerProxyStorage.make(parentPort, workerData.initialState);
   let storage = TestIndexerProxyStorage.makeStorage(proxy);
-  let config = Config.loadWithoutRegistrations();
+  let config = Config.load();
   let persistence = Persistence.make(config.userEntities, config.allEnums, storage);
   if (Env.userLogLevel !== undefined) {
     
@@ -640,11 +640,18 @@ function initTestWorker() {
       return config$1;
     }
   };
-  Main.start(persistence, undefined, true, exitAfterFirstEventBlock, patchConfig);
+  Stdlib_Promise.$$catch(Main.start(persistence, undefined, true, exitAfterFirstEventBlock, patchConfig), exn => {
+    let toThrow = exn.RE_EXN_ID === Main.FatalError ? exn._1 : Utils.prettifyExn(exn);
+    setImmediate(() => {
+      throw toThrow;
+    });
+    return Promise.resolve();
+  });
 }
 
 export {
   toIndexingAddress,
+  getIndexingAddressesByChain,
   handleLoad,
   handleWriteBatch,
   makeInitialState,

package/src/bindings/Performance.res

@@ -0,0 +1,7 @@
+type timeRef = float
+
+@val @scope("performance") external now: unit => timeRef = "now"
+
+let secondsSince = (from: timeRef): float => (now() -. from) /. 1000.
+
+let secondsBetween = (~from: timeRef, ~to: timeRef): float => (to -. from) /. 1000.

package/src/bindings/Performance.res.mjs

@@ -0,0 +1,21 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function secondsSince(from) {
+  return (performance.now() - from) / 1000;
+}
+
+function secondsBetween(from, to) {
+  return (to - from) / 1000;
+}
+
+function now(prim) {
+  return performance.now();
+}
+
+export {
+  now,
+  secondsSince,
+  secondsBetween,
+}
+/* No side effect */

package/src/bindings/Performance.resi

@@ -0,0 +1,7 @@
+type timeRef = float
+
+let now: unit => timeRef
+
+let secondsSince: timeRef => float
+
+let secondsBetween: (~from: timeRef, ~to: timeRef) => float

package/src/bindings/Viem.res

@@ -1,52 +1,11 @@
-type eventLog = {
-  abi: EvmTypes.Abi.t,
-  data: string,
-  topics: array<EvmTypes.Hex.t>,
-}
-
-type decodedEvent<'a> = {
-  eventName: string,
-  args: 'a,
-}
-
-@module("viem") external decodeEventLogOrThrow: eventLog => decodedEvent<'a> = "decodeEventLog"
-
 type hex = EvmTypes.Hex.t
 @module("viem") external toHex: 'a => hex = "toHex"
 @module("viem") external keccak256: hex => hex = "keccak256"
-@module("viem") external keccak256Bytes: Uint8Array.t => hex = "keccak256"
 @module("viem") external pad: hex => hex = "pad"
-@module("viem")
-external encodePacked: (~types: array<string>, ~values: array<'a>) => hex = "encodePacked"
 
 type sizeOptions = {size: int}
-@module("viem") external intToHex: (int, ~options: sizeOptions=?) => hex = "numberToHex"
 @module("viem") external bigintToHex: (bigint, ~options: sizeOptions=?) => hex = "numberToHex"
 @module("viem") external stringToHex: (string, ~options: sizeOptions=?) => hex = "stringToHex"
 @module("viem") external boolToHex: (bool, ~options: sizeOptions=?) => hex = "boolToHex"
 @module("viem") external bytesToHex: (Uint8Array.t, ~options: sizeOptions=?) => hex = "bytesToHex"
 @module("viem") external concat: array<hex> => hex = "concat"
-
-exception ParseError(exn)
-exception UnknownContractName({contractName: string})
-
-let parseLogOrThrow = (
-  contractNameAbiMapping: dict<EvmTypes.Abi.t>,
-  ~contractName,
-  ~topics,
-  ~data,
-) => {
-  switch contractNameAbiMapping->Utils.Dict.dangerouslyGetNonOption(contractName) {
-  | None => throw(UnknownContractName({contractName: contractName}))
-  | Some(abi) =>
-    let viemLog: eventLog = {
-      abi,
-      data,
-      topics,
-    }
-
-    try viemLog->decodeEventLogOrThrow catch {
-    | exn => throw(ParseError(exn))
-    }
-  }
-}

package/src/bindings/Viem.res.mjs

@@ -1,44 +1,2 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Viem from "viem";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-
-let ParseError = /* @__PURE__ */Primitive_exceptions.create("Viem.ParseError");
-
-let UnknownContractName = /* @__PURE__ */Primitive_exceptions.create("Viem.UnknownContractName");
-
-function parseLogOrThrow(contractNameAbiMapping, contractName, topics, data) {
-  let abi = contractNameAbiMapping[contractName];
-  if (abi !== undefined) {
-    let viemLog_abi = Primitive_option.valFromOption(abi);
-    let viemLog = {
-      abi: viemLog_abi,
-      data: data,
-      topics: topics
-    };
-    try {
-      return Viem.decodeEventLog(viemLog);
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      throw {
-        RE_EXN_ID: ParseError,
-        _1: exn,
-        Error: new Error()
-      };
-    }
-  } else {
-    throw {
-      RE_EXN_ID: UnknownContractName,
-      contractName: contractName,
-      Error: new Error()
-    };
-  }
-}
-
-export {
-  ParseError,
-  UnknownContractName,
-  parseLogOrThrow,
-}
-/* viem Not a pure module */
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/sources/BlockStore.res

@@ -0,0 +1,46 @@
+// Binding to the Rust `BlockStore` napi class. Blocks are kept in Rust as raw
+// structs (their large fields never enter JS until read) keyed by block number.
+// One store lives per chain on `ChainState`; each fetch response contributes a
+// page that is merged in. At batch preparation the selected fields are
+// materialised in bulk, off the JS thread, in columnar form and zipped into
+// plain JS objects on the main thread.
+type t
+
+@send external newEvm: (Core.blockStoreCtor, ~shouldChecksum: bool) => t = "newEvm"
+@send external newSvm: Core.blockStoreCtor => t = "newSvm"
+@send external newFuel: Core.blockStoreCtor => t = "newFuel"
+
+// The store's ecosystem is fixed here, from the chain's config. EVM carries the
+// chain's address-checksumming setting; SVM/Fuel need no extra data.
+let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool): t => {
+  let ctor = Core.getAddon().blockStore
+  switch ecosystem {
+  | Evm => ctor->newEvm(~shouldChecksum)
+  | Svm => ctor->newSvm
+  | Fuel => ctor->newFuel
+  }
+}
+
+// One event's selected block fields → store selection bitmask, built from the
+// ecosystem's ordered field-name array (the bit index is the field code shared
+// with the Rust store, `EvmBlockField`).
+let makeMaskFn = FieldMask.makeMaskFn
+
+// Drain another store (a fetch-response page) into this one.
+@send external merge: (t, t) => unit = "merge"
+
+// Bulk-materialise blocks off the JS thread, one row per `blockNumbers[i]` key,
+// decoding only the fields set in that row's own `masks[i]`. Result is aligned
+// with the input.
+@send
+external materialize: (
+  t,
+  ~blockNumbers: array<int>,
+  ~masks: array<float>,
+) => promise<array<Internal.eventBlock>> = "materialize"
+
+// Drop blocks at or below the given block (already processed).
+@send external prune: (t, int) => unit = "prune"
+
+// Drop blocks above the given block (rolled back).
+@send external rollback: (t, int) => unit = "rollback"

package/src/sources/BlockStore.res.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.res.mjs";
+import * as FieldMask from "./FieldMask.res.mjs";
+
+function make(ecosystem, shouldChecksum) {
+  let ctor = Core.getAddon().BlockStore;
+  switch (ecosystem) {
+    case "evm" :
+      return ctor.newEvm(shouldChecksum);
+    case "fuel" :
+      return ctor.newFuel();
+    case "svm" :
+      return ctor.newSvm();
+  }
+}
+
+let makeMaskFn = FieldMask.makeMaskFn;
+
+export {
+  make,
+  makeMaskFn,
+}
+/* Core Not a pure module */

package/src/sources/EventRouter.res

@@ -28,29 +28,25 @@ module Group = {
     }
   }
 
-  let get = (
-    group: t<'a>,
-    ~contractAddress,
-    ~blockNumber,
-    ~indexingAddresses: dict<FetchState.indexingAddress>,
-  ) =>
+  // Ownership only: resolve the owning contract from the partition's reverse
+  // index (the partition that fetched the log), not a chain-wide snapshot. The
+  // `effectiveStartBlock` temporal gate now lives in `clientAddressFilter`. The
+  // wildcard partition has an empty index → every log falls back to `wildcard`,
+  // so it can never claim an address-bound contract's logs.
+  let get = (group: t<'a>, ~contractAddress, ~contractNameByAddress: dict<string>) =>
     switch group {
     | {wildcard, byContractName} =>
-      switch indexingAddresses->Utils.Dict.dangerouslyGetNonOption(
+      switch contractNameByAddress->Utils.Dict.dangerouslyGetNonOption(
         contractAddress->Address.toString,
       ) {
-      | Some(indexingContract) =>
-        if indexingContract.effectiveStartBlock <= blockNumber {
-          switch byContractName->Utils.Dict.dangerouslyGetNonOption(indexingContract.contractName) {
-          // Fall back to the wildcard handler when the indexed contract has no
-          // matching event for this tag. This covers addresses registered for
-          // contracts without events (persisted for future config changes) as
-          // well as addresses whose contract has other events but not this one.
-          | None => wildcard
-          | Some(_) as event => event
-          }
-        } else {
-          None
+      | Some(contractName) =>
+        switch byContractName->Utils.Dict.dangerouslyGetNonOption(contractName) {
+        // Fall back to the wildcard handler when the owning contract has no
+        // matching event for this tag. This covers addresses registered for
+        // contracts without events (persisted for future config changes) as
+        // well as addresses whose contract has other events but not this one.
+        | None => wildcard
+        | Some(_) as event => event
         }
       | None => wildcard
       }
@@ -89,10 +85,10 @@ let addOrThrow = (
   }
 }
 
-let get = (router: t<'a>, ~tag, ~contractAddress, ~blockNumber, ~indexingAddresses) => {
+let get = (router: t<'a>, ~tag, ~contractAddress, ~contractNameByAddress) => {
   switch router->Utils.Dict.dangerouslyGetNonOption(tag) {
   | None => None
-  | Some(group) => group->Group.get(~contractAddress, ~blockNumber, ~indexingAddresses)
+  | Some(group) => group->Group.get(~contractAddress, ~contractNameByAddress)
   }
 }
 
@@ -100,16 +96,16 @@ let getEvmEventId = (~sighash, ~topicCount) => {
   sighash ++ "_" ++ topicCount->Int.toString
 }
 
-let fromEvmEventModsOrThrow = (events: array<Internal.evmEventConfig>, ~chain): t<
-  Internal.evmEventConfig,
+let fromEvmEventModsOrThrow = (events: array<Internal.evmOnEventRegistration>, ~chain): t<
+  Internal.evmOnEventRegistration,
 > => {
   let router = empty()
   events->Array.forEach(config => {
     router->addOrThrow(
-      config.id,
+      config.eventConfig.id,
       config,
-      ~contractName=config.contractName,
-      ~eventName=config.name,
+      ~contractName=config.eventConfig.contractName,
+      ~eventName=config.eventConfig.name,
       ~chain,
       ~isWildcard=config.isWildcard,
     )
@@ -135,21 +131,26 @@ type svmProgramOrdering = {
   byteLengthsDesc: array<int>,
 }
 
-let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConfig>, ~chain): (
-  t<Internal.svmInstructionEventConfig>,
+let fromSvmEventConfigsOrThrow = (events: array<Internal.svmOnEventRegistration>, ~chain): (
+  t<Internal.svmOnEventRegistration>,
   array<svmProgramOrdering>,
 ) => {
   let router = empty()
   events->Array.forEach(config => {
+    let eventConfig =
+      config.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
     // The router tag must include the programId so two programs declaring the
     // same discriminator coexist. The source-side lookup uses the same shape
     // via `getSvmEventId(~programId, ~discriminator)`.
-    let routerTag = getSvmEventId(~programId=config.programId, ~discriminator=config.discriminator)
+    let routerTag = getSvmEventId(
+      ~programId=eventConfig.programId,
+      ~discriminator=eventConfig.discriminator,
+    )
     router->addOrThrow(
       routerTag,
       config,
-      ~contractName=config.contractName,
-      ~eventName=config.name,
+      ~contractName=eventConfig.contractName,
+      ~eventName=eventConfig.name,
       ~chain,
       ~isWildcard=config.isWildcard,
     )
@@ -158,7 +159,9 @@ let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConf
   // Per-program list of declared discriminator byte lengths, sorted desc.
   let byProgram: dict<Utils.Set.t<int>> = Dict.make()
   events->Array.forEach(config => {
-    let key = config.programId->SvmTypes.Pubkey.toString
+    let eventConfig =
+      config.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+    let key = eventConfig.programId->SvmTypes.Pubkey.toString
     let set = switch byProgram->Utils.Dict.dangerouslyGetNonOption(key) {
     | Some(s) => s
     | None =>
@@ -166,7 +169,7 @@ let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConf
       byProgram->Dict.set(key, s)
       s
     }
-    let _ = set->Utils.Set.add(config.discriminatorByteLen)
+    let _ = set->Utils.Set.add(eventConfig.discriminatorByteLen)
   })
   let ordering =
     byProgram

package/src/sources/EventRouter.res.mjs

@@ -39,16 +39,13 @@ function addOrThrow(group, event, contractName, isWildcard) {
   byContractName[contractName] = event;
 }
 
-function get(group, contractAddress, blockNumber, indexingAddresses) {
+function get(group, contractAddress, contractNameByAddress) {
   let wildcard = group.wildcard;
-  let indexingContract = indexingAddresses[contractAddress];
-  if (indexingContract === undefined) {
+  let contractName = contractNameByAddress[contractAddress];
+  if (contractName === undefined) {
     return wildcard;
   }
-  if (indexingContract.effectiveStartBlock > blockNumber) {
-    return;
-  }
-  let event = group.byContractName[indexingContract.contractName];
+  let event = group.byContractName[contractName];
   if (event !== undefined) {
     return event;
   } else {
@@ -93,10 +90,10 @@ function addOrThrow$1(router, eventId, event, contractName, isWildcard, eventNam
   }
 }
 
-function get$1(router, tag, contractAddress, blockNumber, indexingAddresses) {
+function get$1(router, tag, contractAddress, contractNameByAddress) {
   let group = router[tag];
   if (group !== undefined) {
-    return get(group, contractAddress, blockNumber, indexingAddresses);
+    return get(group, contractAddress, contractNameByAddress);
   }
 }
 
@@ -106,7 +103,7 @@ function getEvmEventId(sighash, topicCount) {
 
 function fromEvmEventModsOrThrow(events, chain) {
   let router = {};
-  events.forEach(config => addOrThrow$1(router, config.id, config, config.contractName, config.isWildcard, config.name, chain));
+  events.forEach(config => addOrThrow$1(router, config.eventConfig.id, config, config.eventConfig.contractName, config.isWildcard, config.eventConfig.name, chain));
   return router;
 }
 
@@ -121,12 +118,14 @@ function getSvmEventId(programId, discriminator) {
 function fromSvmEventConfigsOrThrow(events, chain) {
   let router = {};
   events.forEach(config => {
-    let routerTag = getSvmEventId(config.programId, config.discriminator);
-    addOrThrow$1(router, routerTag, config, config.contractName, config.isWildcard, config.name, chain);
+    let eventConfig = config.eventConfig;
+    let routerTag = getSvmEventId(eventConfig.programId, eventConfig.discriminator);
+    addOrThrow$1(router, routerTag, config, eventConfig.contractName, config.isWildcard, eventConfig.name, chain);
   });
   let byProgram = {};
   events.forEach(config => {
-    let key = config.programId;
+    let eventConfig = config.eventConfig;
+    let key = eventConfig.programId;
     let s = byProgram[key];
     let set;
     if (s !== undefined) {
@@ -136,7 +135,7 @@ function fromSvmEventConfigsOrThrow(events, chain) {
       byProgram[key] = s$1;
       set = s$1;
     }
-    set.add(config.discriminatorByteLen);
+    set.add(eventConfig.discriminatorByteLen);
   });
   let ordering = Object.entries(byProgram).map(param => {
     let sorted = Array.from(param[1]).toSorted((a, b) => b - a | 0);