envio 2.29.2 → 2.30.0

package/src/Utils.res.js

@@ -214,6 +214,10 @@ function mergeSorted(f, xs, ys) {
   return result;
 }
 
+var clearInPlace = ((arr) => {
+    arr.length = 0
+  });
+
 function setIndexImmutable(arr, index, value) {
   var shallowCopy = arr.slice(0);
   shallowCopy[index] = value;
@@ -312,6 +316,7 @@ function interleave(arr, separator) {
 
 var $$Array$1 = {
   mergeSorted: mergeSorted,
+  clearInPlace: clearInPlace,
   setIndexImmutable: setIndexImmutable,
   transposeResults: transposeResults,
   includes: includes,

package/src/bindings/Ethers.res

@@ -147,19 +147,43 @@ module JsonRpcProvider = {
   @send
   external getTransaction: (t, ~transactionHash: string) => promise<transaction> = "getTransaction"
 
-  let makeGetTransactionFields = (~getTransactionByHash) =>
-    async (log: log): promise<unknown> => {
-      let transaction = await getTransactionByHash(log.transactionHash)
-      // Mutating should be fine, since the transaction isn't used anywhere else outside the function
-      let fields: {..} = transaction->Obj.magic
-
-      // Make it compatible with HyperSync transaction fields
-      fields["transactionIndex"] = log.transactionIndex
-      fields["input"] = fields["data"]
-
-      fields->Obj.magic
+  let makeGetTransactionFields = (~getTransactionByHash, ~lowercaseAddresses: bool) => async (
+    log: log,
+  ): promise<unknown> => {
+    let transaction = await getTransactionByHash(log.transactionHash)
+    // Mutating should be fine, since the transaction isn't used anywhere else outside the function
+    let fields: {..} = transaction->Obj.magic
+
+    // Make it compatible with HyperSync transaction fields
+    fields["transactionIndex"] = log.transactionIndex
+    fields["input"] = fields["data"]
+
+    // NOTE: this is wasteful if these fields are not selected in the users config.
+    //       There might be a better way to do this in the `makeThrowingGetEventTransaction` function rather based on the schema.
+    //       However this is not extremely expensive and good enough for now (only on rpc sync also).
+    if lowercaseAddresses {
+      open Js.Nullable
+      switch fields["from"] {
+      | Value(from) => fields["from"] = from->Js.String2.toLowerCase
+      | Undefined => ()
+      | Null => ()
+      }
+      switch fields["to"] {
+      | Value(to) => fields["to"] = to->Js.String2.toLowerCase
+      | Undefined => ()
+      | Null => ()
+      }
+      switch fields["contractAddress"] {
+      | Value(contractAddress) =>
+        fields["contractAddress"] = contractAddress->Js.String2.toLowerCase
+      | Undefined => ()
+      | Null => ()
+      }
     }
 
+    fields->Obj.magic
+  }
+
   type block = {
     _difficulty: bigint,
     difficulty: int,

package/src/bindings/Ethers.res.js

@@ -78,11 +78,31 @@ function make(rpcUrl, chainId) {
   return makeStatic(rpcUrl, network, undefined, undefined);
 }
 
-function makeGetTransactionFields(getTransactionByHash) {
+function makeGetTransactionFields(getTransactionByHash, lowercaseAddresses) {
   return async function (log) {
     var transaction = await getTransactionByHash(log.transactionHash);
     transaction.transactionIndex = log.transactionIndex;
     transaction.input = transaction.data;
+    if (lowercaseAddresses) {
+      var from = transaction.from;
+      if (from === null || from === undefined) {
+        from === null;
+      } else {
+        transaction.from = from.toLowerCase();
+      }
+      var to = transaction.to;
+      if (to === null || to === undefined) {
+        to === null;
+      } else {
+        transaction.to = to.toLowerCase();
+      }
+      var contractAddress = transaction.contractAddress;
+      if (contractAddress === null || contractAddress === undefined) {
+        contractAddress === null;
+      } else {
+        transaction.contractAddress = contractAddress.toLowerCase();
+      }
+    }
     return transaction;
   };
 }

package/src/bindings/PromClient.res

@@ -11,6 +11,14 @@ type registry
 @send external metrics: registry => Promise.t<string> = "metrics"
 @get external getContentType: registry => string = "contentType"
 
+type metricValue = {
+  value: int,
+  labels: dict<string>,
+}
+type metricInstance = {get: unit => promise<{"values": array<metricValue>}>}
+@send external getSingleMetric: (registry, string) => option<metricInstance> = "getSingleMetric"
+@send external resetMetrics: registry => unit = "resetMetrics"
+
 module Counter = {
   type counter
   @new @module("prom-client") external makeCounter: customMetric<'a> => counter = "Counter"
@@ -36,6 +44,8 @@ module Gauge = {
   @send external setFloat: (gauge, float) => unit = "set"
 
   @send external labels: (gauge, 'labelsObject) => gauge = "labels"
+
+  @send external get: gauge => promise<{"values": array<dict<string>>}> = "get"
 }
 
 module Histogram = {

package/src/db/InternalTable.res

@@ -8,7 +8,6 @@ let isIndex = true
 module Chains = {
   type progressFields = [
     | #progress_block
-    | #_progress_log_index
     | #events_processed
   ]
 
@@ -35,7 +34,6 @@ module Chains = {
     #progress_block,
     #ready_at,
     #events_processed,
-    #_progress_log_index,
     #_is_hyper_sync,
     #_num_batches_fetched,
   ]
@@ -55,7 +53,6 @@ module Chains = {
     @as("start_block") startBlock: int,
     @as("end_block") endBlock: Js.null<int>,
     @as("progress_block") progressBlockNumber: int,
-    @as("_progress_log_index") progressNextBlockLogIndex: Js.null<int>,
     @as("events_processed") numEventsProcessed: int,
     ...metaFields,
   }
@@ -91,14 +88,6 @@ module Chains = {
       mkField((#_is_hyper_sync: field :> string), Boolean, ~fieldSchema=S.bool),
       // Fully processed block number
       mkField((#progress_block: field :> string), Integer, ~fieldSchema=S.int),
-      // Optional log index of the next block after progress block
-      // To correctly resume indexing when we processed half of the block.
-      mkField(
-        (#_progress_log_index: field :> string),
-        Integer,
-        ~fieldSchema=S.null(S.int),
-        ~isNullable,
-      ),
       // TODO: Should deprecate after changing the ETA calculation logic
       mkField((#_num_batches_fetched: field :> string), Integer, ~fieldSchema=S.int),
     ],
@@ -114,7 +103,6 @@ module Chains = {
       latestFetchedBlockNumber: -1,
       timestampCaughtUpToHeadOrEndblock: Js.Null.empty,
       progressBlockNumber: -1,
-      progressNextBlockLogIndex: Js.Null.empty,
       isHyperSync: false,
       numEventsProcessed: 0,
       numBatchesFetched: 0,
@@ -175,11 +163,7 @@ SET ${setClauses->Js.Array2.joinWith(",\n    ")}
 WHERE "id" = $1;`
   }
 
-  let progressFields: array<progressFields> = [
-    #progress_block,
-    #_progress_log_index,
-    #events_processed,
-  ]
+  let progressFields: array<progressFields> = [#progress_block, #events_processed]
 
   let makeProgressFieldsUpdateQuery = (~pgSchema) => {
     let setClauses = Belt.Array.mapWithIndex(progressFields, (index, field) => {
@@ -234,10 +218,6 @@ WHERE "id" = $1;`
         ->Js.Array2.push(
           switch field {
           | #progress_block => data.progressBlockNumber->(Utils.magic: int => unknown)
-          | #_progress_log_index =>
-            data.progressNextBlockLogIndex
-            ->Js.Null.fromOption
-            ->(Utils.magic: Js.null<int> => unknown)
           | #events_processed => data.totalEventsProcessed->(Utils.magic: int => unknown)
           },
         )
@@ -448,42 +428,4 @@ module DynamicContractRegistry = {
     table,
     entityHistory,
   }->Internal.fromGenericEntityConfig
-
-  let makeCleanUpOnRestartQuery = (~pgSchema, ~chains: array<Chains.t>) => {
-    let query = ref(``)
-
-    chains->Js.Array2.forEach(chain => {
-      if query.contents !== "" {
-        query := query.contents ++ "\n"
-      }
-      query :=
-        query.contents ++
-        `DELETE FROM "${pgSchema}"."${table.tableName}"
-WHERE chain_id = ${chain.id->Belt.Int.toString}${switch chain {
-          | {progressBlockNumber, progressNextBlockLogIndex: Value(progressNextBlockLogIndex)} =>
-            ` AND (
-  registering_event_block_number > ${(progressBlockNumber + 1)->Belt.Int.toString}
-  OR registering_event_block_number = ${(progressBlockNumber + 1)->Belt.Int.toString}
-  AND registering_event_log_index > ${progressNextBlockLogIndex->Belt.Int.toString}
-)`
-          | {progressBlockNumber: -1, progressNextBlockLogIndex: Null} => ``
-          | {progressBlockNumber, progressNextBlockLogIndex: Null} =>
-            ` AND registering_event_block_number > ${progressBlockNumber->Belt.Int.toString}`
-          }};
-DELETE FROM "${pgSchema}"."${table.tableName}_history"
-WHERE entity_history_chain_id = ${chain.id->Belt.Int.toString}${switch chain {
-          | {progressBlockNumber, progressNextBlockLogIndex: Value(progressNextBlockLogIndex)} =>
-            ` AND (
-  entity_history_block_number > ${(progressBlockNumber + 1)->Belt.Int.toString}
-  OR entity_history_block_number = ${(progressBlockNumber + 1)->Belt.Int.toString}
-  AND entity_history_log_index > ${progressNextBlockLogIndex->Belt.Int.toString}
-)`
-          | {progressBlockNumber: -1, progressNextBlockLogIndex: Null} => ``
-          | {progressBlockNumber, progressNextBlockLogIndex: Null} =>
-            ` AND entity_history_block_number > ${progressBlockNumber->Belt.Int.toString}`
-          }};`
-    })
-
-    query.contents
-  }
 }

package/src/db/InternalTable.res.js

@@ -21,7 +21,6 @@ var fields = [
   "progress_block",
   "ready_at",
   "events_processed",
-  "_progress_log_index",
   "_is_hyper_sync",
   "_num_batches_fetched"
 ];
@@ -37,7 +36,6 @@ var table = Table.mkTable("envio_chains", undefined, [
       Table.mkField("events_processed", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
       Table.mkField("_is_hyper_sync", "BOOLEAN", S$RescriptSchema.bool, undefined, undefined, undefined, undefined, undefined, undefined),
       Table.mkField("progress_block", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
-      Table.mkField("_progress_log_index", "INTEGER", S$RescriptSchema.$$null(S$RescriptSchema.$$int), undefined, undefined, true, undefined, undefined, undefined),
       Table.mkField("_num_batches_fetched", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined)
     ]);
 
@@ -47,7 +45,6 @@ function initialFromConfig(chainConfig) {
           start_block: chainConfig.startBlock,
           end_block: Js_null.fromOption(chainConfig.endBlock),
           progress_block: -1,
-          _progress_log_index: null,
           events_processed: 0,
           first_event_block: null,
           buffer_block: -1,
@@ -109,7 +106,6 @@ function makeMetaFieldsUpdateQuery(pgSchema) {
 
 var progressFields = [
   "progress_block",
-  "_progress_log_index",
   "events_processed"
 ];
 
@@ -143,9 +139,7 @@ function setProgressedChains(sql, pgSchema, progressedChains) {
         var params = [];
         params.push(data.chainId);
         progressFields.forEach(function (field) {
-              params.push(field === "events_processed" ? data.totalEventsProcessed : (
-                      field === "progress_block" ? data.progressBlockNumber : Js_null.fromOption(data.progressNextBlockLogIndex)
-                    ));
+              params.push(field === "progress_block" ? data.progressBlockNumber : data.totalEventsProcessed);
             });
         promises.push(sql.unsafe(query, params, {prepare: true}));
       });
@@ -291,31 +285,6 @@ var config = {
   entityHistory: entityHistory
 };
 
-function makeCleanUpOnRestartQuery(pgSchema, chains) {
-  var query = {
-    contents: ""
-  };
-  chains.forEach(function (chain) {
-        if (query.contents !== "") {
-          query.contents = query.contents + "\n";
-        }
-        var progressBlockNumber = chain.progress_block;
-        var progressNextBlockLogIndex = chain._progress_log_index;
-        var tmp;
-        tmp = progressNextBlockLogIndex === null ? (
-            progressBlockNumber !== -1 ? " AND registering_event_block_number > " + String(progressBlockNumber) : ""
-          ) : " AND (\n  registering_event_block_number > " + String(progressBlockNumber + 1 | 0) + "\n  OR registering_event_block_number = " + String(progressBlockNumber + 1 | 0) + "\n  AND registering_event_log_index > " + String(progressNextBlockLogIndex) + "\n)";
-        var progressBlockNumber$1 = chain.progress_block;
-        var progressNextBlockLogIndex$1 = chain._progress_log_index;
-        var tmp$1;
-        tmp$1 = progressNextBlockLogIndex$1 === null ? (
-            progressBlockNumber$1 !== -1 ? " AND entity_history_block_number > " + String(progressBlockNumber$1) : ""
-          ) : " AND (\n  entity_history_block_number > " + String(progressBlockNumber$1 + 1 | 0) + "\n  OR entity_history_block_number = " + String(progressBlockNumber$1 + 1 | 0) + "\n  AND entity_history_log_index > " + String(progressNextBlockLogIndex$1) + "\n)";
-        query.contents = query.contents + ("DELETE FROM \"" + pgSchema + "\".\"" + table$4.tableName + "\"\nWHERE chain_id = " + String(chain.id) + tmp + ";\nDELETE FROM \"" + pgSchema + "\".\"" + table$4.tableName + "_history\"\nWHERE entity_history_chain_id = " + String(chain.id) + tmp$1 + ";");
-      });
-  return query.contents;
-}
-
 var DynamicContractRegistry = {
   name: name,
   makeId: makeId,
@@ -323,8 +292,7 @@ var DynamicContractRegistry = {
   rowsSchema: rowsSchema,
   table: table$4,
   entityHistory: entityHistory,
-  config: config,
-  makeCleanUpOnRestartQuery: makeCleanUpOnRestartQuery
+  config: config
 };
 
 var isPrimaryKey = true;

package/src/sources/HyperSyncClient.res

@@ -448,10 +448,16 @@ type t = {
 }
 
 @module("@envio-dev/hypersync-client") @scope("HypersyncClient") external make: cfg => t = "new"
-let make = (~url, ~apiToken, ~httpReqTimeoutMillis, ~maxNumRetries) =>
+let make = (
+  ~url,
+  ~apiToken,
+  ~httpReqTimeoutMillis,
+  ~maxNumRetries,
+  ~enableChecksumAddresses=true,
+) =>
   make({
     url,
-    enableChecksumAddresses: true,
+    enableChecksumAddresses,
     bearerToken: apiToken,
     httpReqTimeoutMillis,
     maxNumRetries,

package/src/sources/HyperSyncClient.res.js

@@ -57,13 +57,14 @@ var ResponseTypes = {
   authorizationListSchema: authorizationListSchema
 };
 
-function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries) {
+function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, enableChecksumAddressesOpt) {
+  var enableChecksumAddresses = enableChecksumAddressesOpt !== undefined ? enableChecksumAddressesOpt : true;
   return HypersyncClient.HypersyncClient.new({
               url: url,
               bearerToken: apiToken,
               httpReqTimeoutMillis: httpReqTimeoutMillis,
               maxNumRetries: maxNumRetries,
-              enableChecksumAddresses: true
+              enableChecksumAddresses: enableChecksumAddresses
             });
 }
 

package/src/sources/HyperSyncSource.res

@@ -154,6 +154,7 @@ type options = {
   apiToken: option<string>,
   clientMaxRetries: int,
   clientTimeoutMillis: int,
+  lowercaseAddresses: bool,
 }
 
 let make = (
@@ -167,6 +168,7 @@ let make = (
     apiToken,
     clientMaxRetries,
     clientTimeoutMillis,
+    lowercaseAddresses,
   }: options,
 ): t => {
   let name = "HyperSync"
@@ -180,6 +182,7 @@ let make = (
     ~apiToken,
     ~maxNumRetries=clientMaxRetries,
     ~httpReqTimeoutMillis=clientTimeoutMillis,
+    ~enableChecksumAddresses=!lowercaseAddresses,
   )
 
   let hscDecoder: ref<option<HyperSyncClient.Decoder.t>> = ref(None)
@@ -193,7 +196,11 @@ let make = (
           ~msg="Failed to instantiate a decoder from hypersync client, please double check your ABI or try using 'event_decoder: viem' config option",
         )
       | decoder =>
-        decoder.enableChecksummedAddresses()
+        if lowercaseAddresses {
+          decoder.disableChecksummedAddresses()
+        } else {
+          decoder.enableChecksummedAddresses()
+        }
         decoder
       }
     }

package/src/sources/HyperSyncSource.res.js

@@ -124,6 +124,7 @@ function memoGetSelectionConfig(chain) {
 }
 
 function make(param) {
+  var lowercaseAddresses = param.lowercaseAddresses;
   var eventRouter = param.eventRouter;
   var shouldUseHypersyncClientDecoder = param.shouldUseHypersyncClientDecoder;
   var allEventSignatures = param.allEventSignatures;
@@ -131,7 +132,7 @@ function make(param) {
   var chain = param.chain;
   var getSelectionConfig = memoGetSelectionConfig(chain);
   var apiToken = Belt_Option.getWithDefault(param.apiToken, "3dc856dd-b0ea-494f-b27e-017b8b6b7e07");
-  var client = HyperSyncClient.make(endpointUrl, apiToken, param.clientTimeoutMillis, param.clientMaxRetries);
+  var client = HyperSyncClient.make(endpointUrl, apiToken, param.clientTimeoutMillis, param.clientMaxRetries, !lowercaseAddresses);
   var hscDecoder = {
     contents: undefined
   };
@@ -148,7 +149,11 @@ function make(param) {
       var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
       return ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate a decoder from hypersync client, please double check your ABI or try using 'event_decoder: viem' config option", exn);
     }
-    decoder$1.enableChecksummedAddresses();
+    if (lowercaseAddresses) {
+      decoder$1.disableChecksummedAddresses();
+    } else {
+      decoder$1.enableChecksummedAddresses();
+    }
     return decoder$1;
   };
   var UndefinedValue = /* @__PURE__ */Caml_exceptions.create("UndefinedValue");

package/src/sources/RpcSource.res

@@ -22,6 +22,7 @@ let rec getKnownBlockWithBackoff = async (
   ~chain,
   ~blockNumber,
   ~backoffMsOnFailure,
+  ~lowercaseAddresses: bool,
 ) =>
   switch await getKnownBlock(provider, blockNumber) {
   | exception err =>
@@ -39,8 +40,17 @@ let rec getKnownBlockWithBackoff = async (
       ~chain,
       ~blockNumber,
       ~backoffMsOnFailure=backoffMsOnFailure * 2,
+      ~lowercaseAddresses,
     )
-  | result => result
+  | result =>
+    if lowercaseAddresses {
+      // NOTE: this is wasteful if these fields are not selected in the users config.
+      //       There might be a better way to do this based on the block schema.
+      //       However this is not extremely expensive and good enough for now (only on rpc sync also).
+      // The in place mutation is cheapest.
+      (result->Obj.magic)["miner"] = result.miner->Address.Evm.fromAddressLowercaseOrThrow
+    }
+    result
   }
 let getSuggestedBlockIntervalFromExn = {
   // Unknown provider: "retry with the range 123-456"
@@ -453,9 +463,24 @@ type options = {
   chain: ChainMap.Chain.t,
   contracts: array<Internal.evmContractConfig>,
   eventRouter: EventRouter.t<Internal.evmEventConfig>,
+  allEventSignatures: array<string>,
+  shouldUseHypersyncClientDecoder: bool,
+  lowercaseAddresses: bool,
 }
 
-let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options): t => {
+let make = (
+  {
+    sourceFor,
+    syncConfig,
+    url,
+    chain,
+    contracts,
+    eventRouter,
+    allEventSignatures,
+    shouldUseHypersyncClientDecoder,
+    lowercaseAddresses,
+  }: options,
+): t => {
   let urlHost = switch sanitizeUrl(url) {
   | None =>
     Js.Exn.raiseError(
@@ -498,6 +523,7 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
         ~chain,
         ~backoffMsOnFailure=1000,
         ~blockNumber,
+        ~lowercaseAddresses,
       ),
     ~onError=(am, ~exn) => {
       Logging.error({
@@ -522,6 +548,7 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
   let getEventTransactionOrThrow = makeThrowingGetEventTransaction(
     ~getTransactionFields=Ethers.JsonRpcProvider.makeGetTransactionFields(
       ~getTransactionByHash=LazyLoader.get(transactionLoader, _),
+      ~lowercaseAddresses,
     ),
   )
 
@@ -530,6 +557,32 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
     contractNameAbiMapping->Js.Dict.set(contract.name, contract.abi)
   })
 
+  let convertEthersLogToHyperSyncEvent = (log: Ethers.log): HyperSyncClient.ResponseTypes.event => {
+    let hyperSyncLog: HyperSyncClient.ResponseTypes.log = {
+      removed: log.removed->Option.getWithDefault(false),
+      index: log.logIndex,
+      transactionIndex: log.transactionIndex,
+      transactionHash: log.transactionHash,
+      blockHash: log.blockHash,
+      blockNumber: log.blockNumber,
+      address: log.address,
+      data: log.data,
+      topics: log.topics->Array.map(topic => Js.Nullable.return(topic)),
+    }
+    {log: hyperSyncLog}
+  }
+
+  let hscDecoder: ref<option<HyperSyncClient.Decoder.t>> = ref(None)
+  let getHscDecoder = () => {
+    switch hscDecoder.contents {
+    | Some(decoder) => decoder
+    | None => {
+        let decoder = HyperSyncClient.Decoder.fromSignatures(allEventSignatures)
+        decoder
+      }
+    }
+  }
+
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
@@ -603,10 +656,106 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
       )
     }
 
-    let parsedQueueItems =
+    let parsedQueueItems = if shouldUseHypersyncClientDecoder {
+      // Convert Ethers logs to HyperSync events
+      let hyperSyncEvents = logs->Belt.Array.map(convertEthersLogToHyperSyncEvent)
+
+      // Decode using HyperSyncClient decoder
+      let parsedEvents = try await getHscDecoder().decodeEvents(hyperSyncEvents) catch {
+      | exn =>
+        raise(
+          Source.GetItemsError(
+            FailedParsingItems({
+              message: "Failed to parse events using hypersync client decoder. Please double-check your ABI.",
+              exn,
+              blockNumber: fromBlock,
+              logIndex: 0,
+            }),
+          ),
+        )
+      }
+
+      await logs
+      ->Array.zip(parsedEvents)
+      ->Array.keepMap(((
+        log: Ethers.log,
+        maybeDecodedEvent: Js.Nullable.t<HyperSyncClient.Decoder.decodedEvent>,
+      )) => {
+        let topic0 = log.topics[0]->Option.getWithDefault("0x0"->EvmTypes.Hex.fromStringUnsafe)
+        let routedAddress = if lowercaseAddresses {
+          log.address->Address.Evm.fromAddressLowercaseOrThrow
+        } else {
+          log.address
+        }
+
+        switch eventRouter->EventRouter.get(
+          ~tag=EventRouter.getEvmEventId(
+            ~sighash=topic0->EvmTypes.Hex.toString,
+            ~topicCount=log.topics->Array.length,
+          ),
+          ~indexingContracts,
+          ~contractAddress=routedAddress,
+          ~blockNumber=log.blockNumber,
+        ) {
+        | None => None
+        | Some(eventConfig) =>
+          switch maybeDecodedEvent {
+          | Js.Nullable.Value(decoded) =>
+            Some(
+              (
+                async () => {
+                  let (block, transaction) = try await Promise.all2((
+                    log->getEventBlockOrThrow,
+                    log->getEventTransactionOrThrow(
+                      ~transactionSchema=eventConfig.transactionSchema,
+                    ),
+                  )) catch {
+                  | exn =>
+                    raise(
+                      Source.GetItemsError(
+                        FailedGettingFieldSelection({
+                          message: "Failed getting selected fields. Please double-check your RPC provider returns correct data.",
+                          exn,
+                          blockNumber: log.blockNumber,
+                          logIndex: log.logIndex,
+                        }),
+                      ),
+                    )
+                  }
+
+                  Internal.Event({
+                    eventConfig: (eventConfig :> Internal.eventConfig),
+                    timestamp: block.timestamp,
+                    blockNumber: block.number,
+                    chain,
+                    logIndex: log.logIndex,
+                    event: {
+                      chainId: chain->ChainMap.Chain.toChainId,
+                      params: decoded->eventConfig.convertHyperSyncEventArgs,
+                      transaction,
+                      block: block->(
+                        Utils.magic: Ethers.JsonRpcProvider.block => Internal.eventBlock
+                      ),
+                      srcAddress: routedAddress,
+                      logIndex: log.logIndex,
+                    }->Internal.fromGenericEvent,
+                  })
+                }
+              )(),
+            )
+          | Js.Nullable.Null
+          | Js.Nullable.Undefined =>
+            None
+          }
+        }
+      })
+      ->Promise.all
+    } else {
+      // Decode using Viem
       await logs
       ->Belt.Array.keepMap(log => {
         let topic0 = log.topics->Js.Array2.unsafe_get(0)
+
         switch eventRouter->EventRouter.get(
           ~tag=EventRouter.getEvmEventId(
             ~sighash=topic0->EvmTypes.Hex.toString,
@@ -685,6 +834,7 @@ let make = ({sourceFor, syncConfig, url, chain, contracts, eventRouter}: options
         }
       })
       ->Promise.all
+    }
 
     let optFirstBlockParent = await firstBlockParentPromise