envio 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/sources/RpcSource.res.mjs

@@ -4,9 +4,7 @@ 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";
 import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Source from "./Source.res.mjs";
@@ -14,9 +12,11 @@ import * as Address from "../Address.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as $$Promise from "../bindings/Promise.res.mjs";
 import * as Belt_Int from "rescript/lib/es6/belt_Int.js";
+import * as Internal from "../Internal.res.mjs";
 import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as FetchState from "../FetchState.res.mjs";
 import * as LazyLoader from "../LazyLoader.res.mjs";
+import * as Prometheus from "../Prometheus.res.mjs";
 import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
 import * as Caml_option from "rescript/lib/es6/caml_option.js";
 import * as EventRouter from "./EventRouter.res.mjs";
@@ -26,54 +26,56 @@ import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
 import * as Caml_splice_call from "rescript/lib/es6/caml_splice_call.js";
 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 RpcWebSocketHeightStream from "./RpcWebSocketHeightStream.res.mjs";
 
 var QueryTimout = /* @__PURE__ */Caml_exceptions.create("RpcSource.QueryTimout");
 
-function getKnownBlock(provider, blockNumber) {
-  return provider.getBlock(blockNumber).then(function (blockNullable) {
-              if (blockNullable == null) {
-                return Promise.reject(Js_exn.raiseError("RPC returned null for blockNumber " + String(blockNumber)));
-              } else {
-                return Promise.resolve(blockNullable);
-              }
-            });
+async function getKnownRawBlock(client, blockNumber) {
+  var json = await Rpc.getRawBlock(client, blockNumber);
+  if (json !== undefined) {
+    return json;
+  } else {
+    return Js_exn.raiseError("RPC returned null for blockNumber " + String(blockNumber));
+  }
+}
+
+function parseBlockInfo(json) {
+  return {
+          number: S$RescriptSchema.parseOrThrow(json["number"], Rpc.hexIntSchema),
+          timestamp: S$RescriptSchema.parseOrThrow(json["timestamp"], Rpc.hexIntSchema),
+          hash: S$RescriptSchema.parseOrThrow(json["hash"], S$RescriptSchema.string)
+        };
 }
 
-async function getKnownBlockWithBackoff(provider, sourceName, chain, blockNumber, backoffMsOnFailure, lowercaseAddresses) {
+async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumber, backoffMsOnFailure) {
+  var currentBackoff = backoffMsOnFailure;
   var result;
-  try {
-    result = await getKnownBlock(provider, blockNumber);
-  }
-  catch (raw_err){
-    var err = Caml_js_exceptions.internalToOCamlException(raw_err);
-    Logging.warn({
-          err: Utils.prettifyExn(err),
-          msg: "Issue while running fetching batch of events from the RPC. Will wait " + String(backoffMsOnFailure) + "ms and try again.",
-          source: sourceName,
-          chainId: chain,
-          type: "EXPONENTIAL_BACKOFF"
-        });
-    await Time.resolvePromiseAfterDelay(backoffMsOnFailure);
-    return await getKnownBlockWithBackoff(provider, sourceName, chain, blockNumber, (backoffMsOnFailure << 1), lowercaseAddresses);
-  }
-  if (lowercaseAddresses) {
-    return {
-            _difficulty: result._difficulty,
-            difficulty: result.difficulty,
-            extraData: result.extraData,
-            gasLimit: result.gasLimit,
-            gasUsed: result.gasUsed,
-            hash: result.hash,
-            miner: Address.Evm.fromAddressLowercaseOrThrow(result.miner),
-            nonce: result.nonce,
-            number: result.number,
-            parentHash: result.parentHash,
-            timestamp: result.timestamp,
-            transactions: result.transactions
-          };
-  } else {
-    return result;
-  }
+  while(Belt_Option.isNone(result)) {
+    Prometheus.SourceRequestCount.increment(sourceName, chain, "eth_getBlockByNumber");
+    var exit = 0;
+    var json;
+    try {
+      json = await getKnownRawBlock(client, blockNumber);
+      exit = 1;
+    }
+    catch (raw_err){
+      var err = Caml_js_exceptions.internalToOCamlException(raw_err);
+      Logging.warn({
+            err: Utils.prettifyExn(err),
+            msg: "Issue while running fetching batch of events from the RPC. Will wait " + String(currentBackoff) + "ms and try again.",
+            source: sourceName,
+            chainId: chain,
+            type: "EXPONENTIAL_BACKOFF"
+          });
+      await Time.resolvePromiseAfterDelay(currentBackoff);
+      currentBackoff = (currentBackoff << 1);
+    }
+    if (exit === 1) {
+      result = json;
+    }
+    
+  };
+  return Belt_Option.getExn(result);
 }
 
 var suggestedRangeRegExp = /retry with the range (\d+)-(\d+)/;
@@ -102,111 +104,117 @@ var publicNodeRegExp = /maximum block range: (\d+)/;
 
 var hyperliquidRegExp = /query exceeds max block range (\d+)/;
 
-function getSuggestedBlockIntervalFromExn(exn) {
-  if (exn.RE_EXN_ID !== Js_exn.$$Error) {
-    return ;
-  }
-  try {
-    var message = exn._1.error.message;
-    S$RescriptSchema.assertOrThrow(message, S$RescriptSchema.string);
-    var extractBlockRange = function (execResult, isMaxRange) {
-      if (execResult.length !== 2) {
-        return ;
-      }
-      var blockRangeLimit = execResult[1];
-      if (blockRangeLimit === null || blockRangeLimit === undefined) {
-        return ;
-      }
-      var blockRangeLimit$1 = Belt_Int.fromString(blockRangeLimit);
-      if (blockRangeLimit$1 !== undefined && blockRangeLimit$1 > 0) {
-        return [
-                blockRangeLimit$1,
-                isMaxRange
-              ];
-      }
-      
-    };
-    var execResult = suggestedRangeRegExp.exec(message);
-    if (execResult !== null) {
-      if (execResult.length !== 3) {
-        return ;
-      }
-      var fromBlock = execResult[1];
-      if (fromBlock === null || fromBlock === undefined) {
-        return ;
-      }
-      var toBlock = execResult[2];
-      if (toBlock === null || toBlock === undefined) {
-        return ;
-      }
-      var match = Belt_Int.fromString(fromBlock);
-      var match$1 = Belt_Int.fromString(toBlock);
-      if (match !== undefined && match$1 !== undefined && match$1 >= match) {
-        return [
-                (match$1 - match | 0) + 1 | 0,
-                false
-              ];
-      } else {
-        return ;
-      }
-    }
-    var execResult$1 = blockRangeLimitRegExp.exec(message);
-    if (execResult$1 !== null) {
-      return extractBlockRange(execResult$1, true);
-    }
-    var execResult$2 = alchemyRangeRegExp.exec(message);
-    if (execResult$2 !== null) {
-      return extractBlockRange(execResult$2, true);
-    }
-    var execResult$3 = cloudflareRangeRegExp.exec(message);
-    if (execResult$3 !== null) {
-      return extractBlockRange(execResult$3, true);
-    }
-    var execResult$4 = thirdwebRangeRegExp.exec(message);
-    if (execResult$4 !== null) {
-      return extractBlockRange(execResult$4, true);
-    }
-    var execResult$5 = blockpiRangeRegExp.exec(message);
-    if (execResult$5 !== null) {
-      return extractBlockRange(execResult$5, true);
+function parseMessageForBlockRange(message) {
+  var extractBlockRange = function (execResult, isMaxRange) {
+    if (execResult.length !== 2) {
+      return ;
     }
-    var execResult$6 = maxAllowedBlocksRegExp.exec(message);
-    if (execResult$6 !== null) {
-      return extractBlockRange(execResult$6, true);
+    var blockRangeLimit = execResult[1];
+    if (blockRangeLimit === null || blockRangeLimit === undefined) {
+      return ;
     }
-    var match$2 = baseRangeRegExp.exec(message);
-    if (match$2 !== null) {
+    var blockRangeLimit$1 = Belt_Int.fromString(blockRangeLimit);
+    if (blockRangeLimit$1 !== undefined && blockRangeLimit$1 > 0) {
       return [
-              2000,
-              true
+              blockRangeLimit$1,
+              isMaxRange
             ];
     }
-    var execResult$7 = blastPaidRegExp.exec(message);
-    if (execResult$7 !== null) {
-      return extractBlockRange(execResult$7, true);
-    }
-    var match$3 = chainstackRegExp.exec(message);
-    if (match$3 !== null) {
-      return [
-              10000,
-              true
-            ];
+    
+  };
+  var execResult = suggestedRangeRegExp.exec(message);
+  if (execResult !== null) {
+    if (execResult.length !== 3) {
+      return ;
     }
-    var execResult$8 = coinbaseRegExp.exec(message);
-    if (execResult$8 !== null) {
-      return extractBlockRange(execResult$8, true);
+    var fromBlock = execResult[1];
+    if (fromBlock === null || fromBlock === undefined) {
+      return ;
     }
-    var execResult$9 = publicNodeRegExp.exec(message);
-    if (execResult$9 !== null) {
-      return extractBlockRange(execResult$9, true);
+    var toBlock = execResult[2];
+    if (toBlock === null || toBlock === undefined) {
+      return ;
     }
-    var execResult$10 = hyperliquidRegExp.exec(message);
-    if (execResult$10 !== null) {
-      return extractBlockRange(execResult$10, true);
+    var match = Belt_Int.fromString(fromBlock);
+    var match$1 = Belt_Int.fromString(toBlock);
+    if (match !== undefined && match$1 !== undefined && match$1 >= match) {
+      return [
+              (match$1 - match | 0) + 1 | 0,
+              false
+            ];
     } else {
       return ;
     }
   }
+  var execResult$1 = blockRangeLimitRegExp.exec(message);
+  if (execResult$1 !== null) {
+    return extractBlockRange(execResult$1, true);
+  }
+  var execResult$2 = alchemyRangeRegExp.exec(message);
+  if (execResult$2 !== null) {
+    return extractBlockRange(execResult$2, true);
+  }
+  var execResult$3 = cloudflareRangeRegExp.exec(message);
+  if (execResult$3 !== null) {
+    return extractBlockRange(execResult$3, true);
+  }
+  var execResult$4 = thirdwebRangeRegExp.exec(message);
+  if (execResult$4 !== null) {
+    return extractBlockRange(execResult$4, true);
+  }
+  var execResult$5 = blockpiRangeRegExp.exec(message);
+  if (execResult$5 !== null) {
+    return extractBlockRange(execResult$5, true);
+  }
+  var execResult$6 = maxAllowedBlocksRegExp.exec(message);
+  if (execResult$6 !== null) {
+    return extractBlockRange(execResult$6, true);
+  }
+  var match$2 = baseRangeRegExp.exec(message);
+  if (match$2 !== null) {
+    return [
+            2000,
+            true
+          ];
+  }
+  var execResult$7 = blastPaidRegExp.exec(message);
+  if (execResult$7 !== null) {
+    return extractBlockRange(execResult$7, true);
+  }
+  var match$3 = chainstackRegExp.exec(message);
+  if (match$3 !== null) {
+    return [
+            10000,
+            true
+          ];
+  }
+  var execResult$8 = coinbaseRegExp.exec(message);
+  if (execResult$8 !== null) {
+    return extractBlockRange(execResult$8, true);
+  }
+  var execResult$9 = publicNodeRegExp.exec(message);
+  if (execResult$9 !== null) {
+    return extractBlockRange(execResult$9, true);
+  }
+  var execResult$10 = hyperliquidRegExp.exec(message);
+  if (execResult$10 !== null) {
+    return extractBlockRange(execResult$10, true);
+  }
+  
+}
+
+function getSuggestedBlockIntervalFromExn(exn) {
+  if (exn.RE_EXN_ID === Rpc.JsonRpcError) {
+    return parseMessageForBlockRange(exn._1.message);
+  }
+  if (exn.RE_EXN_ID !== Js_exn.$$Error) {
+    return ;
+  }
+  try {
+    var message = exn._1.error.message;
+    S$RescriptSchema.assertOrThrow(message, S$RescriptSchema.string);
+    return parseMessageForBlockRange(message);
+  }
   catch (exn$1){
     return ;
   }
@@ -214,7 +222,7 @@ function getSuggestedBlockIntervalFromExn(exn) {
 
 var maxSuggestedBlockIntervalKey = "max";
 
-function getNextPage(fromBlock, toBlock, addresses, topicQuery, loadBlock, sc, provider, mutSuggestedBlockIntervals, partitionId) {
+function getNextPage(fromBlock, toBlock, addresses, topicQuery, loadBlock, sc, client, mutSuggestedBlockIntervals, partitionId, sourceName, chainId) {
   var queryTimoutPromise = Time.resolvePromiseAfterDelay(sc.queryTimeoutMillis).then(function () {
         return Promise.reject({
                     RE_EXN_ID: QueryTimout,
@@ -222,15 +230,16 @@ function getNextPage(fromBlock, toBlock, addresses, topicQuery, loadBlock, sc, p
                   });
       });
   var latestFetchedBlockPromise = loadBlock(toBlock);
-  var logsPromise = provider.getLogs(Ethers.CombinedFilter.toFilter({
-              address: addresses,
-              topics: topicQuery,
-              fromBlock: fromBlock,
-              toBlock: toBlock
-            })).then(async function (logs) {
+  Prometheus.SourceRequestCount.increment(sourceName, chainId, "eth_getLogs");
+  var logsPromise = Rpc.getLogs(client, {
+          fromBlock: fromBlock,
+          toBlock: toBlock,
+          address: addresses,
+          topics: topicQuery
+        }).then(async function (logs) {
         return {
                 logs: logs,
-                latestFetchedBlock: await latestFetchedBlockPromise
+                latestFetchedBlockInfo: await latestFetchedBlockPromise
               };
       });
   return $$Promise.$$catch(Promise.race([
@@ -323,7 +332,7 @@ function getSelectionConfig(selection, chain) {
     }
     var dynamicEventFilter = dynamicEventFilters[0];
     if (selection.eventConfigs.length === 1) {
-      var eventConfig = selection.eventConfigs[0];
+      var eventConfig = Utils.$$Array.firstUnsafe(selection.eventConfigs);
       getLogSelectionOrThrow = (function (addressesByContractName) {
           var addresses = FetchState.addressesByContractNameGetAll(addressesByContractName);
           var match = dynamicEventFilter(addresses);
@@ -380,151 +389,591 @@ function getSelectionConfig(selection, chain) {
 }
 
 function memoGetSelectionConfig(chain) {
-  var cache = new WeakMap();
-  return function (selection) {
-    var c = cache.get(selection);
-    if (c !== undefined) {
-      return c;
+  return Utils.$$WeakMap.memoize(function (selection) {
+              return getSelectionConfig(selection, chain);
+            });
+}
+
+var lowercaseAddressSchema = S$RescriptSchema.transform(S$RescriptSchema.string, (function (param) {
+        return {
+                p: (function (str) {
+                    return str.toLowerCase();
+                  })
+              };
+      }));
+
+var checksumAddressSchema = S$RescriptSchema.transform(S$RescriptSchema.string, (function (param) {
+        return {
+                p: (function (str) {
+                    return Address.Evm.fromStringOrThrow(str);
+                  })
+              };
+      }));
+
+function makeBlockFieldRegistry(addressSchema) {
+  return Utils.Record.fromArray(Belt_Array.map([
+                  {
+                    location: "number",
+                    jsonKey: "number",
+                    schema: Rpc.hexIntSchema
+                  },
+                  {
+                    location: "timestamp",
+                    jsonKey: "timestamp",
+                    schema: Rpc.hexIntSchema
+                  },
+                  {
+                    location: "hash",
+                    jsonKey: "hash",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "parentHash",
+                    jsonKey: "parentHash",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "nonce",
+                    jsonKey: "nonce",
+                    schema: Rpc.hexBigintSchema
+                  },
+                  {
+                    location: "sha3Uncles",
+                    jsonKey: "sha3Uncles",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "logsBloom",
+                    jsonKey: "logsBloom",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "transactionsRoot",
+                    jsonKey: "transactionsRoot",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "stateRoot",
+                    jsonKey: "stateRoot",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "receiptsRoot",
+                    jsonKey: "receiptsRoot",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "miner",
+                    jsonKey: "miner",
+                    schema: addressSchema
+                  },
+                  {
+                    location: "difficulty",
+                    jsonKey: "difficulty",
+                    schema: Rpc.hexBigintSchema
+                  },
+                  {
+                    location: "totalDifficulty",
+                    jsonKey: "totalDifficulty",
+                    schema: Rpc.hexBigintSchema
+                  },
+                  {
+                    location: "extraData",
+                    jsonKey: "extraData",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "size",
+                    jsonKey: "size",
+                    schema: Rpc.hexBigintSchema
+                  },
+                  {
+                    location: "gasLimit",
+                    jsonKey: "gasLimit",
+                    schema: Rpc.hexBigintSchema
+                  },
+                  {
+                    location: "gasUsed",
+                    jsonKey: "gasUsed",
+                    schema: Rpc.hexBigintSchema
+                  },
+                  {
+                    location: "uncles",
+                    jsonKey: "uncles",
+                    schema: S$RescriptSchema.array(S$RescriptSchema.string)
+                  },
+                  {
+                    location: "baseFeePerGas",
+                    jsonKey: "baseFeePerGas",
+                    schema: Rpc.hexBigintSchema
+                  },
+                  {
+                    location: "blobGasUsed",
+                    jsonKey: "blobGasUsed",
+                    schema: Rpc.hexBigintSchema
+                  },
+                  {
+                    location: "excessBlobGas",
+                    jsonKey: "excessBlobGas",
+                    schema: Rpc.hexBigintSchema
+                  },
+                  {
+                    location: "parentBeaconBlockRoot",
+                    jsonKey: "parentBeaconBlockRoot",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "withdrawalsRoot",
+                    jsonKey: "withdrawalsRoot",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "l1BlockNumber",
+                    jsonKey: "l1BlockNumber",
+                    schema: Rpc.hexIntSchema
+                  },
+                  {
+                    location: "sendCount",
+                    jsonKey: "sendCount",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "sendRoot",
+                    jsonKey: "sendRoot",
+                    schema: S$RescriptSchema.string
+                  },
+                  {
+                    location: "mixHash",
+                    jsonKey: "mixHash",
+                    schema: S$RescriptSchema.string
+                  }
+                ], (function (def) {
+                    return [
+                            def.location,
+                            Internal.evmNullableBlockFields.has(def.location) ? ({
+                                  location: def.location,
+                                  jsonKey: def.jsonKey,
+                                  schema: S$RescriptSchema.nullable(def.schema)
+                                }) : def
+                          ];
+                  })));
+}
+
+var blockFieldRegistryLowercase = makeBlockFieldRegistry(lowercaseAddressSchema);
+
+var blockFieldRegistryChecksum = makeBlockFieldRegistry(checksumAddressSchema);
+
+function parseBlockFieldsFromJson(mutBlockAcc, fields, json) {
+  Belt_Array.forEach(fields, (function (def) {
+          var raw = json[def.jsonKey];
+          try {
+            var parsed = S$RescriptSchema.parseOrThrow(raw, def.schema);
+            mutBlockAcc[def.location] = parsed;
+            return ;
+          }
+          catch (raw_error){
+            var error = Caml_js_exceptions.internalToOCamlException(raw_error);
+            if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
+              return Js_exn.raiseError("Invalid block field \"" + def.location + "\" found in the RPC response. Error: " + S$RescriptSchema.$$Error.reason(error._1));
+            }
+            throw error;
+          }
+        }));
+}
+
+function makeThrowingGetEventBlock(getBlockJson, lowercaseAddresses) {
+  var blockFieldRegistry = lowercaseAddresses ? blockFieldRegistryLowercase : blockFieldRegistryChecksum;
+  var fnsCache = new WeakMap();
+  return function (log, selectedBlockFields) {
+    var fn = fnsCache.get(selectedBlockFields);
+    var tmp;
+    if (fn !== undefined) {
+      tmp = fn;
+    } else {
+      var fields = [];
+      selectedBlockFields.forEach(function (fieldName) {
+            fields.push(blockFieldRegistry[fieldName]);
+          });
+      var fn$1 = selectedBlockFields.size === 0 ? (function (param) {
+            return Promise.resolve({});
+          }) : (function (log) {
+            return getBlockJson(log.blockNumber).then(function (json) {
+                        var mutBlockAcc = {};
+                        parseBlockFieldsFromJson(mutBlockAcc, fields, json);
+                        return mutBlockAcc;
+                      });
+          });
+      fnsCache.set(selectedBlockFields, fn$1);
+      tmp = fn$1;
     }
-    var c$1 = getSelectionConfig(selection, chain);
-    cache.set(selection, c$1);
-    return c$1;
+    return tmp(log);
   };
 }
 
-function makeThrowingGetEventBlock(getBlock) {
-  return async function (log) {
-    return await getBlock(log.blockNumber);
-  };
+function makeFieldRegistry(addressSchema) {
+  return Utils.Record.fromArray(Belt_Array.map([
+                  {
+                    location: "gas",
+                    jsonKey: "gas",
+                    schema: Rpc.hexBigintSchema,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "gasPrice",
+                    jsonKey: "gasPrice",
+                    schema: Rpc.hexBigintSchema,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "input",
+                    jsonKey: "input",
+                    schema: S$RescriptSchema.string,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "nonce",
+                    jsonKey: "nonce",
+                    schema: Rpc.hexBigintSchema,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "value",
+                    jsonKey: "value",
+                    schema: Rpc.hexBigintSchema,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "v",
+                    jsonKey: "v",
+                    schema: S$RescriptSchema.string,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "r",
+                    jsonKey: "r",
+                    schema: S$RescriptSchema.string,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "s",
+                    jsonKey: "s",
+                    schema: S$RescriptSchema.string,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "yParity",
+                    jsonKey: "yParity",
+                    schema: S$RescriptSchema.string,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "maxPriorityFeePerGas",
+                    jsonKey: "maxPriorityFeePerGas",
+                    schema: Rpc.hexBigintSchema,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "maxFeePerGas",
+                    jsonKey: "maxFeePerGas",
+                    schema: Rpc.hexBigintSchema,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "maxFeePerBlobGas",
+                    jsonKey: "maxFeePerBlobGas",
+                    schema: Rpc.hexBigintSchema,
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "blobVersionedHashes",
+                    jsonKey: "blobVersionedHashes",
+                    schema: S$RescriptSchema.array(S$RescriptSchema.string),
+                    source: "TransactionOnly"
+                  },
+                  {
+                    location: "gasUsed",
+                    jsonKey: "gasUsed",
+                    schema: Rpc.hexBigintSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "cumulativeGasUsed",
+                    jsonKey: "cumulativeGasUsed",
+                    schema: Rpc.hexBigintSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "effectiveGasPrice",
+                    jsonKey: "effectiveGasPrice",
+                    schema: Rpc.hexBigintSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "contractAddress",
+                    jsonKey: "contractAddress",
+                    schema: addressSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "logsBloom",
+                    jsonKey: "logsBloom",
+                    schema: S$RescriptSchema.string,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "root",
+                    jsonKey: "root",
+                    schema: S$RescriptSchema.string,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "status",
+                    jsonKey: "status",
+                    schema: Rpc.hexIntSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "l1Fee",
+                    jsonKey: "l1Fee",
+                    schema: Rpc.hexBigintSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "l1GasPrice",
+                    jsonKey: "l1GasPrice",
+                    schema: Rpc.hexBigintSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "l1GasUsed",
+                    jsonKey: "l1GasUsed",
+                    schema: Rpc.hexBigintSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "l1FeeScalar",
+                    jsonKey: "l1FeeScalar",
+                    schema: Rpc.decimalFloatSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "gasUsedForL1",
+                    jsonKey: "gasUsedForL1",
+                    schema: Rpc.hexBigintSchema,
+                    source: "ReceiptOnly"
+                  },
+                  {
+                    location: "from",
+                    jsonKey: "from",
+                    schema: addressSchema,
+                    source: "Both"
+                  },
+                  {
+                    location: "to",
+                    jsonKey: "to",
+                    schema: addressSchema,
+                    source: "Both"
+                  },
+                  {
+                    location: "type",
+                    jsonKey: "type",
+                    schema: Rpc.hexIntSchema,
+                    source: "Both"
+                  }
+                ], (function (def) {
+                    return [
+                            def.location,
+                            Internal.evmNullableTransactionFields.has(def.location) ? ({
+                                  location: def.location,
+                                  jsonKey: def.jsonKey,
+                                  schema: S$RescriptSchema.nullable(def.schema),
+                                  source: def.source
+                                }) : def
+                          ];
+                  })));
 }
 
-function makeThrowingGetEventTransaction(getTransactionFields) {
+var fieldRegistryLowercase = makeFieldRegistry(lowercaseAddressSchema);
+
+var fieldRegistryChecksum = makeFieldRegistry(checksumAddressSchema);
+
+function parseFieldsFromJson(mutTransactionAcc, fields, json) {
+  Belt_Array.forEach(fields, (function (def) {
+          var raw = json[def.jsonKey];
+          try {
+            var parsed = S$RescriptSchema.parseOrThrow(raw, def.schema);
+            mutTransactionAcc[def.location] = parsed;
+            return ;
+          }
+          catch (raw_error){
+            var error = Caml_js_exceptions.internalToOCamlException(raw_error);
+            if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
+              return Js_exn.raiseError("Invalid transaction field \"" + def.location + "\" found in the RPC response. Error: " + S$RescriptSchema.$$Error.reason(error._1));
+            }
+            throw error;
+          }
+        }));
+}
+
+function makeThrowingGetEventTransaction(getTransactionJson, getReceiptJson, lowercaseAddresses) {
+  var fieldRegistry = lowercaseAddresses ? fieldRegistryLowercase : fieldRegistryChecksum;
   var fnsCache = new WeakMap();
-  return function (log, transactionSchema) {
-    var fn = fnsCache.get(transactionSchema);
+  return function (log, selectedTransactionFields) {
+    var fn = fnsCache.get(selectedTransactionFields);
     var tmp;
     if (fn !== undefined) {
       tmp = fn;
     } else {
-      var transactionSchema$1 = S$RescriptSchema.removeTypeValidation(transactionSchema);
-      var match = transactionSchema$1.t;
-      var transactionFieldItems;
-      transactionFieldItems = typeof match !== "object" || match.TAG !== "object" ? Js_exn.raiseError("Unexpected internal error: transactionSchema is not an object") : match.items;
-      var parseOrThrowReadableError = function (data) {
-        try {
-          return S$RescriptSchema.parseOrThrow(data, transactionSchema$1);
+      var hasTransactionIndex = {
+        contents: false
+      };
+      var hasHash = {
+        contents: false
+      };
+      var txFields = [];
+      var receiptFields = [];
+      var bothFields = [];
+      selectedTransactionFields.forEach(function (fieldName) {
+            switch (fieldName) {
+              case "transactionIndex" :
+                  hasTransactionIndex.contents = true;
+                  return ;
+              case "hash" :
+                  hasHash.contents = true;
+                  return ;
+              default:
+                var def = fieldRegistry[fieldName];
+                if (def === undefined) {
+                  return ;
+                }
+                var match = def.source;
+                switch (match) {
+                  case "TransactionOnly" :
+                      txFields.push(def);
+                      return ;
+                  case "ReceiptOnly" :
+                      receiptFields.push(def);
+                      return ;
+                  case "Both" :
+                      bothFields.push(def);
+                      return ;
+                  
+                }
+            }
+          });
+      var match = txFields.length !== 0;
+      var match$1 = receiptFields.length !== 0;
+      var strategy = match ? (
+          match$1 ? "TransactionAndReceipt" : "TransactionOnly"
+        ) : (
+          match$1 ? "ReceiptOnly" : (
+              bothFields.length !== 0 ? "TransactionOnly" : "NoRpc"
+            )
+        );
+      var targetForBoth = strategy === "ReceiptOnly" ? receiptFields : txFields;
+      Belt_Array.forEach(bothFields, (function (f) {
+              targetForBoth.push(f);
+            }));
+      var setLogFields = function (mutTransactionAcc, log) {
+        if (hasTransactionIndex.contents) {
+          mutTransactionAcc["transactionIndex"] = log.transactionIndex;
         }
-        catch (raw_error){
-          var error = Caml_js_exceptions.internalToOCamlException(raw_error);
-          if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
-            var error$1 = error._1;
-            return Js_exn.raiseError("Invalid transaction field \"" + S$RescriptSchema.Path.toArray(error$1.path).join(".") + "\" found in the RPC response. Error: " + S$RescriptSchema.$$Error.reason(error$1));
-          }
-          throw error;
+        if (hasHash.contents) {
+          mutTransactionAcc["hash"] = log.transactionHash;
+          return ;
         }
+        
       };
-      var fn$1;
-      var exit = 0;
-      var len = transactionFieldItems.length;
-      if (len >= 3) {
-        exit = 1;
-      } else {
-        switch (len) {
-          case 0 :
-              fn$1 = (function (param) {
-                  return Promise.resolve({});
-                });
-              break;
-          case 1 :
-              var match$1 = transactionFieldItems[0];
-              switch (match$1.location) {
-                case "hash" :
-                    exit = 2;
-                    break;
-                case "transactionIndex" :
-                    fn$1 = (function (log) {
-                        return Promise.resolve(parseOrThrowReadableError(log));
+      var fn$1 = selectedTransactionFields.size === 0 ? (function (param) {
+            return Promise.resolve({});
+          }) : (
+          strategy === "NoRpc" ? (function (log) {
+                var mutTransactionAcc = {};
+                setLogFields(mutTransactionAcc, log);
+                return Promise.resolve(mutTransactionAcc);
+              }) : (function (log) {
+                var txJsonPromise;
+                var exit = 0;
+                switch (strategy) {
+                  case "NoRpc" :
+                  case "ReceiptOnly" :
+                      txJsonPromise = Promise.resolve(undefined);
+                      break;
+                  case "TransactionOnly" :
+                  case "TransactionAndReceipt" :
+                      exit = 1;
+                      break;
+                  
+                }
+                if (exit === 1) {
+                  txJsonPromise = getTransactionJson(log.transactionHash).then(function (v) {
+                        return v;
                       });
-                    break;
-                default:
-                  exit = 1;
-              }
-              break;
-          case 2 :
-              var match$2 = transactionFieldItems[0];
-              switch (match$2.location) {
-                case "hash" :
-                    var match$3 = transactionFieldItems[1];
-                    exit = match$3.location === "transactionIndex" ? 2 : 1;
-                    break;
-                case "transactionIndex" :
-                    var match$4 = transactionFieldItems[1];
-                    exit = match$4.location === "hash" ? 2 : 1;
-                    break;
-                default:
-                  exit = 1;
-              }
-              break;
-          
-        }
-      }
-      switch (exit) {
-        case 1 :
-            fn$1 = (function (log) {
-                return getTransactionFields(log).then(parseOrThrowReadableError);
-              });
-            break;
-        case 2 :
-            fn$1 = (function (log) {
-                return Promise.resolve(parseOrThrowReadableError({
-                                hash: log.transactionHash,
-                                transactionIndex: log.transactionIndex
-                              }));
-              });
-            break;
-        
-      }
-      fnsCache.set(transactionSchema$1, fn$1);
+                }
+                var receiptJsonPromise;
+                var exit$1 = 0;
+                switch (strategy) {
+                  case "NoRpc" :
+                  case "TransactionOnly" :
+                      receiptJsonPromise = Promise.resolve(undefined);
+                      break;
+                  case "ReceiptOnly" :
+                  case "TransactionAndReceipt" :
+                      exit$1 = 1;
+                      break;
+                  
+                }
+                if (exit$1 === 1) {
+                  receiptJsonPromise = getReceiptJson(log.transactionHash).then(function (v) {
+                        return v;
+                      });
+                }
+                return Promise.all([
+                              txJsonPromise,
+                              receiptJsonPromise
+                            ]).then(function (param) {
+                            var receiptJson = param[1];
+                            var txJson = param[0];
+                            var mutTransactionAcc = {};
+                            setLogFields(mutTransactionAcc, log);
+                            if (txJson !== undefined) {
+                              parseFieldsFromJson(mutTransactionAcc, txFields, txJson);
+                            }
+                            if (receiptJson !== undefined) {
+                              parseFieldsFromJson(mutTransactionAcc, receiptFields, receiptJson);
+                            }
+                            return mutTransactionAcc;
+                          });
+              })
+        );
+      fnsCache.set(selectedTransactionFields, fn$1);
       tmp = fn$1;
     }
     return tmp(log);
   };
 }
 
-function sanitizeUrl(url) {
-  var regex = /https?:\/\/([^\/?]+).*/;
-  var result = regex.exec(url);
-  if (result === null) {
-    return ;
-  }
-  var host = Belt_Array.get(result, 1);
-  if (host !== undefined) {
-    return Caml_option.nullable_to_opt(Caml_option.valFromOption(host));
-  }
-  
-}
-
 function make(param) {
   var lowercaseAddresses = param.lowercaseAddresses;
-  var shouldUseHypersyncClientDecoder = param.shouldUseHypersyncClientDecoder;
   var allEventSignatures = param.allEventSignatures;
   var eventRouter = param.eventRouter;
   var chain = param.chain;
   var url = param.url;
   var syncConfig = param.syncConfig;
-  var host = sanitizeUrl(url);
-  var urlHost = host !== undefined ? host : Js_exn.raiseError("EE109: The RPC url \"" + url + "\" is incorrect format. The RPC url needs to start with either http:// or https://");
+  var host = Utils.Url.getHostFromUrl(url);
+  var urlHost = host !== undefined ? host : Js_exn.raiseError("The RPC url for chain " + String(chain) + " is in incorrect format. The RPC url needs to start with either http:// or https://");
   var name = "RPC (" + urlHost + ")";
-  var provider = Ethers.JsonRpcProvider.make(url, chain);
   var getSelectionConfig = memoGetSelectionConfig(chain);
   var mutSuggestedBlockIntervals = {};
+  var client = Rpc.makeClient(url);
   var makeTransactionLoader = function () {
     return LazyLoader.make((function (transactionHash) {
-                  return provider.getTransaction(transactionHash);
+                  Prometheus.SourceRequestCount.increment(name, chain, "eth_getTransactionByHash");
+                  return Rest.$$fetch(Rpc.GetTransactionByHash.rawRoute, transactionHash, client);
                 }), (function (am, exn) {
                   Logging.error({
                         err: Utils.prettifyExn(exn),
-                        msg: "EE1100: Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in " + String(am._retryDelayMillis / 1000 | 0) + " seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the \"suggestedFix\" in the metadata of this command",
+                        msg: "Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in " + String(am._retryDelayMillis / 1000 | 0) + " seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the \"suggestedFix\" in the metadata of this command",
                         source: name,
                         chainId: chain,
                         metadata: {
@@ -536,11 +985,11 @@ function make(param) {
   };
   var makeBlockLoader = function () {
     return LazyLoader.make((function (blockNumber) {
-                  return getKnownBlockWithBackoff(provider, name, chain, blockNumber, 1000, lowercaseAddresses);
+                  return getKnownRawBlockWithBackoff(client, name, chain, blockNumber, 1000);
                 }), (function (am, exn) {
                   Logging.error({
                         err: Utils.prettifyExn(exn),
-                        msg: "EE1100: Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in " + String(am._retryDelayMillis / 1000 | 0) + " seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the \"suggestedFix\" in the metadata of this command",
+                        msg: "Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in " + String(am._retryDelayMillis / 1000 | 0) + " seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the \"suggestedFix\" in the metadata of this command",
                         source: name,
                         chainId: chain,
                         metadata: {
@@ -550,34 +999,60 @@ function make(param) {
                       });
                 }), undefined, undefined, undefined, undefined);
   };
+  var makeReceiptLoader = function () {
+    return LazyLoader.make((function (transactionHash) {
+                  Prometheus.SourceRequestCount.increment(name, chain, "eth_getTransactionReceipt");
+                  return Rest.$$fetch(Rpc.GetTransactionReceipt.rawRoute, transactionHash, client);
+                }), (function (am, exn) {
+                  Logging.error({
+                        err: Utils.prettifyExn(exn),
+                        msg: "Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in " + String(am._retryDelayMillis / 1000 | 0) + " seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the \"suggestedFix\" in the metadata of this command",
+                        source: name,
+                        chainId: chain,
+                        metadata: {
+                          asyncTaskName: "receiptLoader: fetching transaction receipt - `getTransactionReceipt` rpc call",
+                          suggestedFix: "This likely means the RPC url you are using is not responding correctly. Please try another RPC endipoint."
+                        }
+                      });
+                }), undefined, undefined, undefined, undefined);
+  };
   var blockLoader = {
     contents: makeBlockLoader()
   };
   var transactionLoader = {
     contents: makeTransactionLoader()
   };
-  var getEventBlockOrThrow = makeThrowingGetEventBlock(function (blockNumber) {
-        return LazyLoader.get(blockLoader.contents, blockNumber);
-      });
-  var getEventTransactionOrThrow = makeThrowingGetEventTransaction(Ethers.JsonRpcProvider.makeGetTransactionFields((function (__x) {
-              return LazyLoader.get(transactionLoader.contents, __x);
-            }), 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;
+  var receiptLoader = {
+    contents: makeReceiptLoader()
+  };
+  var getEventBlockOrThrow = makeThrowingGetEventBlock((function (blockNumber) {
+          return LazyLoader.get(blockLoader.contents, blockNumber);
+        }), lowercaseAddresses);
+  var getEventTransactionOrThrow = makeThrowingGetEventTransaction((async function (transactionHash) {
+          var json = await LazyLoader.get(transactionLoader.contents, transactionHash);
+          if (json !== undefined) {
+            return json;
+          } else {
+            return Js_exn.raiseError("Transaction not found for hash: " + transactionHash);
+          }
+        }), (async function (transactionHash) {
+          var json = await LazyLoader.get(receiptLoader.contents, transactionHash);
+          if (json !== undefined) {
+            return json;
+          } else {
+            return Js_exn.raiseError("Transaction receipt not found for hash: " + transactionHash);
+          }
+        }), lowercaseAddresses);
+  var convertLogToHyperSyncEvent = function (log) {
+    var hyperSyncLog_removed = log.removed;
+    var hyperSyncLog_logIndex = log.logIndex;
     var hyperSyncLog_transactionIndex = log.transactionIndex;
     var hyperSyncLog_transactionHash = log.transactionHash;
     var hyperSyncLog_blockHash = log.blockHash;
     var hyperSyncLog_blockNumber = log.blockNumber;
     var hyperSyncLog_address = Caml_option.some(log.address);
     var hyperSyncLog_data = log.data;
-    var hyperSyncLog_topics = Belt_Array.map(log.topics, (function (topic) {
-            return topic;
-          }));
+    var hyperSyncLog_topics = log.topics;
     var hyperSyncLog = {
       removed: hyperSyncLog_removed,
       logIndex: hyperSyncLog_logIndex,
@@ -604,114 +1079,60 @@ function make(param) {
       return HyperSyncClient.Decoder.fromSignatures(allEventSignatures);
     }
   };
-  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, currentBlockHeight, partitionId, selection, param, param$1) {
+  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, knownHeight, partitionId, selection, param, param$1) {
     var startFetchingBatchTimeRef = Hrtime.makeTimer();
     var maxSuggestedBlockInterval = mutSuggestedBlockIntervals[maxSuggestedBlockIntervalKey];
     var suggestedBlockInterval = maxSuggestedBlockInterval !== undefined ? maxSuggestedBlockInterval : Belt_Option.getWithDefault(mutSuggestedBlockIntervals[partitionId], syncConfig.initialBlockInterval);
-    var toBlock$1 = toBlock !== undefined && toBlock < currentBlockHeight ? toBlock : currentBlockHeight;
+    var toBlock$1 = toBlock !== undefined && toBlock < knownHeight ? toBlock : knownHeight;
     var suggestedToBlock = Caml.int_max(Caml.int_min((fromBlock + suggestedBlockInterval | 0) - 1 | 0, toBlock$1), fromBlock);
-    var firstBlockParentPromise = fromBlock > 0 ? LazyLoader.get(blockLoader.contents, fromBlock - 1 | 0).then(function (res) {
-            return res;
+    var firstBlockParentPromise = fromBlock > 0 ? LazyLoader.get(blockLoader.contents, fromBlock - 1 | 0).then(function (json) {
+            return parseBlockInfo(json);
           }) : Promise.resolve(undefined);
     var match = getSelectionConfig(selection);
     var match$1 = match.getLogSelectionOrThrow(addressesByContractName);
     var match$2 = await getNextPage(fromBlock, suggestedToBlock, match$1.addresses, match$1.topicQuery, (function (blockNumber) {
-            return LazyLoader.get(blockLoader.contents, blockNumber);
-          }), syncConfig, provider, mutSuggestedBlockIntervals, partitionId);
-    var latestFetchedBlock = match$2.latestFetchedBlock;
+            return LazyLoader.get(blockLoader.contents, blockNumber).then(parseBlockInfo);
+          }), syncConfig, client, mutSuggestedBlockIntervals, partitionId, name, chain);
+    var latestFetchedBlockInfo = match$2.latestFetchedBlockInfo;
     var logs = match$2.logs;
     var executedBlockInterval = (suggestedToBlock - fromBlock | 0) + 1 | 0;
     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, convertLogToHyperSyncEvent);
+    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) : Address.Evm.fromAddressOrThrow(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)
+                                          getEventBlockOrThrow(log, eventConfig.selectedBlockFields),
+                                          getEventTransactionOrThrow(log, eventConfig.selectedTransactionFields)
                                         ]);
                                   }
                                   catch (raw_exn){
@@ -721,58 +1142,41 @@ function make(param) {
                                           _1: {
                                             TAG: "FailedGettingFieldSelection",
                                             exn: exn,
-                                            blockNumber: blockNumber,
-                                            logIndex: logIndex,
+                                            blockNumber: log.blockNumber,
+                                            logIndex: log.logIndex,
                                             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,
                                           timestamp: block.timestamp,
                                           chain: chain,
                                           blockNumber: block.number,
-                                          logIndex: log.index,
+                                          logIndex: log.logIndex,
                                           event: {
-                                            params: decodedEvent.args,
+                                            contractName: eventConfig.contractName,
+                                            eventName: eventConfig.name,
+                                            params: eventConfig.convertHyperSyncEventArgs(maybeDecodedEvent),
                                             chainId: chain,
-                                            srcAddress: log.address,
-                                            logIndex: log.index,
+                                            srcAddress: routedAddress,
+                                            logIndex: log.logIndex,
                                             transaction: match[1],
                                             block: block
                                           }
                                         };
                                 })());
-                })));
-    }
+                }
+                
+              })));
     var optFirstBlockParent = await firstBlockParentPromise;
-    var totalTimeElapsed = Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(startFetchingBatchTimeRef)));
+    var totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));
     var reorgGuard_rangeLastBlock = {
-      blockHash: latestFetchedBlock.hash,
-      blockNumber: latestFetchedBlock.number
+      blockHash: latestFetchedBlockInfo.hash,
+      blockNumber: latestFetchedBlockInfo.number
     };
     var reorgGuard_prevRangeLastBlock = Belt_Option.map(optFirstBlockParent, (function (b) {
             return {
@@ -785,26 +1189,28 @@ function make(param) {
       prevRangeLastBlock: reorgGuard_prevRangeLastBlock
     };
     return {
-            currentBlockHeight: currentBlockHeight,
+            knownHeight: knownHeight,
             reorgGuard: reorgGuard,
             parsedQueueItems: parsedQueueItems,
             fromBlockQueried: fromBlock,
-            latestFetchedBlockNumber: latestFetchedBlock.number,
-            latestFetchedBlockTimestamp: latestFetchedBlock.timestamp,
+            latestFetchedBlockNumber: latestFetchedBlockInfo.number,
+            latestFetchedBlockTimestamp: latestFetchedBlockInfo.timestamp,
             stats: {
-              "total time elapsed (ms)": totalTimeElapsed
+              "total time elapsed (s)": totalTimeElapsed
             }
           };
   };
   var getBlockHashes = function (blockNumbers, _currentlyUnusedLogger) {
     blockLoader.contents = makeBlockLoader();
     transactionLoader.contents = makeTransactionLoader();
+    receiptLoader.contents = makeReceiptLoader();
     return $$Promise.$$catch(Promise.all(Belt_Array.map(blockNumbers, (function (blockNum) {
                             return LazyLoader.get(blockLoader.contents, blockNum);
-                          }))).then(function (blocks) {
+                          }))).then(function (rawBlocks) {
                     return {
                             TAG: "Ok",
-                            _0: Belt_Array.map(blocks, (function (b) {
+                            _0: Belt_Array.map(rawBlocks, (function (json) {
+                                    var b = parseBlockInfo(json);
                                     return {
                                             blockHash: b.hash,
                                             blockNumber: b.number,
@@ -819,33 +1225,62 @@ function make(param) {
                             });
                 }));
   };
-  var client = Rest.client(url, undefined);
+  var createHeightSubscription = Belt_Option.map(param.ws, (function (wsUrl) {
+          return function (onHeight) {
+            return RpcWebSocketHeightStream.subscribe(wsUrl, chain, onHeight);
+          };
+        }));
   return {
           name: name,
           sourceFor: param.sourceFor,
           chain: chain,
           poweredByHyperSync: false,
-          pollingInterval: 1000,
+          pollingInterval: syncConfig.pollingInterval,
           getBlockHashes: getBlockHashes,
-          getHeightOrThrow: (function () {
-              return Rest.$$fetch(Rpc.GetBlockHeight.route, undefined, client);
+          getHeightOrThrow: (async function () {
+              var timerRef = Hrtime.makeTimer();
+              var height;
+              try {
+                height = await Rest.$$fetch(Rpc.GetBlockHeight.route, undefined, client);
+              }
+              catch (exn){
+                var seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
+                Prometheus.SourceRequestCount.increment(name, chain, "eth_blockNumber");
+                Prometheus.SourceRequestCount.addSeconds(name, chain, "eth_blockNumber", seconds);
+                throw exn;
+              }
+              var seconds$1 = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
+              Prometheus.SourceRequestCount.increment(name, chain, "eth_blockNumber");
+              Prometheus.SourceRequestCount.addSeconds(name, chain, "eth_blockNumber", seconds$1);
+              return height;
             }),
-          getItemsOrThrow: getItemsOrThrow
+          getItemsOrThrow: getItemsOrThrow,
+          createHeightSubscription: createHeightSubscription
         };
 }
 
 export {
   QueryTimout ,
-  getKnownBlock ,
-  getKnownBlockWithBackoff ,
+  getKnownRawBlock ,
+  parseBlockInfo ,
+  getKnownRawBlockWithBackoff ,
   getSuggestedBlockIntervalFromExn ,
   maxSuggestedBlockIntervalKey ,
   getNextPage ,
   getSelectionConfig ,
   memoGetSelectionConfig ,
+  lowercaseAddressSchema ,
+  checksumAddressSchema ,
+  makeBlockFieldRegistry ,
+  blockFieldRegistryLowercase ,
+  blockFieldRegistryChecksum ,
+  parseBlockFieldsFromJson ,
   makeThrowingGetEventBlock ,
+  makeFieldRegistry ,
+  fieldRegistryLowercase ,
+  fieldRegistryChecksum ,
+  parseFieldsFromJson ,
   makeThrowingGetEventTransaction ,
-  sanitizeUrl ,
   make ,
 }
-/* Rpc Not a pure module */
+/* lowercaseAddressSchema Not a pure module */