envio 3.3.0-alpha.3 → 3.3.0-alpha.5

package/src/Prometheus.res.mjs

@@ -389,39 +389,28 @@ let ProcessStartTimeSeconds = {
   set: set$3
 };
 
-let gauge$4 = makeOrThrow$1("envio_indexing_addresses", "The number of addresses indexed on chain. Includes both static and dynamic addresses.", chainIdLabelsSchema);
+let gauge$4 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
 
-function set$4(addressesCount, chainId) {
-  handleInt$1(gauge$4, chainId, addressesCount);
+function set$4(concurrency, chainId) {
+  handleInt$1(gauge$4, chainId, concurrency);
 }
 
-let IndexingAddresses = {
+let IndexingConcurrency = {
   gauge: gauge$4,
   set: set$4
 };
 
-let gauge$5 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
+let gauge$5 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
 
-function set$5(concurrency, chainId) {
-  handleInt$1(gauge$5, chainId, concurrency);
+function set$5(partitionsCount, chainId) {
+  handleInt$1(gauge$5, chainId, partitionsCount);
 }
 
-let IndexingConcurrency = {
+let IndexingPartitions = {
   gauge: gauge$5,
   set: set$5
 };
 
-let gauge$6 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
-
-function set$6(partitionsCount, chainId) {
-  handleInt$1(gauge$6, chainId, partitionsCount);
-}
-
-let IndexingPartitions = {
-  gauge: gauge$6,
-  set: set$6
-};
-
 let counter = makeOrThrow("envio_indexing_idle_seconds", "The time the indexer source syncing has been idle. A high value may indicate the source sync is a bottleneck.", chainIdLabelsSchema);
 
 let IndexingIdleTime = {
@@ -440,51 +429,51 @@ let IndexingQueryTime = {
   counter: counter$2
 };
 
-let gauge$7 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
+let gauge$6 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
 
-function set$7(bufferSize, chainId) {
-  handleInt$1(gauge$7, chainId, bufferSize);
+function set$6(bufferSize, chainId) {
+  handleInt$1(gauge$6, chainId, bufferSize);
 }
 
 let IndexingBufferSize = {
-  gauge: gauge$7,
-  set: set$7
+  gauge: gauge$6,
+  set: set$6
 };
 
-let gauge$8 = PromClient.Gauge.makeGauge({
+let gauge$7 = PromClient.Gauge.makeGauge({
   name: "envio_indexing_target_buffer_size",
   help: "The indexer-wide target buffer size shared across all chains. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target."
 });
 
-function set$8(targetBufferSize) {
-  gauge$8.set(targetBufferSize);
+function set$7(targetBufferSize) {
+  gauge$7.set(targetBufferSize);
 }
 
 let IndexingTargetBufferSize = {
-  gauge: gauge$8,
-  set: set$8
+  gauge: gauge$7,
+  set: set$7
 };
 
-let gauge$9 = makeOrThrow$1("envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
+let gauge$8 = makeOrThrow$1("envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
 
-function set$9(blockNumber, chainId) {
-  handleInt$1(gauge$9, chainId, blockNumber);
+function set$8(blockNumber, chainId) {
+  handleInt$1(gauge$8, chainId, blockNumber);
 }
 
 let IndexingBufferBlockNumber = {
-  gauge: gauge$9,
-  set: set$9
+  gauge: gauge$8,
+  set: set$8
 };
 
-let gauge$10 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
+let gauge$9 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
 
-function set$10(endBlock, chainId) {
-  handleInt$1(gauge$10, chainId, endBlock);
+function set$9(endBlock, chainId) {
+  handleInt$1(gauge$9, chainId, endBlock);
 }
 
 let IndexingEndBlock = {
-  gauge: gauge$10,
-  set: set$10
+  gauge: gauge$9,
+  set: set$9
 };
 
 let sourceLabelsSchema = S$RescriptSchema.schema(s => ({
@@ -525,18 +514,18 @@ let SourceRequestCount = {
   addSeconds: addSeconds
 };
 
-let gauge$11 = makeOrThrow$1("envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", sourceLabelsSchema);
+let gauge$10 = makeOrThrow$1("envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", sourceLabelsSchema);
 
-function set$11(sourceName, chainId, blockNumber) {
-  handleInt$1(gauge$11, {
+function set$10(sourceName, chainId, blockNumber) {
+  handleInt$1(gauge$10, {
     source: sourceName,
     chainId: chainId
   }, blockNumber);
 }
 
 let SourceHeight = {
-  gauge: gauge$11,
-  set: set$11
+  gauge: gauge$10,
+  set: set$10
 };
 
 let counter$4 = makeOrThrow("envio_reorg_detected_total", "Total number of reorgs detected", chainIdLabelsSchema);
@@ -550,43 +539,43 @@ let ReorgCount = {
   increment: increment$5
 };
 
-let gauge$12 = makeOrThrow$1("envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", chainIdLabelsSchema);
+let gauge$11 = makeOrThrow$1("envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", chainIdLabelsSchema);
 
-function set$12(blockNumber, chain) {
-  handleInt$1(gauge$12, chain, blockNumber);
+function set$11(blockNumber, chain) {
+  handleInt$1(gauge$11, chain, blockNumber);
 }
 
 let ReorgDetectionBlockNumber = {
-  gauge: gauge$12,
-  set: set$12
+  gauge: gauge$11,
+  set: set$11
 };
 
-let gauge$13 = PromClient.Gauge.makeGauge({
+let gauge$12 = PromClient.Gauge.makeGauge({
   name: "envio_reorg_threshold",
   help: "Whether indexing is currently within the reorg threshold"
 });
 
-function set$13(isInReorgThreshold) {
-  gauge$13.set(isInReorgThreshold ? 1 : 0);
+function set$12(isInReorgThreshold) {
+  gauge$12.set(isInReorgThreshold ? 1 : 0);
 }
 
 let ReorgThreshold = {
-  gauge: gauge$13,
-  set: set$13
+  gauge: gauge$12,
+  set: set$12
 };
 
-let gauge$14 = PromClient.Gauge.makeGauge({
+let gauge$13 = PromClient.Gauge.makeGauge({
   name: "envio_rollback_enabled",
   help: "Whether rollback on reorg is enabled"
 });
 
-function set$14(enabled) {
-  gauge$14.set(enabled ? 1 : 0);
+function set$13(enabled) {
+  gauge$13.set(enabled ? 1 : 0);
 }
 
 let RollbackEnabled = {
-  gauge: gauge$14,
-  set: set$14
+  gauge: gauge$13,
+  set: set$13
 };
 
 let timeCounter$3 = PromClient.Counter.makeCounter({
@@ -635,62 +624,62 @@ let RollbackHistoryPrune = {
   increment: increment$7
 };
 
-let gauge$15 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
+let gauge$14 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
 
-function set$15(blockNumber, chain) {
-  handleInt$1(gauge$15, chain, blockNumber);
+function set$14(blockNumber, chain) {
+  handleInt$1(gauge$14, chain, blockNumber);
 }
 
 let RollbackTargetBlockNumber = {
-  gauge: gauge$15,
-  set: set$15
+  gauge: gauge$14,
+  set: set$14
 };
 
-let gauge$16 = PromClient.Gauge.makeGauge({
+let gauge$15 = PromClient.Gauge.makeGauge({
   name: "envio_processing_max_batch_size",
   help: "The maximum number of items to process in a single batch."
 });
 
-function set$16(maxBatchSize) {
-  gauge$16.set(maxBatchSize);
+function set$15(maxBatchSize) {
+  gauge$15.set(maxBatchSize);
 }
 
 let ProcessingMaxBatchSize = {
-  gauge: gauge$16,
-  set: set$16
+  gauge: gauge$15,
+  set: set$15
 };
 
-let gauge$17 = makeOrThrow$1("envio_progress_block", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
+let gauge$16 = makeOrThrow$1("envio_progress_block", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
 
-function set$17(blockNumber, chainId) {
-  handleInt$1(gauge$17, chainId, blockNumber);
+function set$16(blockNumber, chainId) {
+  handleInt$1(gauge$16, chainId, blockNumber);
 }
 
 let ProgressBlockNumber = {
-  gauge: gauge$17,
-  set: set$17
+  gauge: gauge$16,
+  set: set$16
 };
 
-let gauge$18 = makeOrThrow$1("envio_progress_events", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
+let gauge$17 = makeOrThrow$1("envio_progress_events", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
 
-function set$18(processedCount, chainId) {
-  handleFloat$1(gauge$18, chainId, processedCount);
+function set$17(processedCount, chainId) {
+  handleFloat$1(gauge$17, chainId, processedCount);
 }
 
 let ProgressEventsCount = {
-  gauge: gauge$18,
-  set: set$18
+  gauge: gauge$17,
+  set: set$17
 };
 
-let gauge$19 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
+let gauge$18 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
 
-function set$19(latencyMs, chainId) {
-  handleInt$1(gauge$19, chainId, latencyMs);
+function set$18(latencyMs, chainId) {
+  handleInt$1(gauge$18, chainId, latencyMs);
 }
 
 let ProgressLatency = {
-  gauge: gauge$19,
-  set: set$19
+  gauge: gauge$18,
+  set: set$18
 };
 
 let effectLabelsSchema = S$RescriptSchema.object(s => s.f("effect", S$RescriptSchema.string));
@@ -710,15 +699,15 @@ let EffectCalls = {
   activeCallsCount: activeCallsCount
 };
 
-let gauge$20 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
+let gauge$19 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
 
-function set$20(count, effectName) {
-  handleInt$1(gauge$20, effectName, count);
+function set$19(count, effectName) {
+  handleInt$1(gauge$19, effectName, count);
 }
 
 let EffectCacheCount = {
-  gauge: gauge$20,
-  set: set$20
+  gauge: gauge$19,
+  set: set$19
 };
 
 let counter$7 = makeOrThrow("envio_effect_cache_invalidations", "The number of effect cache invalidations.", effectLabelsSchema);
@@ -732,18 +721,18 @@ let EffectCacheInvalidationsCount = {
   increment: increment$8
 };
 
-let gauge$21 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
+let gauge$20 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
 
 let timeCounter$6 = makeOrThrow("envio_effect_queue_wait_seconds", "The time spent waiting in the rate limit queue.", effectLabelsSchema);
 
-function set$21(count, effectName) {
-  handleInt$1(gauge$21, effectName, count);
+function set$20(count, effectName) {
+  handleInt$1(gauge$20, effectName, count);
 }
 
 let EffectQueueCount = {
-  gauge: gauge$21,
+  gauge: gauge$20,
   timeCounter: timeCounter$6,
-  set: set$21
+  set: set$20
 };
 
 let loadLabelsSchema = S$RescriptSchema.schema(s => ({
@@ -846,7 +835,6 @@ export {
   IndexingKnownHeight,
   Info,
   ProcessStartTimeSeconds,
-  IndexingAddresses,
   IndexingConcurrency,
   IndexingPartitions,
   IndexingIdleTime,

package/src/SimulateItems.res

@@ -234,6 +234,10 @@ let deriveSrcAddress = (
 // A non-wildcard event is gated by `clientAddressFilter` on srcAddress ownership,
 // so a simulate item whose srcAddress isn't indexed on this chain would be
 // silently dropped (handler never runs). Fail loudly instead.
+//
+// `config` must already have handler registrations applied, otherwise an event
+// made wildcard purely through `indexer.onEvent({ wildcard: true })` reads back
+// as non-wildcard and gets wrongly rejected.
 let validateSrcAddresses = (
   ~simulateItems: array<JSON.t>,
   ~config: Config.t,

package/src/TestIndexer.res

@@ -667,8 +667,11 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             Int.compare(aId, bId)
           })
 
-          // Parse and validate all chain configs upfront before starting any workers
-          let preflightAddressesByChain = getIndexingAddressesByChain(state)
+          // Parse and validate the block ranges upfront before starting any
+          // workers. srcAddress validation can't run here: it depends on which
+          // events are wildcard, and `config` reflects config.yaml only —
+          // handler-level `wildcard: true` takes effect only once registrations
+          // are applied.
           let chainEntries = sortedChainKeys->Array.map(chainIdStr => {
             let rawChainConfig = rawChains->Dict.getUnsafe(chainIdStr)
             let chainId = switch chainIdStr->Int.fromString {
@@ -684,19 +687,6 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
               ~rawChainConfig,
               ~progressBlock=state.progressBlockByChain->Dict.get(chainIdStr),
             )
-            switch rawChainConfig.simulate {
-            | Some(simulateItems) =>
-              let chainConfig = config.chainMap->ChainMap.get(ChainMap.Chain.makeUnsafe(~chainId))
-              SimulateItems.validateSrcAddresses(
-                ~simulateItems,
-                ~config,
-                ~chainConfig,
-                ~indexingAddresses=preflightAddressesByChain
-                ->Dict.get(chainIdStr)
-                ->Option.getOr([]),
-              )
-            | None => ()
-            }
             (chainIdStr, chainId, rawChainConfig, processChainConfig)
           })
 
@@ -877,7 +867,27 @@ let initTestWorker = () => {
     | Some(_) => ()
     }
 
-    let patchConfig = (config, _registrations) => {
+    let patchConfig = (config: Config.t, _registrations) => {
+      // `config` here has handler registrations applied, so `isWildcard`
+      // reflects `indexer.onEvent({ wildcard: true })` — which the main thread
+      // can't see. Validate srcAddresses against it before patching in the
+      // simulate source.
+      switch simulate {
+      | Some(simulateItems) =>
+        let chainConfig = config.chainMap->ChainMap.get(ChainMap.Chain.makeUnsafe(~chainId))
+        let indexingAddresses =
+          initialState.chains
+          ->Array.find(c => c.id == chainId)
+          ->Option.mapOr([], c => c.indexingAddresses)
+        SimulateItems.validateSrcAddresses(
+          ~simulateItems,
+          ~config,
+          ~chainConfig,
+          ~indexingAddresses,
+        )
+      | None => ()
+      }
+
       let config = SimulateItems.patchConfig(~config, ~processConfig)
 
       // In auto-exit mode, set batchSize=1 to process one block checkpoint at a time
@@ -887,7 +897,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. patchConfig's
+      // srcAddress validation) 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

@@ -481,17 +481,11 @@ function makeCreateTestIndexer(config, workerPath) {
         let bId = Stdlib_Option.getOr(Stdlib_Int.fromString(b, undefined), 0);
         return Primitive_int.compare(aId, bId);
       });
-      let preflightAddressesByChain = getIndexingAddressesByChain(state);
       let chainEntries = sortedChainKeys.map(chainIdStr => {
         let rawChainConfig = rawChains[chainIdStr];
         let id = Stdlib_Int.fromString(chainIdStr, undefined);
         let chainId = id !== undefined ? id : Stdlib_JsError.throwWithMessage(`Invalid chain ID "` + chainIdStr + `": expected a numeric chain ID`);
         let processChainConfig = parseBlockRange(chainIdStr, config, rawChainConfig, state.progressBlockByChain[chainIdStr]);
-        let simulateItems = rawChainConfig.simulate;
-        if (simulateItems !== undefined) {
-          let chainConfig = ChainMap.get(config.chainMap, ChainMap.Chain.makeUnsafe(chainId));
-          SimulateItems.validateSrcAddresses(simulateItems, config, chainConfig, Stdlib_Option.getOr(preflightAddressesByChain[chainIdStr], []));
-        }
         return [
           chainIdStr,
           chainId,
@@ -592,9 +586,11 @@ function initTestWorker() {
     Process.exit(1);
     return;
   }
+  let initialState = workerData.initialState;
   let simulate = workerData.simulate;
   let endBlock = workerData.endBlock;
-  let chainIdStr = workerData.chainId.toString();
+  let chainId = workerData.chainId;
+  let chainIdStr = chainId.toString();
   let exitAfterFirstEventBlock = Stdlib_Option.isNone(endBlock);
   let resolvedChainDict = {};
   resolvedChainDict["startBlock"] = workerData.startBlock;
@@ -609,7 +605,7 @@ function initTestWorker() {
   let processConfig = {
     chains: resolvedChainsDict
   };
-  let proxy = TestIndexerProxyStorage.make(parentPort, workerData.initialState);
+  let proxy = TestIndexerProxyStorage.make(parentPort, initialState);
   let storage = TestIndexerProxyStorage.makeStorage(proxy);
   let config = Config.loadWithoutRegistrations();
   let persistence = Persistence.make(config.userEntities, config.allEnums, storage);
@@ -619,6 +615,11 @@ function initTestWorker() {
     Logging.setLogLevel("silent");
   }
   let patchConfig = (config, _registrations) => {
+    if (simulate !== undefined) {
+      let chainConfig = ChainMap.get(config.chainMap, ChainMap.Chain.makeUnsafe(chainId));
+      let indexingAddresses = Stdlib_Option.mapOr(initialState.chains.find(c => c.id === chainId), [], c => c.indexingAddresses);
+      SimulateItems.validateSrcAddresses(simulate, config, chainConfig, indexingAddresses);
+    }
     let config$1 = SimulateItems.patchConfig(config, processConfig);
     if (exitAfterFirstEventBlock) {
       return {
@@ -646,7 +647,13 @@ 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 {

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. */