envio 3.0.0-alpha.11 → 3.0.0-alpha.12

package/evm.schema.json

@@ -458,6 +458,15 @@
           ],
           "format": "uint32",
           "minimum": 0
+        },
+        "polling_interval": {
+          "description": "How frequently (in milliseconds) to check for new blocks in realtime. Default is 1000ms. Note: Setting this higher than block time does not reduce RPC usage as every block is still fetched to check for reorgs.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
         }
       },
       "additionalProperties": false,
@@ -553,6 +562,15 @@
           ],
           "format": "uint32",
           "minimum": 0
+        },
+        "polling_interval": {
+          "description": "How frequently (in milliseconds) to check for new blocks in realtime. Default is 1000ms. Note: Setting this higher than block time does not reduce RPC usage as every block is still fetched to check for reorgs.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
         }
       },
       "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v3.0.0-alpha.11",
+  "version": "v3.0.0-alpha.12",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
@@ -29,10 +29,10 @@
     "node": ">=22.0.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "v3.0.0-alpha.11",
-    "envio-linux-arm64": "v3.0.0-alpha.11",
-    "envio-darwin-x64": "v3.0.0-alpha.11",
-    "envio-darwin-arm64": "v3.0.0-alpha.11"
+    "envio-linux-x64": "v3.0.0-alpha.12",
+    "envio-linux-arm64": "v3.0.0-alpha.12",
+    "envio-darwin-x64": "v3.0.0-alpha.12",
+    "envio-darwin-arm64": "v3.0.0-alpha.12"
   },
   "dependencies": {
     "@clickhouse/client": "1.12.1",

package/src/Batch.res

@@ -6,6 +6,7 @@ open Utils.UnsafeIntOperators
 type chainAfterBatch = {
   batchSize: int,
   progressBlockNumber: int,
+  sourceBlockNumber: int,
   totalEventsProcessed: int,
   fetchState: FetchState.t,
   isProgressAtHeadWhenBatchCreated: bool,
@@ -108,6 +109,7 @@ let getProgressedChainsById = {
           {
             batchSize,
             progressBlockNumber: progressBlockNumberAfterBatch,
+            sourceBlockNumber: chainBeforeBatch.sourceBlockNumber,
             totalEventsProcessed: chainBeforeBatch.totalEventsProcessed + batchSize,
             fetchState: fetchStateAfterBatch,
             isProgressAtHeadWhenBatchCreated: progressBlockNumberAfterBatch >=

package/src/Batch.res.mjs

@@ -62,6 +62,7 @@ function getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAft
     return {
             batchSize: batchSize,
             progressBlockNumber: progressBlockNumberAfterBatch,
+            sourceBlockNumber: chainBeforeBatch.sourceBlockNumber,
             totalEventsProcessed: chainBeforeBatch.totalEventsProcessed + batchSize,
             fetchState: fetchStateAfterBatch,
             isProgressAtHeadWhenBatchCreated: progressBlockNumberAfterBatch >= chainBeforeBatch.sourceBlockNumber

package/src/Config.res

@@ -8,6 +8,7 @@ type sourceSyncOptions = {
   backoffMillis?: int,
   queryTimeoutMillis?: int,
   fallbackStallTimeout?: int,
+  pollingInterval?: int,
 }
 
 type contract = {
@@ -65,6 +66,7 @@ type sourceSync = {
   backoffMillis: int,
   queryTimeoutMillis: int,
   fallbackStallTimeout: int,
+  pollingInterval: int,
 }
 
 type multichain = | @as("ordered") Ordered | @as("unordered") Unordered
@@ -109,6 +111,7 @@ let rpcConfigSchema = S.schema(s =>
     "backoffMillis": s.matches(S.option(S.int)),
     "fallbackStallTimeout": s.matches(S.option(S.int)),
     "queryTimeoutMillis": s.matches(S.option(S.int)),
+    "pollingInterval": s.matches(S.option(S.int)),
   }
 )
 
@@ -323,6 +326,7 @@ let fromPublic = (
             let backoffMillis = rpcConfig["backoffMillis"]
             let queryTimeoutMillis = rpcConfig["queryTimeoutMillis"]
             let fallbackStallTimeout = rpcConfig["fallbackStallTimeout"]
+            let pollingInterval = rpcConfig["pollingInterval"]
             let hasSyncConfig =
               initialBlockInterval->Option.isSome ||
               backoffMultiplicative->Option.isSome ||
@@ -330,7 +334,8 @@ let fromPublic = (
               intervalCeiling->Option.isSome ||
               backoffMillis->Option.isSome ||
               queryTimeoutMillis->Option.isSome ||
-              fallbackStallTimeout->Option.isSome
+              fallbackStallTimeout->Option.isSome ||
+              pollingInterval->Option.isSome
             let syncConfig: option<sourceSyncOptions> = if hasSyncConfig {
               Some({
                 ?initialBlockInterval,
@@ -340,6 +345,7 @@ let fromPublic = (
                 ?backoffMillis,
                 ?queryTimeoutMillis,
                 ?fallbackStallTimeout,
+                ?pollingInterval,
               })
             } else {
               None

package/src/Config.res.mjs

@@ -30,7 +30,8 @@ var rpcConfigSchema = S$RescriptSchema.schema(function (s) {
               intervalCeiling: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
               backoffMillis: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
               fallbackStallTimeout: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
-              queryTimeoutMillis: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int))
+              queryTimeoutMillis: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
+              pollingInterval: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int))
             };
     });
 
@@ -235,7 +236,8 @@ function fromPublic(publicConfigJson, codegenChainsOpt, maxAddrInPartitionOpt, u
                       var backoffMillis = rpcConfig.backoffMillis;
                       var queryTimeoutMillis = rpcConfig.queryTimeoutMillis;
                       var fallbackStallTimeout = rpcConfig.fallbackStallTimeout;
-                      var hasSyncConfig = Belt_Option.isSome(initialBlockInterval) || Belt_Option.isSome(backoffMultiplicative) || Belt_Option.isSome(accelerationAdditive) || Belt_Option.isSome(intervalCeiling) || Belt_Option.isSome(backoffMillis) || Belt_Option.isSome(queryTimeoutMillis) || Belt_Option.isSome(fallbackStallTimeout);
+                      var pollingInterval = rpcConfig.pollingInterval;
+                      var hasSyncConfig = Belt_Option.isSome(initialBlockInterval) || Belt_Option.isSome(backoffMultiplicative) || Belt_Option.isSome(accelerationAdditive) || Belt_Option.isSome(intervalCeiling) || Belt_Option.isSome(backoffMillis) || Belt_Option.isSome(queryTimeoutMillis) || Belt_Option.isSome(fallbackStallTimeout) || Belt_Option.isSome(pollingInterval);
                       var syncConfig = hasSyncConfig ? ({
                             initialBlockInterval: initialBlockInterval,
                             backoffMultiplicative: backoffMultiplicative,
@@ -243,7 +245,8 @@ function fromPublic(publicConfigJson, codegenChainsOpt, maxAddrInPartitionOpt, u
                             intervalCeiling: intervalCeiling,
                             backoffMillis: backoffMillis,
                             queryTimeoutMillis: queryTimeoutMillis,
-                            fallbackStallTimeout: fallbackStallTimeout
+                            fallbackStallTimeout: fallbackStallTimeout,
+                            pollingInterval: pollingInterval
                           }) : undefined;
                       return {
                               url: rpcConfig.url,

package/src/GlobalState.res

@@ -159,7 +159,6 @@ let updateChainMetadataTable = (
     chainsData->Js.Dict.set(
       cf.chainConfig.id->Belt.Int.toString,
       {
-        blockHeight: cf.fetchState.knownHeight,
         firstEventBlockNumber: cf.firstEventBlockNumber->Js.Null.fromOption,
         isHyperSync: (cf.sourceManager->SourceManager.getActiveSource).poweredByHyperSync,
         latestFetchedBlockNumber: cf.fetchState->FetchState.bufferBlockNumber,

package/src/GlobalState.res.mjs

@@ -127,7 +127,6 @@ function updateChainMetadataTable(cm, persistence, throttler) {
           chainsData[String(cf.chainConfig.id)] = {
             first_event_block: Js_null.fromOption(cf.firstEventBlockNumber),
             buffer_block: FetchState.bufferBlockNumber(cf.fetchState),
-            source_block: cf.fetchState.knownHeight,
             ready_at: Js_null.fromOption(cf.timestampCaughtUpToHeadOrEndblock),
             _is_hyper_sync: SourceManager.getActiveSource(cf.sourceManager).poweredByHyperSync,
             _num_batches_fetched: cf.numBatchesFetched

package/src/PgStorage.res

@@ -933,6 +933,7 @@ let rec writeBatch = async (
                 ): InternalTable.Chains.progressedChain => {
                   chainId: chainAfterBatch.fetchState.chainId,
                   progressBlockNumber: chainAfterBatch.progressBlockNumber,
+                  sourceBlockNumber: chainAfterBatch.sourceBlockNumber,
                   totalEventsProcessed: chainAfterBatch.totalEventsProcessed,
                 }),
               ),

package/src/PgStorage.res.mjs

@@ -635,6 +635,7 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpo
                                               return {
                                                       chainId: chainAfterBatch.fetchState.chainId,
                                                       progressBlockNumber: chainAfterBatch.progressBlockNumber,
+                                                      sourceBlockNumber: chainAfterBatch.sourceBlockNumber,
                                                       totalEventsProcessed: chainAfterBatch.totalEventsProcessed
                                                     };
                                             })));

package/src/db/InternalTable.res

@@ -74,6 +74,7 @@ module Chains = {
   type progressFields = [
     | #progress_block
     | #events_processed
+    | #source_block
   ]
 
   type field = [
@@ -108,7 +109,6 @@ module Chains = {
   type metaFields = {
     @as("first_event_block") firstEventBlockNumber: Js.null<int>,
     @as("buffer_block") latestFetchedBlockNumber: int,
-    @as("source_block") blockHeight: int,
     @as("ready_at")
     timestampCaughtUpToHeadOrEndblock: Js.null<Js.Date.t>,
     @as("_is_hyper_sync") isHyperSync: bool,
@@ -122,6 +122,7 @@ module Chains = {
     @as("max_reorg_depth") maxReorgDepth: int,
     @as("progress_block") progressBlockNumber: int,
     @as("events_processed") numEventsProcessed: int,
+    @as("source_block") blockHeight: int,
     ...metaFields,
   }
 
@@ -212,7 +213,6 @@ VALUES ${valuesRows->Js.Array2.joinWith(",\n       ")};`,
 
   // Fields that can be updated outside of the batch transaction
   let metaFields: array<field> = [
-    #source_block,
     #buffer_block,
     #first_event_block,
     #ready_at,
@@ -279,7 +279,7 @@ FROM "${pgSchema}"."${table.tableName}" as chains;`
     ->(Utils.magic: promise<array<unknown>> => promise<array<rawInitialState>>)
   }
 
-  let progressFields: array<progressFields> = [#progress_block, #events_processed]
+  let progressFields: array<progressFields> = [#progress_block, #events_processed, #source_block]
 
   let makeProgressFieldsUpdateQuery = (~pgSchema) => {
     let setClauses = Belt.Array.mapWithIndex(progressFields, (index, field) => {
@@ -320,6 +320,7 @@ WHERE "id" = $1;`
   type progressedChain = {
     chainId: int,
     progressBlockNumber: int,
+    sourceBlockNumber: int,
     totalEventsProcessed: int,
   }
 
@@ -341,6 +342,7 @@ WHERE "id" = $1;`
           switch field {
           | #progress_block => data.progressBlockNumber->(Utils.magic: int => unknown)
           | #events_processed => data.totalEventsProcessed->(Utils.magic: int => unknown)
+          | #source_block => data.sourceBlockNumber->(Utils.magic: int => unknown)
           },
         )
         ->ignore

package/src/db/InternalTable.res.mjs

@@ -101,9 +101,9 @@ function initialFromConfig(chainConfig) {
           max_reorg_depth: chainConfig.maxReorgDepth,
           progress_block: -1,
           events_processed: 0,
+          source_block: 0,
           first_event_block: null,
           buffer_block: -1,
-          source_block: 0,
           ready_at: null,
           _is_hyper_sync: false,
           _num_batches_fetched: 0
@@ -143,7 +143,6 @@ function makeInitialValuesQuery(pgSchema, chainConfigs) {
 }
 
 var metaFields = [
-  "source_block",
   "buffer_block",
   "first_event_block",
   "ready_at",
@@ -169,7 +168,8 @@ function getInitialState(sql, pgSchema) {
 
 var progressFields = [
   "progress_block",
-  "events_processed"
+  "events_processed",
+  "source_block"
 ];
 
 function makeProgressFieldsUpdateQuery(pgSchema) {
@@ -202,7 +202,9 @@ function setProgressedChains(sql, pgSchema, progressedChains) {
         var params = [];
         params.push(data.chainId);
         progressFields.forEach(function (field) {
-              params.push(field === "progress_block" ? data.progressBlockNumber : data.totalEventsProcessed);
+              params.push(field === "source_block" ? data.sourceBlockNumber : (
+                      field === "progress_block" ? data.progressBlockNumber : data.totalEventsProcessed
+                    ));
             });
         promises.push(sql.unsafe(query, params, {prepare: true}));
       });

package/src/sources/EvmChain.res

@@ -15,6 +15,7 @@ let getSyncConfig = (
     ?backoffMillis,
     ?queryTimeoutMillis,
     ?fallbackStallTimeout,
+    ?pollingInterval,
   }: Config.sourceSyncOptions,
 ): Config.sourceSync => {
   let queryTimeoutMillis = queryTimeoutMillis->Option.getWithDefault(20_000)
@@ -39,6 +40,8 @@ let getSyncConfig = (
     // How long to wait before cancelling an RPC request
     queryTimeoutMillis,
     fallbackStallTimeout: fallbackStallTimeout->Option.getWithDefault(queryTimeoutMillis / 2),
+    // How frequently to check for new blocks in realtime (default: 1000ms)
+    pollingInterval: pollingInterval->Option.getWithDefault(1000),
   }
 }
 

package/src/sources/EvmChain.res.mjs

@@ -16,7 +16,8 @@ function getSyncConfig(param) {
           intervalCeiling: Belt_Option.getWithDefault(Env.Configurable.SyncConfig.intervalCeiling, Belt_Option.getWithDefault(param.intervalCeiling, 10000)),
           backoffMillis: Belt_Option.getWithDefault(param.backoffMillis, 5000),
           queryTimeoutMillis: queryTimeoutMillis,
-          fallbackStallTimeout: Belt_Option.getWithDefault(param.fallbackStallTimeout, queryTimeoutMillis / 2 | 0)
+          fallbackStallTimeout: Belt_Option.getWithDefault(param.fallbackStallTimeout, queryTimeoutMillis / 2 | 0),
+          pollingInterval: Belt_Option.getWithDefault(param.pollingInterval, 1000)
         };
 }
 

package/src/sources/Rpc.res

@@ -183,30 +183,30 @@ module GetBlockHeight = {
 module GetTransactionByHash = {
   let transactionSchema = S.object((s): Internal.evmTransactionFields => {
     // We already know the data so ignore the fields
-    // blockHash: ?s.field("blockHash", S.option(S.string)),
-    // blockNumber: ?s.field("blockNumber", S.option(hexIntSchema)),
-    // chainId: ?s.field("chainId", S.option(hexIntSchema)),
-    from: ?s.field("from", S.option(S.string->(Utils.magic: S.t<string> => S.t<Address.t>))),
-    to: ?s.field("to", S.option(S.string->(Utils.magic: S.t<string> => S.t<Address.t>))),
-    gas: ?s.field("gas", S.option(hexBigintSchema)),
-    gasPrice: ?s.field("gasPrice", S.option(hexBigintSchema)),
-    hash: ?s.field("hash", S.option(S.string)),
-    input: ?s.field("input", S.option(S.string)),
-    nonce: ?s.field("nonce", S.option(hexBigintSchema)),
-    transactionIndex: ?s.field("transactionIndex", S.option(hexIntSchema)),
-    value: ?s.field("value", S.option(hexBigintSchema)),
-    type_: ?s.field("type", S.option(hexIntSchema)),
+    // blockHash: ?s.field("blockHash", S.nullable(S.string)),
+    // blockNumber: ?s.field("blockNumber", S.nullable(hexIntSchema)),
+    // chainId: ?s.field("chainId", S.nullable(hexIntSchema)),
+    from: ?s.field("from", S.nullable(S.string->(Utils.magic: S.t<string> => S.t<Address.t>))),
+    to: ?s.field("to", S.nullable(S.string->(Utils.magic: S.t<string> => S.t<Address.t>))),
+    gas: ?s.field("gas", S.nullable(hexBigintSchema)),
+    gasPrice: ?s.field("gasPrice", S.nullable(hexBigintSchema)),
+    hash: ?s.field("hash", S.nullable(S.string)),
+    input: ?s.field("input", S.nullable(S.string)),
+    nonce: ?s.field("nonce", S.nullable(hexBigintSchema)),
+    transactionIndex: ?s.field("transactionIndex", S.nullable(hexIntSchema)),
+    value: ?s.field("value", S.nullable(hexBigintSchema)),
+    type_: ?s.field("type", S.nullable(hexIntSchema)),
     // Signature fields - optional for ZKSync EIP-712 compatibility
-    v: ?s.field("v", S.option(S.string)),
-    r: ?s.field("r", S.option(S.string)),
-    s: ?s.field("s", S.option(S.string)),
-    yParity: ?s.field("yParity", S.option(S.string)),
+    v: ?s.field("v", S.nullable(S.string)),
+    r: ?s.field("r", S.nullable(S.string)),
+    s: ?s.field("s", S.nullable(S.string)),
+    yParity: ?s.field("yParity", S.nullable(S.string)),
     // EIP-1559 fields
-    maxPriorityFeePerGas: ?s.field("maxPriorityFeePerGas", S.option(hexBigintSchema)),
-    maxFeePerGas: ?s.field("maxFeePerGas", S.option(hexBigintSchema)),
+    maxPriorityFeePerGas: ?s.field("maxPriorityFeePerGas", S.nullable(hexBigintSchema)),
+    maxFeePerGas: ?s.field("maxFeePerGas", S.nullable(hexBigintSchema)),
     // EIP-4844 blob fields
-    maxFeePerBlobGas: ?s.field("maxFeePerBlobGas", S.option(hexBigintSchema)),
-    blobVersionedHashes: ?s.field("blobVersionedHashes", S.option(S.array(S.string))),
+    maxFeePerBlobGas: ?s.field("maxFeePerBlobGas", S.nullable(hexBigintSchema)),
+    blobVersionedHashes: ?s.field("blobVersionedHashes", S.nullable(S.array(S.string))),
     // TODO: Fields to add:
     // pub access_list: Option<Vec<AccessList>>,
     // pub authorization_list: Option<Vec<Authorization>>,

package/src/sources/Rpc.res.mjs

@@ -189,24 +189,24 @@ var GetBlockHeight = {
 
 var transactionSchema = S$RescriptSchema.object(function (s) {
       return {
-              from: s.f("from", S$RescriptSchema.option(S$RescriptSchema.string)),
-              to: s.f("to", S$RescriptSchema.option(S$RescriptSchema.string)),
-              gas: s.f("gas", S$RescriptSchema.option(hexBigintSchema)),
-              gasPrice: s.f("gasPrice", S$RescriptSchema.option(hexBigintSchema)),
-              hash: s.f("hash", S$RescriptSchema.option(S$RescriptSchema.string)),
-              input: s.f("input", S$RescriptSchema.option(S$RescriptSchema.string)),
-              nonce: s.f("nonce", S$RescriptSchema.option(hexBigintSchema)),
-              transactionIndex: s.f("transactionIndex", S$RescriptSchema.option(hexIntSchema)),
-              value: s.f("value", S$RescriptSchema.option(hexBigintSchema)),
-              v: s.f("v", S$RescriptSchema.option(S$RescriptSchema.string)),
-              r: s.f("r", S$RescriptSchema.option(S$RescriptSchema.string)),
-              s: s.f("s", S$RescriptSchema.option(S$RescriptSchema.string)),
-              yParity: s.f("yParity", S$RescriptSchema.option(S$RescriptSchema.string)),
-              maxPriorityFeePerGas: s.f("maxPriorityFeePerGas", S$RescriptSchema.option(hexBigintSchema)),
-              maxFeePerGas: s.f("maxFeePerGas", S$RescriptSchema.option(hexBigintSchema)),
-              maxFeePerBlobGas: s.f("maxFeePerBlobGas", S$RescriptSchema.option(hexBigintSchema)),
-              blobVersionedHashes: s.f("blobVersionedHashes", S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
-              type: s.f("type", S$RescriptSchema.option(hexIntSchema))
+              from: s.f("from", S$RescriptSchema.nullable(S$RescriptSchema.string)),
+              to: s.f("to", S$RescriptSchema.nullable(S$RescriptSchema.string)),
+              gas: s.f("gas", S$RescriptSchema.nullable(hexBigintSchema)),
+              gasPrice: s.f("gasPrice", S$RescriptSchema.nullable(hexBigintSchema)),
+              hash: s.f("hash", S$RescriptSchema.nullable(S$RescriptSchema.string)),
+              input: s.f("input", S$RescriptSchema.nullable(S$RescriptSchema.string)),
+              nonce: s.f("nonce", S$RescriptSchema.nullable(hexBigintSchema)),
+              transactionIndex: s.f("transactionIndex", S$RescriptSchema.nullable(hexIntSchema)),
+              value: s.f("value", S$RescriptSchema.nullable(hexBigintSchema)),
+              v: s.f("v", S$RescriptSchema.nullable(S$RescriptSchema.string)),
+              r: s.f("r", S$RescriptSchema.nullable(S$RescriptSchema.string)),
+              s: s.f("s", S$RescriptSchema.nullable(S$RescriptSchema.string)),
+              yParity: s.f("yParity", S$RescriptSchema.nullable(S$RescriptSchema.string)),
+              maxPriorityFeePerGas: s.f("maxPriorityFeePerGas", S$RescriptSchema.nullable(hexBigintSchema)),
+              maxFeePerGas: s.f("maxFeePerGas", S$RescriptSchema.nullable(hexBigintSchema)),
+              maxFeePerBlobGas: s.f("maxFeePerBlobGas", S$RescriptSchema.nullable(hexBigintSchema)),
+              blobVersionedHashes: s.f("blobVersionedHashes", S$RescriptSchema.nullable(S$RescriptSchema.array(S$RescriptSchema.string))),
+              type: s.f("type", S$RescriptSchema.nullable(hexIntSchema))
             };
     });
 

package/src/sources/RpcSource.res

@@ -16,49 +16,50 @@ let getKnownBlock = (provider, blockNumber) =>
     }
   )
 
-let rec getKnownBlockWithBackoff = async (
+let getKnownBlockWithBackoff = async (
   ~provider,
   ~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,
-      ~sourceName,
-      ~chain,
-      ~blockNumber,
-      ~backoffMsOnFailure=backoffMsOnFailure * 2,
-      ~lowercaseAddresses,
-    )
-  | result =>
-    if lowercaseAddresses {
+) => {
+  let currentBackoff = ref(backoffMsOnFailure)
+  let result = ref(None)
+
+  while result.contents->Option.isNone {
+    Prometheus.SourceRequestCount.increment(~sourceName, ~chainId=chain->ChainMap.Chain.toChainId)
+    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 ${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
+    | block =>
       // 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
+      // Mutation would be cheaper,
+      // BUT "block" is an Ethers.js Block object,
+      // which has the fields as readonly.
+      result :=
+        Some({
+          ...block,
+          miner: if lowercaseAddresses {
+            block.miner->Address.Evm.fromAddressLowercaseOrThrow
+          } else {
+            block.miner->Address.Evm.fromAddressOrThrow
+          },
+        })
     }
   }
+  result.contents->Option.getExn
+}
 let getSuggestedBlockIntervalFromExn = {
   // Unknown provider: "retry with the range 123-456"
   let suggestedRangeRegExp = %re(`/retry with the range (\d+)-(\d+)/`)
@@ -505,8 +506,7 @@ let make = (
 
   let makeBlockLoader = () =>
     LazyLoader.make(
-      ~loaderFn=blockNumber => {
-        Prometheus.SourceRequestCount.increment(~sourceName=name, ~chainId=chain->ChainMap.Chain.toChainId)
+      ~loaderFn=blockNumber =>
         getKnownBlockWithBackoff(
           ~provider,
           ~sourceName=name,
@@ -514,8 +514,7 @@ let make = (
           ~backoffMsOnFailure=1000,
           ~blockNumber,
           ~lowercaseAddresses,
-        )
-      },
+        ),
       ~onError=(am, ~exn) => {
         Logging.error({
           "err": exn->Utils.prettifyExn,
@@ -682,7 +681,7 @@ let make = (
         let routedAddress = if lowercaseAddresses {
           log.address->Address.Evm.fromAddressLowercaseOrThrow
         } else {
-          log.address
+          log.address->Address.Evm.fromAddressOrThrow
         }
 
         switch eventRouter->EventRouter.get(
@@ -804,7 +803,7 @@ let make = (
     sourceFor,
     chain,
     poweredByHyperSync: false,
-    pollingInterval: 1000,
+    pollingInterval: syncConfig.pollingInterval,
     getBlockHashes,
     getHeightOrThrow: () => {
       Prometheus.SourceRequestCount.increment(~sourceName=name, ~chainId=chain->ChainMap.Chain.toChainId)

package/src/sources/RpcSource.res.mjs

@@ -40,40 +40,47 @@ function getKnownBlock(provider, blockNumber) {
 }
 
 async function getKnownBlockWithBackoff(provider, sourceName, chain, blockNumber, backoffMsOnFailure, lowercaseAddresses) {
+  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);
+    var exit = 0;
+    var block;
+    try {
+      block = await getKnownBlock(provider, 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 = {
+        _difficulty: block._difficulty,
+        difficulty: block.difficulty,
+        extraData: block.extraData,
+        gasLimit: block.gasLimit,
+        gasUsed: block.gasUsed,
+        hash: block.hash,
+        miner: lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(block.miner) : Address.Evm.fromAddressOrThrow(block.miner),
+        nonce: block.nonce,
+        number: block.number,
+        parentHash: block.parentHash,
+        timestamp: block.timestamp,
+        transactions: block.transactions
+      };
+    }
+    
+  };
+  return Belt_Option.getExn(result);
 }
 
 var suggestedRangeRegExp = /retry with the range (\d+)-(\d+)/;
@@ -525,7 +532,6 @@ function make(param) {
   };
   var makeBlockLoader = function () {
     return LazyLoader.make((function (blockNumber) {
-                  Prometheus.SourceRequestCount.increment(name, chain);
                   return getKnownBlockWithBackoff(provider, name, chain, blockNumber, 1000, lowercaseAddresses);
                 }), (function (am, exn) {
                   Logging.error({
@@ -640,7 +646,7 @@ function make(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 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 () {
@@ -742,7 +748,7 @@ function make(param) {
           sourceFor: param.sourceFor,
           chain: chain,
           poweredByHyperSync: false,
-          pollingInterval: 1000,
+          pollingInterval: syncConfig.pollingInterval,
           getBlockHashes: getBlockHashes,
           getHeightOrThrow: (function () {
               Prometheus.SourceRequestCount.increment(name, chain);