envio 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/sources/RpcSource.res

@@ -3,62 +3,67 @@ open Source
 
 exception QueryTimout(string)
 
-let getKnownBlock = (provider, blockNumber) =>
-  provider
-  ->Ethers.JsonRpcProvider.getBlock(blockNumber)
-  ->Promise.then(blockNullable =>
-    switch blockNullable->Js.Nullable.toOption {
-    | Some(block) => Promise.resolve(block)
-    | None =>
-      Promise.reject(
-        Js.Exn.raiseError(`RPC returned null for blockNumber ${blockNumber->Belt.Int.toString}`),
-      )
-    }
-  )
+// Minimal block data needed for infrastructure (reorg guard, timestamps, etc.)
+type blockInfo = {
+  number: int,
+  timestamp: int,
+  hash: string,
+}
 
-let rec getKnownBlockWithBackoff = async (
-  ~provider,
+let getKnownRawBlock = async (~client, ~blockNumber) =>
+  switch await Rpc.getRawBlock(~client, ~blockNumber) {
+  | Some(json) => json
+  | None => Js.Exn.raiseError(`RPC returned null for blockNumber ${blockNumber->Belt.Int.toString}`)
+  }
+
+// Extract infrastructure fields (number, timestamp, hash) from raw block JSON
+let parseBlockInfo = (json: Js.Json.t): blockInfo => {
+  let jsonDict = json->(Utils.magic: Js.Json.t => Js.Dict.t<Js.Json.t>)
+  {
+    number: jsonDict
+    ->Js.Dict.unsafeGet("number")
+    ->S.parseOrThrow(Rpc.hexIntSchema),
+    timestamp: jsonDict
+    ->Js.Dict.unsafeGet("timestamp")
+    ->S.parseOrThrow(Rpc.hexIntSchema),
+    hash: jsonDict
+    ->Js.Dict.unsafeGet("hash")
+    ->S.parseOrThrow(S.string),
+  }
+}
+
+let getKnownRawBlockWithBackoff = async (
+  ~client,
   ~sourceName,
   ~chain,
   ~blockNumber,
   ~backoffMsOnFailure,
-  ~lowercaseAddresses: bool,
-) =>
-  switch await getKnownBlock(provider, blockNumber) {
-  | exception err =>
-    Logging.warn({
-      "err": err->Utils.prettifyExn,
-      "msg": `Issue while running fetching batch of events from the RPC. Will wait ${backoffMsOnFailure->Belt.Int.toString}ms and try again.`,
-      "source": sourceName,
-      "chainId": chain->ChainMap.Chain.toChainId,
-      "type": "EXPONENTIAL_BACKOFF",
-    })
-    await Time.resolvePromiseAfterDelay(~delayMilliseconds=backoffMsOnFailure)
-    await getKnownBlockWithBackoff(
-      ~provider,
+) => {
+  let currentBackoff = ref(backoffMsOnFailure)
+  let result = ref(None)
+
+  while result.contents->Option.isNone {
+    Prometheus.SourceRequestCount.increment(
       ~sourceName,
-      ~chain,
-      ~blockNumber,
-      ~backoffMsOnFailure=backoffMsOnFailure * 2,
-      ~lowercaseAddresses,
+      ~chainId=chain->ChainMap.Chain.toChainId,
+      ~method="eth_getBlockByNumber",
     )
-  | result =>
-    if lowercaseAddresses {
-      // NOTE: this is wasteful if these fields are not selected in the users config.
-      //       There might be a better way to do this based on the block schema.
-      //       However this is not extremely expensive and good enough for now (only on rpc sync also).
-
-      {
-        ...result,
-        // Mutation would be cheaper,
-        // BUT "result" is an Ethers.js Block object,
-        // which has the fields as readonly.
-        miner: result.miner->Address.Evm.fromAddressLowercaseOrThrow,
-      }
-    } else {
-      result
+    switch await getKnownRawBlock(~client, ~blockNumber) {
+    | exception err =>
+      Logging.warn({
+        "err": err->Utils.prettifyExn,
+        "msg": `Issue while running fetching batch of events from the RPC. Will wait ${currentBackoff.contents->Belt.Int.toString}ms and try again.`,
+        "source": sourceName,
+        "chainId": chain->ChainMap.Chain.toChainId,
+        "type": "EXPONENTIAL_BACKOFF",
+      })
+      await Time.resolvePromiseAfterDelay(~delayMilliseconds=currentBackoff.contents)
+      currentBackoff := currentBackoff.contents * 2
+    | json => result := Some(json)
     }
   }
+  result.contents->Option.getExn
+}
 let getSuggestedBlockIntervalFromExn = {
   // Unknown provider: "retry with the range 123-456"
   let suggestedRangeRegExp = %re(`/retry with the range (\d+)-(\d+)/`)
@@ -111,82 +116,68 @@ let getSuggestedBlockIntervalFromExn = {
   // - Optimism: "backend response too large" or "Block range is too large"
   // - Arbitrum: "logs matched by query exceeds limit of 10000"
 
-  (exn): option<(
-    // The suggested block range
-    int,
-    // Whether it's the max range that the provider allows
-    bool,
-  )> =>
-    switch exn {
-    | Js.Exn.Error(error) =>
-      try {
-        let message: string = (error->Obj.magic)["error"]["message"]
-        message->S.assertOrThrow(S.string)
-
-        // Helper to extract block range from regex match
-        let extractBlockRange = (execResult, ~isMaxRange) =>
-          switch execResult->Js.Re.captures {
-          | [_, Js.Nullable.Value(blockRangeLimit)] =>
-            switch blockRangeLimit->Int.fromString {
-            | Some(blockRangeLimit) if blockRangeLimit > 0 => Some(blockRangeLimit, isMaxRange)
-            | _ => None
-            }
-          | _ => None
-          }
+  let parseMessageForBlockRange = (message: string) => {
+    // Helper to extract block range from regex match
+    let extractBlockRange = (execResult, ~isMaxRange) =>
+      switch execResult->Js.Re.captures {
+      | [_, Js.Nullable.Value(blockRangeLimit)] =>
+        switch blockRangeLimit->Int.fromString {
+        | Some(blockRangeLimit) if blockRangeLimit > 0 => Some(blockRangeLimit, isMaxRange)
+        | _ => None
+        }
+      | _ => None
+      }
 
-        // Try each regex pattern in order
-        switch suggestedRangeRegExp->Js.Re.exec_(message) {
-        | Some(execResult) =>
-          switch execResult->Js.Re.captures {
-          | [_, Js.Nullable.Value(fromBlock), Js.Nullable.Value(toBlock)] =>
-            switch (fromBlock->Int.fromString, toBlock->Int.fromString) {
-            | (Some(fromBlock), Some(toBlock)) if toBlock >= fromBlock =>
-              Some(toBlock - fromBlock + 1, false)
-            | _ => None
-            }
-          | _ => None
-          }
+    // Try each regex pattern in order
+    switch suggestedRangeRegExp->Js.Re.exec_(message) {
+    | Some(execResult) =>
+      switch execResult->Js.Re.captures {
+      | [_, Js.Nullable.Value(fromBlock), Js.Nullable.Value(toBlock)] =>
+        switch (fromBlock->Int.fromString, toBlock->Int.fromString) {
+        | (Some(fromBlock), Some(toBlock)) if toBlock >= fromBlock =>
+          Some(toBlock - fromBlock + 1, false)
+        | _ => None
+        }
+      | _ => None
+      }
+    | None =>
+      // Try each provider's specific error pattern
+      switch blockRangeLimitRegExp->Js.Re.exec_(message) {
+      | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
+      | None =>
+        switch alchemyRangeRegExp->Js.Re.exec_(message) {
+        | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
         | None =>
-          // Try each provider's specific error pattern
-          switch blockRangeLimitRegExp->Js.Re.exec_(message) {
+          switch cloudflareRangeRegExp->Js.Re.exec_(message) {
           | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
           | None =>
-            switch alchemyRangeRegExp->Js.Re.exec_(message) {
+            switch thirdwebRangeRegExp->Js.Re.exec_(message) {
             | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
             | None =>
-              switch cloudflareRangeRegExp->Js.Re.exec_(message) {
+              switch blockpiRangeRegExp->Js.Re.exec_(message) {
               | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
               | None =>
-                switch thirdwebRangeRegExp->Js.Re.exec_(message) {
+                switch maxAllowedBlocksRegExp->Js.Re.exec_(message) {
                 | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
                 | None =>
-                  switch blockpiRangeRegExp->Js.Re.exec_(message) {
-                  | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
+                  switch baseRangeRegExp->Js.Re.exec_(message) {
+                  | Some(_) => Some(2000, true)
                   | None =>
-                    switch maxAllowedBlocksRegExp->Js.Re.exec_(message) {
+                    switch blastPaidRegExp->Js.Re.exec_(message) {
                     | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
                     | None =>
-                      switch baseRangeRegExp->Js.Re.exec_(message) {
-                      | Some(_) => Some(2000, true)
+                      switch chainstackRegExp->Js.Re.exec_(message) {
+                      | Some(_) => Some(10000, true)
                       | None =>
-                        switch blastPaidRegExp->Js.Re.exec_(message) {
+                        switch coinbaseRegExp->Js.Re.exec_(message) {
                         | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
                         | None =>
-                          switch chainstackRegExp->Js.Re.exec_(message) {
-                          | Some(_) => Some(10000, true)
+                          switch publicNodeRegExp->Js.Re.exec_(message) {
+                          | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
                           | None =>
-                            switch coinbaseRegExp->Js.Re.exec_(message) {
+                            switch hyperliquidRegExp->Js.Re.exec_(message) {
                             | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
-                            | None =>
-                              switch publicNodeRegExp->Js.Re.exec_(message) {
-                              | Some(execResult) => extractBlockRange(execResult, ~isMaxRange=true)
-                              | None =>
-                                switch hyperliquidRegExp->Js.Re.exec_(message) {
-                                | Some(execResult) =>
-                                  extractBlockRange(execResult, ~isMaxRange=true)
-                                | None => None
-                                }
-                              }
+                            | None => None
                             }
                           }
                         }
@@ -198,6 +189,23 @@ let getSuggestedBlockIntervalFromExn = {
             }
           }
         }
+      }
+    }
+  }
+
+  (exn): option<(
+    // The suggested block range
+    int,
+    // Whether it's the max range that the provider allows
+    bool,
+  )> =>
+    switch exn {
+    | Rpc.JsonRpcError({message}) => parseMessageForBlockRange(message)
+    | Js.Exn.Error(error) =>
+      try {
+        let message: string = (error->Obj.magic)["error"]["message"]
+        message->S.assertOrThrow(S.string)
+        parseMessageForBlockRange(message)
       } catch {
       | _ => None
       }
@@ -206,8 +214,8 @@ let getSuggestedBlockIntervalFromExn = {
 }
 
 type eventBatchQuery = {
-  logs: array<Ethers.log>,
-  latestFetchedBlock: Ethers.JsonRpcProvider.block,
+  logs: array<Rpc.GetLogs.log>,
+  latestFetchedBlockInfo: blockInfo,
 }
 
 let maxSuggestedBlockIntervalKey = "max"
@@ -219,9 +227,11 @@ let getNextPage = (
   ~topicQuery,
   ~loadBlock,
   ~syncConfig as sc: Config.sourceSync,
-  ~provider,
+  ~client,
   ~mutSuggestedBlockIntervals,
   ~partitionId,
+  ~sourceName,
+  ~chainId,
 ): promise<eventBatchQuery> => {
   //If the query hangs for longer than this, reject this promise to reduce the block interval
   let queryTimoutPromise =
@@ -234,22 +244,21 @@ let getNextPage = (
     )
 
   let latestFetchedBlockPromise = loadBlock(toBlock)
-  let logsPromise =
-    provider
-    ->Ethers.JsonRpcProvider.getLogs(
-      ~filter={
-        address: ?addresses,
-        topics: topicQuery,
-        fromBlock,
-        toBlock,
-      }->Ethers.CombinedFilter.toFilter,
-    )
-    ->Promise.then(async logs => {
-      {
-        logs,
-        latestFetchedBlock: await latestFetchedBlockPromise,
-      }
-    })
+  Prometheus.SourceRequestCount.increment(~sourceName, ~chainId, ~method="eth_getLogs")
+  let logsPromise = Rpc.getLogs(
+    ~client,
+    ~param={
+      address: ?addresses,
+      topics: topicQuery,
+      fromBlock,
+      toBlock,
+    },
+  )->Promise.then(async logs => {
+    {
+      logs,
+      latestFetchedBlockInfo: await latestFetchedBlockPromise,
+    }
+  })
 
   [queryTimoutPromise, logsPromise]
   ->Promise.race
@@ -337,7 +346,7 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
       }
     }
   | ([], [dynamicEventFilter]) if selection.eventConfigs->Js.Array2.length === 1 =>
-    let eventConfig = selection.eventConfigs->Js.Array2.unsafe_get(0)
+    let eventConfig = selection.eventConfigs->Utils.Array.firstUnsafe
 
     (~addressesByContractName) => {
       let addresses = addressesByContractName->FetchState.addressesByContractNameGetAll
@@ -371,74 +380,343 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
   }
 }
 
-let memoGetSelectionConfig = (~chain) => {
-  let cache = Utils.WeakMap.make()
-  selection =>
-    switch cache->Utils.WeakMap.get(selection) {
-    | Some(c) => c
-    | None => {
-        let c = selection->getSelectionConfig(~chain)
-        let _ = cache->Utils.WeakMap.set(selection, c)
-        c
-      }
+let memoGetSelectionConfig = (~chain) =>
+  Utils.WeakMap.memoize(selection => selection->getSelectionConfig(~chain))
+
+// Type-erase a schema for storage in the field registry
+external toFieldSchema: S.t<'a> => S.t<Js.Json.t> = "%identity"
+
+let lowercaseAddressSchema: S.t<Js.Json.t> =
+  S.string
+  ->S.transform(_ => {
+    parser: str => str->Js.String2.toLowerCase->Address.unsafeFromString,
+  })
+  ->toFieldSchema
+
+let checksumAddressSchema: S.t<Js.Json.t> =
+  S.string
+  ->S.transform(_ => {
+    parser: str => str->Address.Evm.fromStringOrThrow,
+  })
+  ->toFieldSchema
+
+// Block field definition for per-field parsing
+type blockFieldDef = {
+  location: Internal.evmBlockField,
+  jsonKey: string,
+  schema: S.t<Js.Json.t>, // Type-erased schema
+}
+
+// Block field registry: maps field location (= JS property name) to parsing info.
+let makeBlockFieldRegistry = (addressSchema: S.t<Js.Json.t>): Utils.Record.t<
+  Internal.evmBlockField,
+  blockFieldDef,
+> =>
+  [
+    {location: Number, jsonKey: "number", schema: Rpc.hexIntSchema->toFieldSchema},
+    {location: Timestamp, jsonKey: "timestamp", schema: Rpc.hexIntSchema->toFieldSchema},
+    {location: Hash, jsonKey: "hash", schema: S.string->toFieldSchema},
+    {location: ParentHash, jsonKey: "parentHash", schema: S.string->toFieldSchema},
+    {location: Nonce, jsonKey: "nonce", schema: Rpc.hexBigintSchema->toFieldSchema},
+    {location: Sha3Uncles, jsonKey: "sha3Uncles", schema: S.string->toFieldSchema},
+    {location: LogsBloom, jsonKey: "logsBloom", schema: S.string->toFieldSchema},
+    {location: TransactionsRoot, jsonKey: "transactionsRoot", schema: S.string->toFieldSchema},
+    {location: StateRoot, jsonKey: "stateRoot", schema: S.string->toFieldSchema},
+    {location: ReceiptsRoot, jsonKey: "receiptsRoot", schema: S.string->toFieldSchema},
+    {location: Miner, jsonKey: "miner", schema: addressSchema},
+    {location: Difficulty, jsonKey: "difficulty", schema: Rpc.hexBigintSchema->toFieldSchema},
+    {location: TotalDifficulty, jsonKey: "totalDifficulty", schema: Rpc.hexBigintSchema->toFieldSchema},
+    {location: ExtraData, jsonKey: "extraData", schema: S.string->toFieldSchema},
+    {location: Size, jsonKey: "size", schema: Rpc.hexBigintSchema->toFieldSchema},
+    {location: GasLimit, jsonKey: "gasLimit", schema: Rpc.hexBigintSchema->toFieldSchema},
+    {location: GasUsed, jsonKey: "gasUsed", schema: Rpc.hexBigintSchema->toFieldSchema},
+    {location: Uncles, jsonKey: "uncles", schema: S.array(S.string)->toFieldSchema},
+    {location: BaseFeePerGas, jsonKey: "baseFeePerGas", schema: Rpc.hexBigintSchema->toFieldSchema},
+    {location: BlobGasUsed, jsonKey: "blobGasUsed", schema: Rpc.hexBigintSchema->toFieldSchema},
+    {location: ExcessBlobGas, jsonKey: "excessBlobGas", schema: Rpc.hexBigintSchema->toFieldSchema},
+    {location: ParentBeaconBlockRoot, jsonKey: "parentBeaconBlockRoot", schema: S.string->toFieldSchema},
+    {location: WithdrawalsRoot, jsonKey: "withdrawalsRoot", schema: S.string->toFieldSchema},
+    {location: L1BlockNumber, jsonKey: "l1BlockNumber", schema: Rpc.hexIntSchema->toFieldSchema},
+    {location: SendCount, jsonKey: "sendCount", schema: S.string->toFieldSchema},
+    {location: SendRoot, jsonKey: "sendRoot", schema: S.string->toFieldSchema},
+    {location: MixHash, jsonKey: "mixHash", schema: S.string->toFieldSchema},
+  ]
+  ->Array.map(def => (
+    def.location,
+    if Internal.evmNullableBlockFields->Utils.Set.has(def.location) {
+      {...def, schema: S.nullable(def.schema)->toFieldSchema}
+    } else {
+      def
+    },
+  ))
+  ->Utils.Record.fromArray
+
+let blockFieldRegistryLowercase = makeBlockFieldRegistry(lowercaseAddressSchema)
+let blockFieldRegistryChecksum = makeBlockFieldRegistry(checksumAddressSchema)
+
+// Parse block fields from raw JSON, similar to parseFieldsFromJson for transactions
+let parseBlockFieldsFromJson = (
+  mutBlockAcc: Js.Dict.t<Js.Json.t>,
+  fields: array<blockFieldDef>,
+  json: Js.Json.t,
+) => {
+  let jsonDict = json->(Utils.magic: Js.Json.t => Js.Dict.t<Js.Json.t>)
+  fields->Array.forEach(def => {
+    let raw = jsonDict->Js.Dict.unsafeGet(def.jsonKey)
+    try {
+      let parsed = raw->S.parseOrThrow(def.schema)
+      mutBlockAcc->Js.Dict.set((def.location :> string), parsed)
+    } catch {
+    | S.Raised(error) =>
+      Js.Exn.raiseError(
+        `Invalid block field "${(def.location :> string)}" found in the RPC response. Error: ${error->S.Error.reason}`,
+      )
     }
+  })
 }
 
-let makeThrowingGetEventBlock = (~getBlock) => {
-  async (log: Ethers.log) => {
-    await getBlock(log.blockNumber)
+let makeThrowingGetEventBlock = (
+  ~getBlockJson: int => promise<Js.Json.t>,
+  ~lowercaseAddresses: bool,
+) => {
+  let blockFieldRegistry = if lowercaseAddresses {
+    blockFieldRegistryLowercase
+  } else {
+    blockFieldRegistryChecksum
   }
+  let fnsCache = Utils.WeakMap.make()
+  (log: Rpc.GetLogs.log, ~selectedBlockFields: Utils.Set.t<Internal.evmBlockField>) => {
+    (
+      switch fnsCache->Utils.WeakMap.get(selectedBlockFields) {
+      | Some(fn) => fn
+      // Build per-field parser on first call, then cache in WeakMap
+      | None => {
+          let fields: array<blockFieldDef> = []
+          selectedBlockFields->Utils.Set.forEach(fieldName => {
+            fields->Js.Array2.push(blockFieldRegistry->Utils.Record.getUnsafe(fieldName))->ignore
+          })
+
+          let fn = if selectedBlockFields->Utils.Set.size == 0 {
+            _ => %raw(`{}`)->(Utils.magic: 'a => Internal.eventBlock)->Promise.resolve
+          } else {
+            (log: Rpc.GetLogs.log) => {
+              getBlockJson(log.blockNumber)->Promise.thenResolve(json => {
+                let mutBlockAcc = Js.Dict.empty()
+                parseBlockFieldsFromJson(mutBlockAcc, fields, json)
+                mutBlockAcc->(Utils.magic: Js.Dict.t<Js.Json.t> => Internal.eventBlock)
+              })
+            }
+          }
+          let _ = fnsCache->Utils.WeakMap.set(selectedBlockFields, fn)
+          fn
+        }
+      }
+    )(log)
+  }
+}
+
+// Field source classification for RPC calls
+type fieldSource = TransactionOnly | ReceiptOnly | Both
+
+type fieldDef = {
+  location: Internal.evmTransactionField,
+  jsonKey: string,
+  schema: S.t<Js.Json.t>, // Type-erased schema (S.nullable for optional fields)
+  source: fieldSource,
+}
+
+// Field registry: maps field location (= JS property name) to parsing info.
+// Only includes fields that require an RPC call. Log-derived fields (hash, transactionIndex) are special-cased.
+// Nullable fields are wrapped with S.nullable during registry construction based on Internal.evmNullableTransactionFields
+let makeFieldRegistry = (addressSchema: S.t<Js.Json.t>): Utils.Record.t<
+  Internal.evmTransactionField,
+  fieldDef,
+> =>
+  [
+    // TransactionOnly fields (only in eth_getTransactionByHash)
+    {location: Gas, jsonKey: "gas", schema: Rpc.hexBigintSchema->toFieldSchema, source: TransactionOnly},
+    {location: GasPrice, jsonKey: "gasPrice", schema: Rpc.hexBigintSchema->toFieldSchema, source: TransactionOnly},
+    {location: Input, jsonKey: "input", schema: S.string->toFieldSchema, source: TransactionOnly},
+    {location: Nonce, jsonKey: "nonce", schema: Rpc.hexBigintSchema->toFieldSchema, source: TransactionOnly},
+    {location: Value, jsonKey: "value", schema: Rpc.hexBigintSchema->toFieldSchema, source: TransactionOnly},
+    {location: V, jsonKey: "v", schema: S.string->toFieldSchema, source: TransactionOnly},
+    {location: R, jsonKey: "r", schema: S.string->toFieldSchema, source: TransactionOnly},
+    {location: S, jsonKey: "s", schema: S.string->toFieldSchema, source: TransactionOnly},
+    {location: YParity, jsonKey: "yParity", schema: S.string->toFieldSchema, source: TransactionOnly},
+    {location: MaxPriorityFeePerGas, jsonKey: "maxPriorityFeePerGas", schema: Rpc.hexBigintSchema->toFieldSchema, source: TransactionOnly},
+    {location: MaxFeePerGas, jsonKey: "maxFeePerGas", schema: Rpc.hexBigintSchema->toFieldSchema, source: TransactionOnly},
+    {location: MaxFeePerBlobGas, jsonKey: "maxFeePerBlobGas", schema: Rpc.hexBigintSchema->toFieldSchema, source: TransactionOnly},
+    {location: BlobVersionedHashes, jsonKey: "blobVersionedHashes", schema: S.array(S.string)->toFieldSchema, source: TransactionOnly},
+    // ReceiptOnly fields (only in eth_getTransactionReceipt)
+    {location: GasUsed, jsonKey: "gasUsed", schema: Rpc.hexBigintSchema->toFieldSchema, source: ReceiptOnly},
+    {location: CumulativeGasUsed, jsonKey: "cumulativeGasUsed", schema: Rpc.hexBigintSchema->toFieldSchema, source: ReceiptOnly},
+    {location: EffectiveGasPrice, jsonKey: "effectiveGasPrice", schema: Rpc.hexBigintSchema->toFieldSchema, source: ReceiptOnly},
+    {location: ContractAddress, jsonKey: "contractAddress", schema: addressSchema, source: ReceiptOnly},
+    {location: LogsBloom, jsonKey: "logsBloom", schema: S.string->toFieldSchema, source: ReceiptOnly},
+    {location: Root, jsonKey: "root", schema: S.string->toFieldSchema, source: ReceiptOnly},
+    {location: Status, jsonKey: "status", schema: Rpc.hexIntSchema->toFieldSchema, source: ReceiptOnly},
+    {location: L1Fee, jsonKey: "l1Fee", schema: Rpc.hexBigintSchema->toFieldSchema, source: ReceiptOnly},
+    {location: L1GasPrice, jsonKey: "l1GasPrice", schema: Rpc.hexBigintSchema->toFieldSchema, source: ReceiptOnly},
+    {location: L1GasUsed, jsonKey: "l1GasUsed", schema: Rpc.hexBigintSchema->toFieldSchema, source: ReceiptOnly},
+    {location: L1FeeScalar, jsonKey: "l1FeeScalar", schema: Rpc.decimalFloatSchema->toFieldSchema, source: ReceiptOnly},
+    {location: GasUsedForL1, jsonKey: "gasUsedForL1", schema: Rpc.hexBigintSchema->toFieldSchema, source: ReceiptOnly},
+    // Both fields (available in both eth_getTransactionByHash and eth_getTransactionReceipt)
+    {location: From, jsonKey: "from", schema: addressSchema, source: Both},
+    {location: To, jsonKey: "to", schema: addressSchema, source: Both},
+    {location: Type, jsonKey: "type", schema: Rpc.hexIntSchema->toFieldSchema, source: Both},
+  ]
+  ->Array.map(def => (
+    def.location,
+    if Internal.evmNullableTransactionFields->Utils.Set.has(def.location) {
+      {...def, schema: S.nullable(def.schema)->toFieldSchema}
+    } else {
+      def
+    },
+  ))
+  ->Utils.Record.fromArray
+
+let fieldRegistryLowercase = makeFieldRegistry(lowercaseAddressSchema)
+let fieldRegistryChecksum = makeFieldRegistry(checksumAddressSchema)
+
+type fetchStrategy = NoRpc | TransactionOnly | ReceiptOnly | TransactionAndReceipt
+
+// Parse fields from a raw JSON object into a result dict.
+// Uses unsafeGet so nullable schemas (S.nullable) handle both null and undefined.
+let parseFieldsFromJson = (
+  mutTransactionAcc: Js.Dict.t<Js.Json.t>,
+  fields: array<fieldDef>,
+  json: Js.Json.t,
+) => {
+  let jsonDict = json->(Utils.magic: Js.Json.t => Js.Dict.t<Js.Json.t>)
+  fields->Array.forEach(def => {
+    let raw = jsonDict->Js.Dict.unsafeGet(def.jsonKey)
+    try {
+      let parsed = raw->S.parseOrThrow(def.schema)
+      mutTransactionAcc->Js.Dict.set((def.location :> string), parsed)
+    } catch {
+    | S.Raised(error) =>
+      Js.Exn.raiseError(
+        `Invalid transaction field "${(def.location :> string)}" found in the RPC response. Error: ${error->S.Error.reason}`,
+      )
+    }
+  })
 }
 
-let makeThrowingGetEventTransaction = (~getTransactionFields) => {
+let makeThrowingGetEventTransaction = (
+  ~getTransactionJson: string => promise<Js.Json.t>,
+  ~getReceiptJson: string => promise<Js.Json.t>,
+  ~lowercaseAddresses: bool,
+) => {
+  let fieldRegistry = if lowercaseAddresses {
+    fieldRegistryLowercase
+  } else {
+    fieldRegistryChecksum
+  }
   let fnsCache = Utils.WeakMap.make()
-  (log, ~transactionSchema) => {
+  (log, ~selectedTransactionFields: Utils.Set.t<Internal.evmTransactionField>) => {
     (
-      switch fnsCache->Utils.WeakMap.get(transactionSchema) {
+      switch fnsCache->Utils.WeakMap.get(selectedTransactionFields) {
       | Some(fn) => fn
-      // This is not super expensive, but don't want to do it on every event
+      // Build per-field parser on first call, then cache in WeakMap
       | None => {
-          let transactionSchema = transactionSchema->S.removeTypeValidation
-
-          let transactionFieldItems = switch transactionSchema->S.classify {
-          | Object({items}) => items
-          | _ => Js.Exn.raiseError("Unexpected internal error: transactionSchema is not an object")
+          // Classify fields: log-derived vs RPC fields
+          let hasTransactionIndex = ref(false)
+          let hasHash = ref(false)
+          let txFields: array<fieldDef> = []
+          let receiptFields: array<fieldDef> = []
+          let bothFields: array<fieldDef> = []
+
+          selectedTransactionFields->Utils.Set.forEach(fieldName => {
+            switch fieldName {
+            | TransactionIndex => hasTransactionIndex := true
+            | Hash => hasHash := true
+            | _ =>
+              switch fieldRegistry->Utils.Record.get(fieldName) {
+              | Some(def) =>
+                switch def.source {
+                | TransactionOnly => txFields->Js.Array2.push(def)->ignore
+                | ReceiptOnly => receiptFields->Js.Array2.push(def)->ignore
+                | Both => bothFields->Js.Array2.push(def)->ignore
+                }
+              | None => () // Unknown field — skip silently
+              }
+            }
+          })
+
+          // Determine fetch strategy
+          let strategy = switch (txFields->Array.length > 0, receiptFields->Array.length > 0) {
+          | (true, true) => TransactionAndReceipt
+          | (true, false) => TransactionOnly
+          | (false, true) => ReceiptOnly
+          | (false, false) if bothFields->Array.length > 0 => TransactionOnly
+          | (false, false) => NoRpc
           }
 
-          let parseOrThrowReadableError = data => {
-            try data->S.parseOrThrow(transactionSchema) catch {
-            | S.Raised(error) =>
-              Js.Exn.raiseError(
-                `Invalid transaction field "${error.path
-                  ->S.Path.toArray
-                  ->Js.Array2.joinWith(
-                    ".",
-                  )}" found in the RPC response. Error: ${error->S.Error.reason}`,
-              ) // There should always be only one field, but just in case split them with a dot
+          // Assign Both fields to whichever source is already being fetched; default to transaction
+          let targetForBoth = strategy == ReceiptOnly ? receiptFields : txFields
+          bothFields->Array.forEach(f => targetForBoth->Js.Array2.push(f)->ignore)
+
+          // Set log-derived fields on the mutable accumulator
+          let setLogFields = (mutTransactionAcc: Js.Dict.t<Js.Json.t>, log: Rpc.GetLogs.log) => {
+            if hasTransactionIndex.contents {
+              mutTransactionAcc->Js.Dict.set(
+                "transactionIndex",
+                log.transactionIndex->(Utils.magic: int => Js.Json.t),
+              )
+            }
+            if hasHash.contents {
+              mutTransactionAcc->Js.Dict.set(
+                "hash",
+                log.transactionHash->(Utils.magic: string => Js.Json.t),
+              )
             }
           }
 
-          let fn = switch transactionFieldItems {
-          | [] => _ => %raw(`{}`)->Promise.resolve
-          | [{location: "transactionIndex"}] =>
-            log => log->parseOrThrowReadableError->Promise.resolve
-          | [{location: "hash"}]
-          | [{location: "hash"}, {location: "transactionIndex"}]
-          | [{location: "transactionIndex"}, {location: "hash"}] =>
-            (log: Ethers.log) =>
-              {
-                "hash": log.transactionHash,
-                "transactionIndex": log.transactionIndex,
+          let fn = if selectedTransactionFields->Utils.Set.size == 0 {
+            _ => %raw(`{}`)->Promise.resolve
+          } else {
+            switch strategy {
+            | NoRpc =>
+              (log: Rpc.GetLogs.log) => {
+                let mutTransactionAcc = Js.Dict.empty()
+                setLogFields(mutTransactionAcc, log)
+                mutTransactionAcc->(Utils.magic: Js.Dict.t<Js.Json.t> => 'a)->Promise.resolve
               }
-              ->parseOrThrowReadableError
-              ->Promise.resolve
-          | _ =>
-            log =>
-              log
-              ->getTransactionFields
-              ->Promise.thenResolve(parseOrThrowReadableError)
+            | _ =>
+              (log: Rpc.GetLogs.log) => {
+                let txJsonPromise = switch strategy {
+                | TransactionOnly | TransactionAndReceipt =>
+                  getTransactionJson(log.transactionHash)->Promise.thenResolve(v => Some(v))
+                | _ => Promise.resolve(None)
+                }
+                let receiptJsonPromise = switch strategy {
+                | ReceiptOnly | TransactionAndReceipt =>
+                  getReceiptJson(log.transactionHash)->Promise.thenResolve(v => Some(v))
+                | _ => Promise.resolve(None)
+                }
+
+                Promise.all2((txJsonPromise, receiptJsonPromise))->Promise.thenResolve(((
+                  txJson,
+                  receiptJson,
+                )) => {
+                  let mutTransactionAcc = Js.Dict.empty()
+                  setLogFields(mutTransactionAcc, log)
+
+                  switch txJson {
+                  | Some(json) => parseFieldsFromJson(mutTransactionAcc, txFields, json)
+                  | None => ()
+                  }
+                  switch receiptJson {
+                  | Some(json) => parseFieldsFromJson(mutTransactionAcc, receiptFields, json)
+                  | None => ()
+                  }
+
+                  mutTransactionAcc->(Utils.magic: Js.Dict.t<Js.Json.t> => 'a)
+                })
+              }
+            }
           }
-          let _ = fnsCache->Utils.WeakMap.set(transactionSchema, fn)
+          let _ = fnsCache->Utils.WeakMap.set(selectedTransactionFields, fn)
           fn
         }
       }
@@ -446,33 +724,15 @@ let makeThrowingGetEventTransaction = (~getTransactionFields) => {
   }
 }
 
-let sanitizeUrl = (url: string) => {
-  // Regular expression requiring protocol and capturing hostname
-  // - (https?:\/\/) : Required http:// or https:// (capturing group)
-  // - ([^\/?]+) : Capture hostname (one or more characters that aren't / or ?)
-  // - .* : Match rest of the string
-  let regex = %re("/https?:\/\/([^\/?]+).*/")
-
-  switch Js.Re.exec_(regex, url) {
-  | Some(result) =>
-    switch Js.Re.captures(result)->Belt.Array.get(1) {
-    | Some(host) => host->Js.Nullable.toOption
-    | None => None
-    }
-  | None => None
-  }
-}
-
 type options = {
   sourceFor: Source.sourceFor,
   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,
+  ws?: string,
 }
 
 let make = (
@@ -481,36 +741,42 @@ let make = (
     syncConfig,
     url,
     chain,
-    contracts,
     eventRouter,
     allEventSignatures,
-    shouldUseHypersyncClientDecoder,
     lowercaseAddresses,
+    ?ws,
   }: options,
 ): t => {
-  let urlHost = switch sanitizeUrl(url) {
+  let chainId = chain->ChainMap.Chain.toChainId
+  let urlHost = switch Utils.Url.getHostFromUrl(url) {
   | None =>
     Js.Exn.raiseError(
-      `EE109: The RPC url "${url}" is incorrect format. The RPC url needs to start with either http:// or https://`,
+      `The RPC url for chain ${chainId->Belt.Int.toString} is in incorrect format. The RPC url needs to start with either http:// or https://`,
     )
   | Some(host) => host
   }
   let name = `RPC (${urlHost})`
 
-  let provider = Ethers.JsonRpcProvider.make(~rpcUrl=url, ~chainId=chain->ChainMap.Chain.toChainId)
-
   let getSelectionConfig = memoGetSelectionConfig(~chain)
 
   let mutSuggestedBlockIntervals = Js.Dict.empty()
 
+  let client = Rpc.makeClient(url)
+
   let makeTransactionLoader = () =>
     LazyLoader.make(
-      ~loaderFn=transactionHash =>
-        provider->Ethers.JsonRpcProvider.getTransaction(~transactionHash),
+      ~loaderFn=transactionHash => {
+        Prometheus.SourceRequestCount.increment(
+          ~sourceName=name,
+          ~chainId=chain->ChainMap.Chain.toChainId,
+          ~method="eth_getTransactionByHash",
+        )
+        Rpc.GetTransactionByHash.rawRoute->Rest.fetch(transactionHash, ~client)
+      },
       ~onError=(am, ~exn) => {
         Logging.error({
           "err": exn->Utils.prettifyExn,
-          "msg": `EE1100: Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ${(am._retryDelayMillis / 1000)
+          "msg": `Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ${(am._retryDelayMillis / 1000)
               ->Belt.Int.toString} 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->ChainMap.Chain.toChainId,
@@ -526,19 +792,19 @@ let make = (
 
   let makeBlockLoader = () =>
     LazyLoader.make(
-      ~loaderFn=blockNumber =>
-        getKnownBlockWithBackoff(
-          ~provider,
+      ~loaderFn=blockNumber => {
+        getKnownRawBlockWithBackoff(
+          ~client,
           ~sourceName=name,
           ~chain,
           ~backoffMsOnFailure=1000,
           ~blockNumber,
-          ~lowercaseAddresses,
-        ),
+        )
+      },
       ~onError=(am, ~exn) => {
         Logging.error({
           "err": exn->Utils.prettifyExn,
-          "msg": `EE1100: Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ${(am._retryDelayMillis / 1000)
+          "msg": `Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ${(am._retryDelayMillis / 1000)
               ->Belt.Int.toString} 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->ChainMap.Chain.toChainId,
@@ -552,27 +818,60 @@ let make = (
       },
     )
 
+  let makeReceiptLoader = () =>
+    LazyLoader.make(
+      ~loaderFn=transactionHash => {
+        Prometheus.SourceRequestCount.increment(
+          ~sourceName=name,
+          ~chainId=chain->ChainMap.Chain.toChainId,
+          ~method="eth_getTransactionReceipt",
+        )
+        Rpc.GetTransactionReceipt.rawRoute->Rest.fetch(transactionHash, ~client)
+      },
+      ~onError=(am, ~exn) => {
+        Logging.error({
+          "err": exn->Utils.prettifyExn,
+          "msg": `Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ${(am._retryDelayMillis / 1000)
+              ->Belt.Int.toString} 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->ChainMap.Chain.toChainId,
+          "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.",
+            }
+          },
+        })
+      },
+    )
+
   let blockLoader = ref(makeBlockLoader())
   let transactionLoader = ref(makeTransactionLoader())
+  let receiptLoader = ref(makeReceiptLoader())
 
-  let getEventBlockOrThrow = makeThrowingGetEventBlock(~getBlock=blockNumber =>
-    blockLoader.contents->LazyLoader.get(blockNumber)
+  let getEventBlockOrThrow = makeThrowingGetEventBlock(
+    ~getBlockJson=blockNumber => blockLoader.contents->LazyLoader.get(blockNumber),
+    ~lowercaseAddresses,
   )
   let getEventTransactionOrThrow = makeThrowingGetEventTransaction(
-    ~getTransactionFields=Ethers.JsonRpcProvider.makeGetTransactionFields(
-      ~getTransactionByHash=LazyLoader.get(transactionLoader.contents, _),
-      ~lowercaseAddresses,
-    ),
+    ~getTransactionJson=async transactionHash => {
+      switch await transactionLoader.contents->LazyLoader.get(transactionHash) {
+      | Some(json) => json
+      | None => Js.Exn.raiseError(`Transaction not found for hash: ${transactionHash}`)
+      }
+    },
+    ~getReceiptJson=async transactionHash => {
+      switch await receiptLoader.contents->LazyLoader.get(transactionHash) {
+      | Some(json) => json
+      | None => Js.Exn.raiseError(`Transaction receipt not found for hash: ${transactionHash}`)
+      }
+    },
+    ~lowercaseAddresses,
   )
 
-  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 convertLogToHyperSyncEvent = (log: Rpc.GetLogs.log): HyperSyncClient.ResponseTypes.event => {
     let hyperSyncLog: HyperSyncClient.ResponseTypes.log = {
-      removed: log.removed->Option.getWithDefault(false),
+      removed: log.removed,
       index: log.logIndex,
       transactionIndex: log.transactionIndex,
       transactionHash: log.transactionHash,
@@ -580,7 +879,7 @@ let make = (
       blockNumber: log.blockNumber,
       address: log.address,
       data: log.data,
-      topics: log.topics->Array.map(topic => Js.Nullable.return(topic)),
+      topics: log.topics->(Utils.magic: array<string> => array<Js.Nullable.t<EvmTypes.Hex.t>>),
     }
     {log: hyperSyncLog}
   }
@@ -601,7 +900,7 @@ let make = (
     ~toBlock,
     ~addressesByContractName,
     ~indexingContracts,
-    ~currentBlockHeight,
+    ~knownHeight,
     ~partitionId,
     ~selection: FetchState.selection,
     ~retry as _,
@@ -621,8 +920,8 @@ let make = (
 
     // Always have a toBlock for an RPC worker
     let toBlock = switch toBlock {
-    | Some(toBlock) => Pervasives.min(toBlock, currentBlockHeight)
-    | None => currentBlockHeight
+    | Some(toBlock) => Pervasives.min(toBlock, knownHeight)
+    | None => knownHeight
     }
 
     let suggestedToBlock = Pervasives.min(fromBlock + suggestedBlockInterval - 1, toBlock)
@@ -631,22 +930,29 @@ let make = (
 
     let firstBlockParentPromise =
       fromBlock > 0
-        ? blockLoader.contents->LazyLoader.get(fromBlock - 1)->Promise.thenResolve(res => res->Some)
+        ? blockLoader.contents
+          ->LazyLoader.get(fromBlock - 1)
+          ->Promise.thenResolve(json => Some(parseBlockInfo(json)))
         : Promise.resolve(None)
 
     let {getLogSelectionOrThrow} = getSelectionConfig(selection)
     let {addresses, topicQuery} = getLogSelectionOrThrow(~addressesByContractName)
 
-    let {logs, latestFetchedBlock} = await getNextPage(
+    let {logs, latestFetchedBlockInfo} = await getNextPage(
       ~fromBlock,
       ~toBlock=suggestedToBlock,
       ~addresses,
       ~topicQuery,
-      ~loadBlock=blockNumber => blockLoader.contents->LazyLoader.get(blockNumber),
+      ~loadBlock=blockNumber =>
+        blockLoader.contents
+        ->LazyLoader.get(blockNumber)
+        ->Promise.thenResolve(parseBlockInfo),
       ~syncConfig,
-      ~provider,
+      ~client,
       ~mutSuggestedBlockIntervals,
       ~partitionId,
+      ~sourceName=name,
+      ~chainId=chain->ChainMap.Chain.toChainId,
     )
 
     let executedBlockInterval = suggestedToBlock - fromBlock + 1
@@ -669,44 +975,41 @@ let make = (
       )
     }
 
-    let parsedQueueItems = if shouldUseHypersyncClientDecoder {
-      // Convert Ethers logs to HyperSync events
-      let hyperSyncEvents = logs->Belt.Array.map(convertEthersLogToHyperSyncEvent)
+    // Convert RPC logs to HyperSync events
+    let hyperSyncEvents = logs->Belt.Array.map(convertLogToHyperSyncEvent)
 
-      // 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.",
-              }),
+    // 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(((
-        log: Ethers.log,
+        log: Rpc.GetLogs.log,
         maybeDecodedEvent: Js.Nullable.t<HyperSyncClient.Decoder.decodedEvent>,
       )) => {
-        let topic0 = log.topics[0]->Option.getWithDefault("0x0"->EvmTypes.Hex.fromStringUnsafe)
+        let topic0 = log.topics[0]->Option.getWithDefault("0x0")
         let routedAddress = if lowercaseAddresses {
           log.address->Address.Evm.fromAddressLowercaseOrThrow
         } else {
-          log.address
+          log.address->Address.Evm.fromAddressOrThrow
         }
 
         switch eventRouter->EventRouter.get(
-          ~tag=EventRouter.getEvmEventId(
-            ~sighash=topic0->EvmTypes.Hex.toString,
-            ~topicCount=log.topics->Array.length,
-          ),
+          ~tag=EventRouter.getEvmEventId(~sighash=topic0, ~topicCount=log.topics->Array.length),
           ~indexingContracts,
           ~contractAddress=routedAddress,
           ~blockNumber=log.blockNumber,
@@ -719,9 +1022,9 @@ let make = (
               (
                 async () => {
                   let (block, transaction) = try await Promise.all2((
-                    log->getEventBlockOrThrow,
+                    log->getEventBlockOrThrow(~selectedBlockFields=eventConfig.selectedBlockFields),
                     log->getEventTransactionOrThrow(
-                      ~transactionSchema=eventConfig.transactionSchema,
+                      ~selectedTransactionFields=eventConfig.selectedTransactionFields,
                     ),
                   )) catch {
                   | exn =>
@@ -739,17 +1042,15 @@ let make = (
 
                   Internal.Event({
                     eventConfig: (eventConfig :> Internal.eventConfig),
-                    timestamp: block.timestamp,
-                    blockNumber: block.number,
+                    timestamp: block->Evm.getTimestamp,
+                    blockNumber: block->Evm.getNumber,
                     chain,
                     logIndex: log.logIndex,
                     event: {
                       chainId: chain->ChainMap.Chain.toChainId,
                       params: decoded->eventConfig.convertHyperSyncEventArgs,
                       transaction,
-                      block: block->(
-                        Utils.magic: Ethers.JsonRpcProvider.block => Internal.eventBlock
-                      ),
+                      block,
                       srcAddress: routedAddress,
                       logIndex: log.logIndex,
                     }->Internal.fromGenericEvent,
@@ -764,97 +1065,10 @@ 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
 
-    let totalTimeElapsed =
-      startFetchingBatchTimeRef->Hrtime.timeSince->Hrtime.toMillis->Hrtime.intFromMillis
+    let totalTimeElapsed = startFetchingBatchTimeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
 
     let reorgGuard: ReorgDetection.reorgGuard = {
       prevRangeLastBlock: optFirstBlockParent->Option.map(b => {
@@ -862,19 +1076,19 @@ let make = (
         blockHash: b.hash,
       }),
       rangeLastBlock: {
-        blockNumber: latestFetchedBlock.number,
-        blockHash: latestFetchedBlock.hash,
+        blockNumber: latestFetchedBlockInfo.number,
+        blockHash: latestFetchedBlockInfo.hash,
       },
     }
 
     {
-      latestFetchedBlockTimestamp: latestFetchedBlock.timestamp,
-      latestFetchedBlockNumber: latestFetchedBlock.number,
+      latestFetchedBlockTimestamp: latestFetchedBlockInfo.timestamp,
+      latestFetchedBlockNumber: latestFetchedBlockInfo.number,
       parsedQueueItems,
       stats: {
         totalTimeElapsed: totalTimeElapsed,
       },
-      currentBlockHeight,
+      knownHeight,
       reorgGuard,
       fromBlockQueried: fromBlock,
     }
@@ -886,32 +1100,75 @@ let make = (
     // function when a reorg is detected
     blockLoader := makeBlockLoader()
     transactionLoader := makeTransactionLoader()
+    receiptLoader := makeReceiptLoader()
 
     blockNumbers
     ->Array.map(blockNum => blockLoader.contents->LazyLoader.get(blockNum))
     ->Promise.all
-    ->Promise.thenResolve(blocks => {
-      blocks
-      ->Array.map((b): ReorgDetection.blockDataWithTimestamp => {
-        blockNumber: b.number,
-        blockHash: b.hash,
-        blockTimestamp: b.timestamp,
+    ->Promise.thenResolve(rawBlocks => {
+      rawBlocks
+      ->Array.map(json => {
+        let b = parseBlockInfo(json)
+
+        (
+          {
+            blockNumber: b.number,
+            blockHash: b.hash,
+            blockTimestamp: b.timestamp,
+          }: ReorgDetection.blockDataWithTimestamp
+        )
       })
       ->Ok
     })
     ->Promise.catch(exn => exn->Error->Promise.resolve)
   }
 
-  let client = Rest.client(url)
+  let createHeightSubscription =
+    ws->Belt.Option.map(wsUrl => (~onHeight) =>
+      RpcWebSocketHeightStream.subscribe(~wsUrl, ~chainId, ~onHeight))
 
   {
     name,
     sourceFor,
     chain,
     poweredByHyperSync: false,
-    pollingInterval: 1000,
+    pollingInterval: syncConfig.pollingInterval,
     getBlockHashes,
-    getHeightOrThrow: () => Rpc.GetBlockHeight.route->Rest.fetch((), ~client),
+    getHeightOrThrow: async () => {
+      let timerRef = Hrtime.makeTimer()
+      let height = try {
+        await Rpc.GetBlockHeight.route->Rest.fetch((), ~client)
+      } catch {
+      | exn =>
+        let seconds = timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+        Prometheus.SourceRequestCount.increment(
+          ~sourceName=name,
+          ~chainId=chain->ChainMap.Chain.toChainId,
+          ~method="eth_blockNumber",
+        )
+        Prometheus.SourceRequestCount.addSeconds(
+          ~sourceName=name,
+          ~chainId=chain->ChainMap.Chain.toChainId,
+          ~method="eth_blockNumber",
+          ~seconds,
+        )
+        exn->raise
+      }
+      let seconds = timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+      Prometheus.SourceRequestCount.increment(
+        ~sourceName=name,
+        ~chainId=chain->ChainMap.Chain.toChainId,
+        ~method="eth_blockNumber",
+      )
+      Prometheus.SourceRequestCount.addSeconds(
+        ~sourceName=name,
+        ~chainId=chain->ChainMap.Chain.toChainId,
+        ~method="eth_blockNumber",
+        ~seconds,
+      )
+      height
+    },
     getItemsOrThrow,
+    ?createHeightSubscription,
   }
 }