envio 3.0.0-alpha.7 → 3.0.0-alpha.9

package/evm.schema.json

@@ -84,17 +84,6 @@
         }
       ]
     },
-    "event_decoder": {
-      "description": "The event decoder to use for the indexer (default: hypersync-client)",
-      "anyOf": [
-        {
-          "$ref": "#/$defs/EventDecoder"
-        },
-        {
-          "type": "null"
-        }
-      ]
-    },
     "rollback_on_reorg": {
       "description": "A flag to indicate if the indexer should rollback to the last known valid block on a reorg. This currently incurs a performance hit on historical sync and is recommended to turn this off while developing (default: true)",
       "type": [
@@ -689,13 +678,6 @@
         "unordered"
       ]
     },
-    "EventDecoder": {
-      "type": "string",
-      "enum": [
-        "viem",
-        "hypersync-client"
-      ]
-    },
     "AddressFormat": {
       "type": "string",
       "enum": [

package/index.d.ts

@@ -193,8 +193,6 @@ type IndexerConfig = {
     contracts?: Record<string, EvmContractConfig>;
     /** Address format (default: "checksum"). */
     addressFormat?: "lowercase" | "checksum";
-    /** Event decoder (default: "hypersync"). */
-    eventDecoder?: "hypersync" | "viem";
   };
   /** Fuel ecosystem configuration. */
   fuel?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v3.0.0-alpha.7",
+  "version": "v3.0.0-alpha.9",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
@@ -29,10 +29,10 @@
     "node": ">=22.0.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "v3.0.0-alpha.7",
-    "envio-linux-arm64": "v3.0.0-alpha.7",
-    "envio-darwin-x64": "v3.0.0-alpha.7",
-    "envio-darwin-arm64": "v3.0.0-alpha.7"
+    "envio-linux-x64": "v3.0.0-alpha.9",
+    "envio-linux-arm64": "v3.0.0-alpha.9",
+    "envio-darwin-x64": "v3.0.0-alpha.9",
+    "envio-darwin-arm64": "v3.0.0-alpha.9"
   },
   "dependencies": {
     "@clickhouse/client": "1.12.1",
@@ -56,7 +56,7 @@
     "ink": "6.5.1",
     "ink-big-text": "2.0.0",
     "ink-spinner": "5.0.0",
-    "postgres": "3.4.1",
+    "postgres": "3.4.8",
     "tsx": "4.21.0"
   },
   "files": [

package/src/Config.res

@@ -101,14 +101,12 @@ let publicConfigEcosystemSchema = S.schema(s =>
 )
 
 type addressFormat = | @as("lowercase") Lowercase | @as("checksum") Checksum
-type decoder = | @as("hypersync") Hypersync | @as("viem") Viem
 
 let publicConfigEvmSchema = S.schema(s =>
   {
     "chains": s.matches(S.dict(publicConfigChainSchema)),
     "contracts": s.matches(S.option(S.dict(contractConfigSchema))),
     "addressFormat": s.matches(S.option(S.enum([Lowercase, Checksum]))),
-    "eventDecoder": s.matches(S.option(S.enum([Hypersync, Viem]))),
   }
 )
 
@@ -160,19 +158,9 @@ let fromPublic = (
   }
 
   // Extract EVM-specific options with defaults
-  let (lowercaseAddresses, shouldUseHypersyncClientDecoder) = switch publicConfig["evm"] {
-  | Some(evm) => (
-      evm["addressFormat"]->Option.getWithDefault(Checksum) == Lowercase,
-      evm["eventDecoder"]->Option.getWithDefault(Hypersync) == Hypersync,
-    )
-  | None => (false, true)
-  }
-
-  // Validate that lowercase addresses is not used with viem decoder
-  if lowercaseAddresses && !shouldUseHypersyncClientDecoder {
-    Js.Exn.raiseError(
-      "lowercase addresses is not supported when event_decoder is 'viem'. Please set event_decoder to 'hypersync-client' or change address_format to 'checksum'.",
-    )
+  let lowercaseAddresses = switch publicConfig["evm"] {
+  | Some(evm) => evm["addressFormat"]->Option.getWithDefault(Checksum) == Lowercase
+  | None => false
   }
 
   // Parse ABIs from public config

package/src/Config.res.mjs

@@ -44,10 +44,6 @@ var publicConfigEvmSchema = S$RescriptSchema.schema(function (s) {
               addressFormat: s.m(S$RescriptSchema.option(S$RescriptSchema.$$enum([
                             "lowercase",
                             "checksum"
-                          ]))),
-              eventDecoder: s.m(S$RescriptSchema.option(S$RescriptSchema.$$enum([
-                            "hypersync",
-                            "viem"
                           ])))
             };
     });
@@ -113,32 +109,16 @@ function fromPublic(publicConfigJson, codegenChainsOpt, maxAddrInPartitionOpt, u
   var ecosystemName = match$3[1];
   var publicChainsConfig = match$3[0];
   var evm = publicConfig.evm;
-  var match$4;
-  if (evm !== undefined) {
-    var evm$1 = Caml_option.valFromOption(evm);
-    match$4 = [
-      Belt_Option.getWithDefault(evm$1.addressFormat, "checksum") === "lowercase",
-      Belt_Option.getWithDefault(evm$1.eventDecoder, "hypersync") === "hypersync"
-    ];
-  } else {
-    match$4 = [
-      false,
-      true
-    ];
-  }
-  var lowercaseAddresses = match$4[0];
-  if (lowercaseAddresses && !match$4[1]) {
-    Js_exn.raiseError("lowercase addresses is not supported when event_decoder is 'viem'. Please set event_decoder to 'hypersync-client' or change address_format to 'checksum'.");
-  }
-  var match$5 = publicConfig.evm;
-  var match$6 = publicConfig.fuel;
+  var lowercaseAddresses = evm !== undefined ? Belt_Option.getWithDefault(Caml_option.valFromOption(evm).addressFormat, "checksum") === "lowercase" : false;
+  var match$4 = publicConfig.evm;
+  var match$5 = publicConfig.fuel;
   var publicContractsConfig;
   switch (ecosystemName) {
     case "evm" :
-        publicContractsConfig = match$5 !== undefined ? Caml_option.valFromOption(match$5).contracts : undefined;
+        publicContractsConfig = match$4 !== undefined ? Caml_option.valFromOption(match$4).contracts : undefined;
         break;
     case "fuel" :
-        publicContractsConfig = match$6 !== undefined ? Caml_option.valFromOption(match$6).contracts : undefined;
+        publicContractsConfig = match$5 !== undefined ? Caml_option.valFromOption(match$5).contracts : undefined;
         break;
     case "svm" :
         publicContractsConfig = undefined;

package/src/TestIndexer.res

@@ -23,6 +23,20 @@ type testIndexerState = {
   mutable processChanges: array<unknown>,
 }
 
+// Cast Internal.entity back to DynamicContractRegistry.t
+external castFromDcRegistry: Internal.entity => InternalTable.DynamicContractRegistry.t =
+  "%identity"
+
+// Convert DynamicContractRegistry.t to Internal.indexingContract
+let toIndexingContract = (
+  dc: InternalTable.DynamicContractRegistry.t,
+): Internal.indexingContract => {
+  address: dc.contractAddress,
+  contractName: dc.contractName,
+  startBlock: dc.registeringEventBlockNumber,
+  registrationBlock: Some(dc.registeringEventBlockNumber),
+}
+
 let handleLoadByIds = (
   state: testIndexerState,
   ~tableName: string,
@@ -220,6 +234,7 @@ let handleWriteBatch = (
 let makeInitialState = (
   ~config: Config.t,
   ~processConfigChains: Js.Dict.t<chainConfig>,
+  ~dynamicContractsByChain: dict<array<Internal.indexingContract>>,
 ): Persistence.initialState => {
   let chainKeys = processConfigChains->Js.Dict.keys
   let chains = chainKeys->Array.map(chainIdStr => {
@@ -231,6 +246,10 @@ let makeInitialState = (
     }
 
     let processChainConfig = processConfigChains->Js.Dict.unsafeGet(chainIdStr)
+    let dynamicContracts =
+      dynamicContractsByChain
+      ->Js.Dict.get(chainIdStr)
+      ->Option.getWithDefault([])
     {
       Persistence.id: chainId,
       startBlock: processChainConfig.startBlock,
@@ -241,7 +260,7 @@ let makeInitialState = (
       numEventsProcessed: 0,
       firstEventBlockNumber: None,
       timestampCaughtUpToHeadOrEndblock: None,
-      dynamicContracts: [],
+      dynamicContracts,
     }
   })
 
@@ -344,8 +363,33 @@ let makeCreateTestIndexer = (
         // Reset processChanges for this run
         state.processChanges = []
 
+        // Extract dynamic contracts from state.entities for each chain
+        let dynamicContractsByChain: dict<array<Internal.indexingContract>> = Js.Dict.empty()
+        switch state.entities->Js.Dict.get(InternalTable.DynamicContractRegistry.name) {
+        | Some(dcDict) =>
+          dcDict
+          ->Js.Dict.values
+          ->Array.forEach(entity => {
+            let dc = entity->castFromDcRegistry
+            let chainIdStr = dc.chainId->Int.toString
+            let contracts = switch dynamicContractsByChain->Js.Dict.get(chainIdStr) {
+            | Some(arr) => arr
+            | None =>
+              let arr = []
+              dynamicContractsByChain->Js.Dict.set(chainIdStr, arr)
+              arr
+            }
+            contracts->Array.push(dc->toIndexingContract)->ignore
+          })
+        | None => ()
+        }
+
         // Create initialState from processConfig chains
-        let initialState = makeInitialState(~config, ~processConfigChains=chains)
+        let initialState = makeInitialState(
+          ~config,
+          ~processConfigChains=chains,
+          ~dynamicContractsByChain,
+        )
 
         Promise.make((resolve, reject) => {
           // Include initialState in workerData

package/src/TestIndexer.res.mjs

@@ -20,6 +20,15 @@ import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
 import * as TestIndexerProxyStorage from "./TestIndexerProxyStorage.res.mjs";
 
+function toIndexingContract(dc) {
+  return {
+          address: dc.contract_address,
+          contractName: dc.contract_name,
+          startBlock: dc.registering_event_block_number,
+          registrationBlock: dc.registering_event_block_number
+        };
+}
+
 function handleLoadByIds(state, tableName, ids) {
   var entityDict = Belt_Option.getWithDefault(Js_dict.get(state.entities, tableName), {});
   var entityConfig = state.entityConfigs[tableName];
@@ -183,7 +192,7 @@ function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChain
   }
 }
 
-function makeInitialState(config, processConfigChains) {
+function makeInitialState(config, processConfigChains, dynamicContractsByChain) {
   var chainKeys = Object.keys(processConfigChains);
   var chains = Belt_Array.map(chainKeys, (function (chainIdStr) {
           var chainId = Belt_Option.getWithDefault(Belt_Int.fromString(chainIdStr), 0);
@@ -192,6 +201,7 @@ function makeInitialState(config, processConfigChains) {
             Js_exn.raiseError("Chain " + chainIdStr + " is not configured in config.yaml");
           }
           var processChainConfig = processConfigChains[chainIdStr];
+          var dynamicContracts = Belt_Option.getWithDefault(Js_dict.get(dynamicContractsByChain, chainIdStr), []);
           return {
                   id: chainId,
                   startBlock: processChainConfig.startBlock,
@@ -201,7 +211,7 @@ function makeInitialState(config, processConfigChains) {
                   numEventsProcessed: 0,
                   firstEventBlockNumber: undefined,
                   timestampCaughtUpToHeadOrEndblock: undefined,
-                  dynamicContracts: [],
+                  dynamicContracts: dynamicContracts,
                   sourceBlockNumber: processChainConfig.endBlock
                 };
         }));
@@ -268,7 +278,24 @@ function makeCreateTestIndexer(config, workerPath, allEntities) {
                         validateBlockRange(chainIdStr, configChain, processChainConfig, progressBlock);
                       }));
                 state.processChanges = [];
-                var initialState = makeInitialState(config, chains);
+                var dynamicContractsByChain = {};
+                var dcDict = Js_dict.get(state.entities, InternalTable.DynamicContractRegistry.name);
+                if (dcDict !== undefined) {
+                  Belt_Array.forEach(Js_dict.values(dcDict), (function (entity) {
+                          var chainIdStr = String(entity.chain_id);
+                          var arr = Js_dict.get(dynamicContractsByChain, chainIdStr);
+                          var contracts;
+                          if (arr !== undefined) {
+                            contracts = arr;
+                          } else {
+                            var arr$1 = [];
+                            dynamicContractsByChain[chainIdStr] = arr$1;
+                            contracts = arr$1;
+                          }
+                          contracts.push(toIndexingContract(entity));
+                        }));
+                }
+                var initialState = makeInitialState(config, chains, dynamicContractsByChain);
                 return new Promise((function (resolve, reject) {
                               var workerDataObj = {
                                 processConfig: JSON.parse(Js_json.serializeExn(processConfig)),
@@ -358,6 +385,7 @@ function initTestWorker(makeGeneratedConfig, makePersistence) {
 }
 
 export {
+  toIndexingContract ,
   handleLoadByIds ,
   handleLoadByField ,
   handleWriteBatch ,

package/src/sources/EvmChain.res

@@ -47,7 +47,6 @@ let makeSources = (
   ~contracts: array<Internal.evmContractConfig>,
   ~hyperSync,
   ~allEventSignatures,
-  ~shouldUseHypersyncClientDecoder,
   ~rpcs: array<rpc>,
   ~lowercaseAddresses,
 ) => {
@@ -60,11 +59,9 @@ let makeSources = (
   | Some(endpointUrl) => [
       HyperSyncSource.make({
         chain,
-        contracts,
         endpointUrl,
         allEventSignatures,
         eventRouter,
-        shouldUseHypersyncClientDecoder,
         apiToken: Env.envioApiToken,
         clientMaxRetries: Env.hyperSyncClientMaxRetries,
         clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
@@ -80,12 +77,10 @@ let makeSources = (
       RpcSource.make({
         chain,
         sourceFor,
-        contracts,
         syncConfig: getSyncConfig(syncConfig->Option.getWithDefault({})),
         url,
         eventRouter,
         allEventSignatures,
-        shouldUseHypersyncClientDecoder,
         lowercaseAddresses,
       }),
     )

package/src/sources/EvmChain.res.mjs

@@ -20,16 +20,14 @@ function getSyncConfig(param) {
         };
 }
 
-function makeSources(chain, contracts, hyperSync, allEventSignatures, shouldUseHypersyncClientDecoder, rpcs, lowercaseAddresses) {
+function makeSources(chain, contracts, hyperSync, allEventSignatures, rpcs, lowercaseAddresses) {
   var eventRouter = EventRouter.fromEvmEventModsOrThrow(Belt_Array.flatMap(contracts, (function (contract) {
               return contract.events;
             })), chain);
   var sources = hyperSync !== undefined ? [HyperSyncSource.make({
-            contracts: contracts,
             chain: chain,
             endpointUrl: hyperSync,
             allEventSignatures: allEventSignatures,
-            shouldUseHypersyncClientDecoder: shouldUseHypersyncClientDecoder,
             eventRouter: eventRouter,
             apiToken: Env.envioApiToken,
             clientMaxRetries: Env.hyperSyncClientMaxRetries,
@@ -44,10 +42,8 @@ function makeSources(chain, contracts, hyperSync, allEventSignatures, shouldUseH
                   syncConfig: getSyncConfig(Belt_Option.getWithDefault(param.syncConfig, {})),
                   url: param.url,
                   chain: chain,
-                  contracts: contracts,
                   eventRouter: eventRouter,
                   allEventSignatures: allEventSignatures,
-                  shouldUseHypersyncClientDecoder: shouldUseHypersyncClientDecoder,
                   lowercaseAddresses: lowercaseAddresses
                 }));
       });

package/src/sources/HyperSyncSource.res

@@ -145,11 +145,9 @@ let memoGetSelectionConfig = (~chain) => {
 }
 
 type options = {
-  contracts: array<Internal.evmContractConfig>,
   chain: ChainMap.Chain.t,
   endpointUrl: string,
   allEventSignatures: array<string>,
-  shouldUseHypersyncClientDecoder: bool,
   eventRouter: EventRouter.t<Internal.evmEventConfig>,
   apiToken: option<string>,
   clientMaxRetries: int,
@@ -161,11 +159,9 @@ type options = {
 
 let make = (
   {
-    contracts,
     chain,
     endpointUrl,
     allEventSignatures,
-    shouldUseHypersyncClientDecoder,
     eventRouter,
     apiToken,
     clientMaxRetries,
@@ -205,7 +201,7 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
       switch HyperSyncClient.Decoder.fromSignatures(allEventSignatures) {
       | exception exn =>
         exn->ErrorHandling.mkLogAndRaise(
-          ~msg="Failed to instantiate a decoder from hypersync client, please double check your ABI or try using 'event_decoder: viem' config option",
+          ~msg="Failed to instantiate a decoder from hypersync client, please double check your ABI",
         )
       | decoder =>
         if lowercaseAddresses {
@@ -245,11 +241,6 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
     })
   }
 
-  let contractNameAbiMapping = Js.Dict.empty()
-  contracts->Belt.Array.forEach(contract => {
-    contractNameAbiMapping->Js.Dict.set(contract.name, contract.abi)
-  })
-
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
@@ -402,7 +393,6 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
 
     let handleDecodeFailure = (
       ~eventConfig: Internal.evmEventConfig,
-      ~decoder,
       ~logIndex,
       ~blockNumber,
       ~chainId,
@@ -419,72 +409,28 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
             "chainId": chainId,
             "blockNumber": blockNumber,
             "logIndex": logIndex,
-            "decoder": decoder,
+            "decoder": "hypersync-client",
           },
         )
         exn->ErrorHandling.mkLogAndRaise(~msg, ~logger)
       }
     }
-    if shouldUseHypersyncClientDecoder {
-      //Currently there are still issues with decoder for some cases so
-      //this can only be activated with a flag
-
-      //Parse page items into queue items
-      let parsedEvents = switch await getHscDecoder().decodeEvents(pageUnsafe.events) {
-      | exception exn =>
-        exn->mkLogAndRaise(
-          ~msg="Failed to parse events using hypersync client, please double check your ABI.",
-        )
-      | parsedEvents => parsedEvents
-      }
 
-      pageUnsafe.items->Belt.Array.forEachWithIndex((index, item) => {
-        let {block, log} = item
-        let chainId = chain->ChainMap.Chain.toChainId
-        let topic0 = log.topics->Js.Array2.unsafe_get(0)
-        let maybeEventConfig =
-          eventRouter->EventRouter.get(
-            ~tag=EventRouter.getEvmEventId(
-              ~sighash=topic0->EvmTypes.Hex.toString,
-              ~topicCount=log.topics->Array.length,
-            ),
-            ~indexingContracts,
-            ~contractAddress=log.address,
-            ~blockNumber=block.number->Belt.Option.getUnsafe,
-          )
-        let maybeDecodedEvent = parsedEvents->Js.Array2.unsafe_get(index)
-
-        switch (maybeEventConfig, maybeDecodedEvent) {
-        | (Some(eventConfig), Value(decoded)) =>
-          parsedQueueItems
-          ->Js.Array2.push(
-            makeEventBatchQueueItem(
-              item,
-              ~params=decoded->eventConfig.convertHyperSyncEventArgs,
-              ~eventConfig,
-            ),
-          )
-          ->ignore
-        | (Some(eventConfig), Null | Undefined) =>
-          handleDecodeFailure(
-            ~eventConfig,
-            ~decoder="hypersync-client",
-            ~logIndex=log.logIndex,
-            ~blockNumber=block.number->Belt.Option.getUnsafe,
-            ~chainId,
-            ~exn=UndefinedValue,
-          )
-        | (None, _) => () //ignore events that aren't registered
-        }
-      })
-    } else {
-      //Parse with viem -> slower than the HyperSyncClient
-      pageUnsafe.items->Array.forEach(item => {
-        let {block, log} = item
-        let chainId = chain->ChainMap.Chain.toChainId
-        let topic0 = log.topics->Js.Array2.unsafe_get(0)
+    //Parse page items into queue items
+    let parsedEvents = switch await getHscDecoder().decodeEvents(pageUnsafe.events) {
+    | exception exn =>
+      exn->mkLogAndRaise(
+        ~msg="Failed to parse events using hypersync client, please double check your ABI.",
+      )
+    | parsedEvents => parsedEvents
+    }
 
-        switch eventRouter->EventRouter.get(
+    pageUnsafe.items->Belt.Array.forEachWithIndex((index, item) => {
+      let {block, log} = item
+      let chainId = chain->ChainMap.Chain.toChainId
+      let topic0 = log.topics->Js.Array2.unsafe_get(0)
+      let maybeEventConfig =
+        eventRouter->EventRouter.get(
           ~tag=EventRouter.getEvmEventId(
             ~sighash=topic0->EvmTypes.Hex.toString,
             ~topicCount=log.topics->Array.length,
@@ -492,31 +438,31 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
           ~indexingContracts,
           ~contractAddress=log.address,
           ~blockNumber=block.number->Belt.Option.getUnsafe,
-        ) {
-        | Some(eventConfig) =>
-          switch contractNameAbiMapping->Viem.parseLogOrThrow(
-            ~contractName=eventConfig.contractName,
-            ~topics=log.topics,
-            ~data=log.data,
-          ) {
-          | exception exn =>
-            handleDecodeFailure(
-              ~eventConfig,
-              ~decoder="viem",
-              ~logIndex=log.logIndex,
-              ~blockNumber=block.number->Belt.Option.getUnsafe,
-              ~chainId,
-              ~exn,
-            )
-          | decodedEvent =>
-            parsedQueueItems
-            ->Js.Array2.push(makeEventBatchQueueItem(item, ~params=decodedEvent.args, ~eventConfig))
-            ->ignore
-          }
-        | None => () //Ignore events that aren't registered
-        }
-      })
-    }
+        )
+      let maybeDecodedEvent = parsedEvents->Js.Array2.unsafe_get(index)
+
+      switch (maybeEventConfig, maybeDecodedEvent) {
+      | (Some(eventConfig), Value(decoded)) =>
+        parsedQueueItems
+        ->Js.Array2.push(
+          makeEventBatchQueueItem(
+            item,
+            ~params=decoded->eventConfig.convertHyperSyncEventArgs,
+            ~eventConfig,
+          ),
+        )
+        ->ignore
+      | (Some(eventConfig), Null | Undefined) =>
+        handleDecodeFailure(
+          ~eventConfig,
+          ~logIndex=log.logIndex,
+          ~blockNumber=block.number->Belt.Option.getUnsafe,
+          ~chainId,
+          ~exn=UndefinedValue,
+        )
+      | (None, _) => () //ignore events that aren't registered
+      }
+    })
 
     let parsingTimeElapsed = parsingTimeRef->Hrtime.timeSince->Hrtime.toMillis->Hrtime.intFromMillis
 

package/src/sources/HyperSyncSource.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Rest from "../vendored/Rest.res.mjs";
-import * as Viem from "../bindings/Viem.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Js_exn from "rescript/lib/es6/js_exn.js";
@@ -127,7 +126,6 @@ function make(param) {
   var lowercaseAddresses = param.lowercaseAddresses;
   var apiToken = param.apiToken;
   var eventRouter = param.eventRouter;
-  var shouldUseHypersyncClientDecoder = param.shouldUseHypersyncClientDecoder;
   var allEventSignatures = param.allEventSignatures;
   var endpointUrl = param.endpointUrl;
   var chain = param.chain;
@@ -148,7 +146,7 @@ function make(param) {
     }
     catch (raw_exn){
       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);
+      return ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate a decoder from hypersync client, please double check your ABI", exn);
     }
     if (lowercaseAddresses) {
       decoder$1.disableChecksummedAddresses();
@@ -178,10 +176,6 @@ function make(param) {
             }
           };
   };
-  var contractNameAbiMapping = {};
-  Belt_Array.forEach(param.contracts, (function (contract) {
-          contractNameAbiMapping[contract.name] = contract.abi;
-        }));
   var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, knownHeight, param, selection, retry, logger) {
     var mkLogAndRaise = function (extra, extra$1) {
       return ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
@@ -292,67 +286,46 @@ function make(param) {
     }
     var parsingTimeRef = Hrtime.makeTimer();
     var parsedQueueItems = [];
-    var handleDecodeFailure = function (eventConfig, decoder, logIndex, blockNumber, chainId, exn) {
-      if (eventConfig.isWildcard) {
-        return ;
-      }
-      var msg = "Event " + eventConfig.name + " was unexpectedly parsed as undefined";
-      var logger$1 = Logging.createChildFrom(logger, {
-            chainId: chainId,
-            blockNumber: blockNumber,
-            logIndex: logIndex,
-            decoder: decoder
-          });
-      ErrorHandling.mkLogAndRaise(logger$1, msg, exn);
-    };
-    if (shouldUseHypersyncClientDecoder) {
-      var parsedEvents;
-      try {
-        parsedEvents = await getHscDecoder().decodeEvents(pageUnsafe.events);
-      }
-      catch (raw_exn$1){
-        var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
-        parsedEvents = mkLogAndRaise("Failed to parse events using hypersync client, please double check your ABI.", exn$1);
-      }
-      Belt_Array.forEachWithIndex(pageUnsafe.items, (function (index, item) {
-              var block = item.block;
-              var log = item.log;
-              var topic0 = log.topics[0];
-              var maybeEventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), log.address, block.number, indexingContracts);
-              var maybeDecodedEvent = parsedEvents[index];
-              if (maybeEventConfig === undefined) {
-                return ;
-              }
-              if (maybeDecodedEvent === null || maybeDecodedEvent === undefined) {
-                maybeDecodedEvent === null;
-              } else {
-                parsedQueueItems.push(makeEventBatchQueueItem(item, maybeEventConfig.convertHyperSyncEventArgs(maybeDecodedEvent), maybeEventConfig));
-                return ;
-              }
-              handleDecodeFailure(maybeEventConfig, "hypersync-client", log.logIndex, block.number, chain, {
-                    RE_EXN_ID: UndefinedValue
-                  });
-            }));
-    } else {
-      Belt_Array.forEach(pageUnsafe.items, (function (item) {
-              var block = item.block;
-              var log = item.log;
-              var topic0 = log.topics[0];
-              var eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), log.address, block.number, indexingContracts);
-              if (eventConfig === undefined) {
-                return ;
-              }
-              var decodedEvent;
-              try {
-                decodedEvent = Viem.parseLogOrThrow(contractNameAbiMapping, eventConfig.contractName, log.topics, log.data);
-              }
-              catch (raw_exn){
-                var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-                return handleDecodeFailure(eventConfig, "viem", log.logIndex, block.number, chain, exn);
-              }
-              parsedQueueItems.push(makeEventBatchQueueItem(item, decodedEvent.args, eventConfig));
-            }));
+    var parsedEvents;
+    try {
+      parsedEvents = await getHscDecoder().decodeEvents(pageUnsafe.events);
     }
+    catch (raw_exn$1){
+      var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+      parsedEvents = mkLogAndRaise("Failed to parse events using hypersync client, please double check your ABI.", exn$1);
+    }
+    Belt_Array.forEachWithIndex(pageUnsafe.items, (function (index, item) {
+            var block = item.block;
+            var log = item.log;
+            var topic0 = log.topics[0];
+            var maybeEventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), log.address, block.number, indexingContracts);
+            var maybeDecodedEvent = parsedEvents[index];
+            if (maybeEventConfig === undefined) {
+              return ;
+            }
+            if (maybeDecodedEvent === null || maybeDecodedEvent === undefined) {
+              maybeDecodedEvent === null;
+            } else {
+              parsedQueueItems.push(makeEventBatchQueueItem(item, maybeEventConfig.convertHyperSyncEventArgs(maybeDecodedEvent), maybeEventConfig));
+              return ;
+            }
+            var logIndex = log.logIndex;
+            var blockNumber = block.number;
+            var exn = {
+              RE_EXN_ID: UndefinedValue
+            };
+            if (maybeEventConfig.isWildcard) {
+              return ;
+            }
+            var msg = "Event " + maybeEventConfig.name + " was unexpectedly parsed as undefined";
+            var logger$1 = Logging.createChildFrom(logger, {
+                  chainId: chain,
+                  blockNumber: blockNumber,
+                  logIndex: logIndex,
+                  decoder: "hypersync-client"
+                });
+            ErrorHandling.mkLogAndRaise(logger$1, msg, exn);
+          }));
     var parsingTimeElapsed = Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(parsingTimeRef)));
     var rangeLastBlock = await lastBlockQueriedPromise;
     var reorgGuard_prevRangeLastBlock = Belt_Option.map(pageUnsafe.rollbackGuard, (function (v) {

package/src/sources/RpcSource.res

@@ -468,25 +468,13 @@ type options = {
   syncConfig: Config.sourceSync,
   url: string,
   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,
-    allEventSignatures,
-    shouldUseHypersyncClientDecoder,
-    lowercaseAddresses,
-  }: options,
+  {sourceFor, syncConfig, url, chain, eventRouter, allEventSignatures, lowercaseAddresses}: options,
 ): t => {
   let urlHost = switch sanitizeUrl(url) {
   | None =>
@@ -572,11 +560,6 @@ let make = (
     ),
   )
 
-  let contractNameAbiMapping = Js.Dict.empty()
-  contracts->Belt.Array.forEach(contract => {
-    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),
@@ -676,26 +659,26 @@ let make = (
       )
     }
 
-    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(
-            FailedGettingItems({
-              exn,
-              attemptedToBlock: toBlock,
-              retry: ImpossibleForTheQuery({
-                message: "Failed to parse events using hypersync client decoder. Please double-check your ABI.",
-              }),
+    // 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(
+          FailedGettingItems({
+            exn,
+            attemptedToBlock: toBlock,
+            retry: ImpossibleForTheQuery({
+              message: "Failed to parse events using hypersync client decoder. Please double-check your ABI.",
             }),
-          ),
-        )
-      }
+          }),
+        ),
+      )
+    }
 
+    let parsedQueueItems =
       await logs
       ->Array.zip(parsedEvents)
       ->Array.keepMap(((
@@ -771,92 +754,6 @@ let make = (
         }
       })
       ->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,
-            ~topicCount=log.topics->Array.length,
-          ),
-          ~indexingContracts,
-          ~contractAddress=log.address,
-          ~blockNumber=log.blockNumber,
-        ) {
-        | None => None //ignore events that aren't registered
-        | Some(eventConfig) =>
-          let blockNumber = log.blockNumber
-          let logIndex = log.logIndex
-          Some(
-            (
-              async () => {
-                let (block, transaction) = try await Promise.all2((
-                  log->getEventBlockOrThrow,
-                  log->getEventTransactionOrThrow(~transactionSchema=eventConfig.transactionSchema),
-                )) catch {
-                // Promise.catch won't work here, because the error
-                // might be thrown before a microtask is created
-                | exn =>
-                  raise(
-                    Source.GetItemsError(
-                      FailedGettingFieldSelection({
-                        message: "Failed getting selected fields. Please double-check your RPC provider returns correct data.",
-                        exn,
-                        blockNumber,
-                        logIndex,
-                      }),
-                    ),
-                  )
-                }
-
-                let decodedEvent = try contractNameAbiMapping->Viem.parseLogOrThrow(
-                  ~contractName=eventConfig.contractName,
-                  ~topics=log.topics,
-                  ~data=log.data,
-                ) catch {
-                | exn =>
-                  raise(
-                    Source.GetItemsError(
-                      FailedGettingItems({
-                        exn,
-                        attemptedToBlock: toBlock,
-                        retry: ImpossibleForTheQuery({
-                          message: `Failed to parse event with viem, please double-check your ABI. Block number: ${blockNumber->Int.toString}, log index: ${logIndex->Int.toString}`,
-                        }),
-                      }),
-                    ),
-                  )
-                }
-
-                Internal.Event({
-                  eventConfig: (eventConfig :> Internal.eventConfig),
-                  timestamp: block.timestamp,
-                  blockNumber: block.number,
-                  chain,
-                  logIndex: log.logIndex,
-                  event: {
-                    chainId: chain->ChainMap.Chain.toChainId,
-                    params: decodedEvent.args,
-                    transaction,
-                    // Unreliably expect that the Ethers block fields match the types in HyperIndex
-                    // I assume this is wrong in some cases, so we need to fix it in the future
-                    block: block->(
-                      Utils.magic: Ethers.JsonRpcProvider.block => Internal.eventBlock
-                    ),
-                    srcAddress: log.address,
-                    logIndex: log.logIndex,
-                  }->Internal.fromGenericEvent,
-                })
-              }
-            )(),
-          )
-        }
-      })
-      ->Promise.all
-    }
 
     let optFirstBlockParent = await firstBlockParentPromise
 

package/src/sources/RpcSource.res.mjs

@@ -4,7 +4,6 @@ import * as Rpc from "./Rpc.res.mjs";
 import * as Caml from "rescript/lib/es6/caml.js";
 import * as Rest from "../vendored/Rest.res.mjs";
 import * as Time from "../Time.res.mjs";
-import * as Viem from "../bindings/Viem.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Ethers from "../bindings/Ethers.res.mjs";
 import * as Hrtime from "../bindings/Hrtime.res.mjs";
@@ -506,7 +505,6 @@ function sanitizeUrl(url) {
 
 function make(param) {
   var lowercaseAddresses = param.lowercaseAddresses;
-  var shouldUseHypersyncClientDecoder = param.shouldUseHypersyncClientDecoder;
   var allEventSignatures = param.allEventSignatures;
   var eventRouter = param.eventRouter;
   var chain = param.chain;
@@ -568,10 +566,6 @@ function make(param) {
                 return Js_exn.raiseError("Transaction not found for hash: " + transactionHash);
               }
             }), lowercaseAddresses));
-  var contractNameAbiMapping = {};
-  Belt_Array.forEach(param.contracts, (function (contract) {
-          contractNameAbiMapping[contract.name] = contract.abi;
-        }));
   var convertEthersLogToHyperSyncEvent = function (log) {
     var hyperSyncLog_removed = Belt_Option.getWithDefault(log.removed, false);
     var hyperSyncLog_logIndex = log.index;
@@ -630,88 +624,34 @@ function make(param) {
     if (executedBlockInterval >= suggestedBlockInterval && !Utils.Dict.has(mutSuggestedBlockIntervals, maxSuggestedBlockIntervalKey)) {
       mutSuggestedBlockIntervals[partitionId] = Caml.int_min(executedBlockInterval + syncConfig.accelerationAdditive | 0, syncConfig.intervalCeiling);
     }
-    var parsedQueueItems;
-    if (shouldUseHypersyncClientDecoder) {
-      var hyperSyncEvents = Belt_Array.map(logs, convertEthersLogToHyperSyncEvent);
-      var parsedEvents;
-      try {
-        parsedEvents = await getHscDecoder().decodeEvents(hyperSyncEvents);
-      }
-      catch (raw_exn){
-        var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-        throw {
-              RE_EXN_ID: Source.GetItemsError,
-              _1: {
-                TAG: "FailedGettingItems",
-                exn: exn,
-                attemptedToBlock: toBlock$1,
-                retry: {
-                  TAG: "ImpossibleForTheQuery",
-                  message: "Failed to parse events using hypersync client decoder. Please double-check your ABI."
-                }
-              },
-              Error: new Error()
-            };
-      }
-      parsedQueueItems = await Promise.all(Belt_Array.keepMap(Belt_Array.zip(logs, parsedEvents), (function (param) {
-                  var maybeDecodedEvent = param[1];
-                  var log = param[0];
-                  var topic0 = Belt_Option.getWithDefault(Belt_Array.get(log.topics, 0), "0x0");
-                  var routedAddress = lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(log.address) : log.address;
-                  var eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), routedAddress, log.blockNumber, indexingContracts);
-                  if (eventConfig !== undefined && !(maybeDecodedEvent === null || maybeDecodedEvent === undefined)) {
-                    return Caml_option.some((async function () {
-                                    var match;
-                                    try {
-                                      match = await Promise.all([
-                                            getEventBlockOrThrow(log),
-                                            getEventTransactionOrThrow(log, eventConfig.transactionSchema)
-                                          ]);
-                                    }
-                                    catch (raw_exn){
-                                      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-                                      throw {
-                                            RE_EXN_ID: Source.GetItemsError,
-                                            _1: {
-                                              TAG: "FailedGettingFieldSelection",
-                                              exn: exn,
-                                              blockNumber: log.blockNumber,
-                                              logIndex: log.index,
-                                              message: "Failed getting selected fields. Please double-check your RPC provider returns correct data."
-                                            },
-                                            Error: new Error()
-                                          };
-                                    }
-                                    var block = match[0];
-                                    return {
-                                            kind: 0,
-                                            eventConfig: eventConfig,
-                                            timestamp: block.timestamp,
-                                            chain: chain,
-                                            blockNumber: block.number,
-                                            logIndex: log.index,
-                                            event: {
-                                              params: eventConfig.convertHyperSyncEventArgs(maybeDecodedEvent),
-                                              chainId: chain,
-                                              srcAddress: routedAddress,
-                                              logIndex: log.index,
-                                              transaction: match[1],
-                                              block: block
-                                            }
-                                          };
-                                  })());
-                  }
-                  
-                })));
-    } else {
-      parsedQueueItems = await Promise.all(Belt_Array.keepMap(logs, (function (log) {
-                  var topic0 = log.topics[0];
-                  var eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), log.address, log.blockNumber, indexingContracts);
-                  if (eventConfig === undefined) {
-                    return ;
-                  }
-                  var blockNumber = log.blockNumber;
-                  var logIndex = log.index;
+    var hyperSyncEvents = Belt_Array.map(logs, convertEthersLogToHyperSyncEvent);
+    var parsedEvents;
+    try {
+      parsedEvents = await getHscDecoder().decodeEvents(hyperSyncEvents);
+    }
+    catch (raw_exn){
+      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      throw {
+            RE_EXN_ID: Source.GetItemsError,
+            _1: {
+              TAG: "FailedGettingItems",
+              exn: exn,
+              attemptedToBlock: toBlock$1,
+              retry: {
+                TAG: "ImpossibleForTheQuery",
+                message: "Failed to parse events using hypersync client decoder. Please double-check your ABI."
+              }
+            },
+            Error: new Error()
+          };
+    }
+    var parsedQueueItems = await Promise.all(Belt_Array.keepMap(Belt_Array.zip(logs, parsedEvents), (function (param) {
+                var maybeDecodedEvent = param[1];
+                var log = param[0];
+                var topic0 = Belt_Option.getWithDefault(Belt_Array.get(log.topics, 0), "0x0");
+                var routedAddress = lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(log.address) : log.address;
+                var eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), routedAddress, log.blockNumber, indexingContracts);
+                if (eventConfig !== undefined && !(maybeDecodedEvent === null || maybeDecodedEvent === undefined)) {
                   return Caml_option.some((async function () {
                                   var match;
                                   try {
@@ -727,34 +667,14 @@ function make(param) {
                                           _1: {
                                             TAG: "FailedGettingFieldSelection",
                                             exn: exn,
-                                            blockNumber: blockNumber,
-                                            logIndex: logIndex,
+                                            blockNumber: log.blockNumber,
+                                            logIndex: log.index,
                                             message: "Failed getting selected fields. Please double-check your RPC provider returns correct data."
                                           },
                                           Error: new Error()
                                         };
                                   }
                                   var block = match[0];
-                                  var decodedEvent;
-                                  try {
-                                    decodedEvent = Viem.parseLogOrThrow(contractNameAbiMapping, eventConfig.contractName, log.topics, log.data);
-                                  }
-                                  catch (raw_exn$1){
-                                    var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
-                                    throw {
-                                          RE_EXN_ID: Source.GetItemsError,
-                                          _1: {
-                                            TAG: "FailedGettingItems",
-                                            exn: exn$1,
-                                            attemptedToBlock: toBlock$1,
-                                            retry: {
-                                              TAG: "ImpossibleForTheQuery",
-                                              message: "Failed to parse event with viem, please double-check your ABI. Block number: " + String(blockNumber) + ", log index: " + String(logIndex)
-                                            }
-                                          },
-                                          Error: new Error()
-                                        };
-                                  }
                                   return {
                                           kind: 0,
                                           eventConfig: eventConfig,
@@ -763,17 +683,18 @@ function make(param) {
                                           blockNumber: block.number,
                                           logIndex: log.index,
                                           event: {
-                                            params: decodedEvent.args,
+                                            params: eventConfig.convertHyperSyncEventArgs(maybeDecodedEvent),
                                             chainId: chain,
-                                            srcAddress: log.address,
+                                            srcAddress: routedAddress,
                                             logIndex: log.index,
                                             transaction: match[1],
                                             block: block
                                           }
                                         };
                                 })());
-                })));
-    }
+                }
+                
+              })));
     var optFirstBlockParent = await firstBlockParentPromise;
     var totalTimeElapsed = Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(startFetchingBatchTimeRef)));
     var reorgGuard_rangeLastBlock = {