envio 3.0.0-alpha.11 → 3.0.0-alpha.13

package/evm.schema.json

@@ -307,17 +307,6 @@
           "format": "uint64",
           "minimum": 0
         },
-        "rpc_config": {
-          "description": "RPC configuration for utilizing as the chain's data-source. Typically optional for chains with HyperSync support, which is highly recommended. HyperSync dramatically enhances performance, providing up to a 1000x speed boost over traditional RPC.",
-          "anyOf": [
-            {
-              "$ref": "#/$defs/RpcConfig"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
         "rpc": {
           "description": "RPC configuration for your indexer. If not specified otherwise, for chains supported by HyperSync, RPC serves as a fallback for added reliability. For others, it acts as the primary data-source. HyperSync offers significant performance improvements, up to a 1000x faster than traditional RPC.",
           "anyOf": [
@@ -380,91 +369,6 @@
         "start_block"
       ]
     },
-    "RpcConfig": {
-      "type": "object",
-      "properties": {
-        "url": {
-          "description": "URL of the RPC endpoint. Can be a single URL or an array of URLs. If multiple URLs are provided, the first one will be used as the primary RPC endpoint and the rest will be used as fallbacks.",
-          "anyOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          ]
-        },
-        "initial_block_interval": {
-          "description": "The starting interval in range of blocks per query",
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint32",
-          "minimum": 0
-        },
-        "backoff_multiplicative": {
-          "description": "After an RPC error, how much to scale back the number of blocks requested at once",
-          "type": [
-            "number",
-            "null"
-          ],
-          "format": "double"
-        },
-        "acceleration_additive": {
-          "description": "Without RPC errors or timeouts, how much to increase the number of blocks requested by for the next batch",
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint32",
-          "minimum": 0
-        },
-        "interval_ceiling": {
-          "description": "Do not further increase the block interval past this limit",
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint32",
-          "minimum": 0
-        },
-        "backoff_millis": {
-          "description": "After an error, how long to wait before retrying",
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint32",
-          "minimum": 0
-        },
-        "fallback_stall_timeout": {
-          "description": "If a fallback RPC is provided, the amount of time in ms to wait before kicking off the next provider",
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint32",
-          "minimum": 0
-        },
-        "query_timeout_millis": {
-          "description": "How long to wait before cancelling an RPC request",
-          "type": [
-            "integer",
-            "null"
-          ],
-          "format": "uint32",
-          "minimum": 0
-        }
-      },
-      "additionalProperties": false,
-      "required": [
-        "url"
-      ]
-    },
     "RpcSelection": {
       "anyOf": [
         {
@@ -489,8 +393,22 @@
           "type": "string"
         },
         "for": {
-          "description": "Determines if this RPC is for historical sync, real-time chain indexing, or as a fallback.",
-          "$ref": "#/$defs/For"
+          "description": "Determines if this RPC is for historical sync, real-time chain indexing, or as a fallback. If not specified, defaults to \"fallback\" when HyperSync is available for the chain, or \"sync\" otherwise.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/For"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "ws": {
+          "description": "Optional WebSocket endpoint URL (wss:// or ws://) for real-time block header notifications via eth_subscribe(\"newHeads\"). Provides lower latency than HTTP polling for detecting new blocks.",
+          "type": [
+            "string",
+            "null"
+          ]
         },
         "initial_block_interval": {
           "description": "The starting interval in range of blocks per query",
@@ -553,12 +471,20 @@
           ],
           "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,
       "required": [
-        "url",
-        "for"
+        "url"
       ]
     },
     "For": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v3.0.0-alpha.11",
+  "version": "v3.0.0-alpha.13",
   "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.13",
+    "envio-linux-arm64": "v3.0.0-alpha.13",
+    "envio-darwin-x64": "v3.0.0-alpha.13",
+    "envio-darwin-arm64": "v3.0.0-alpha.13"
   },
   "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
@@ -80,7 +81,7 @@ function getProgressedChainsById(chainsBeforeBatch, batchSizePerChain, progressB
           var progressedChain;
           if (batchSize !== undefined) {
             var leftItems = fetchState.buffer.slice(batchSize);
-            progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, undefined, undefined, leftItems, undefined, undefined), batchSize);
+            progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, undefined, leftItems, undefined, undefined), batchSize);
           } else {
             progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, chainBeforeBatch.fetchState, 0);
           }

package/src/ChainFetcher.res

@@ -202,27 +202,29 @@ let make = (
   let sources = switch chainConfig.sourceConfig {
   | Config.EvmSourceConfig({hypersync, rpcs}) =>
     // Build Internal.evmContractConfig from contracts for EvmChain.makeSources
-    let evmContracts: array<Internal.evmContractConfig> =
-      chainConfig.contracts->Array.map((contract): Internal.evmContractConfig => {
-        name: contract.name,
-        abi: contract.abi,
-        events: contract.events->(
-          Utils.magic: array<Internal.eventConfig> => array<Internal.evmEventConfig>
-        ),
-      })
+    let evmContracts: array<Internal.evmContractConfig> = chainConfig.contracts->Array.map((
+      contract
+    ): Internal.evmContractConfig => {
+      name: contract.name,
+      abi: contract.abi,
+      events: contract.events->(
+        Utils.magic: array<Internal.eventConfig> => array<Internal.evmEventConfig>
+      ),
+    })
     // Collect all event signatures from contracts
     let allEventSignatures =
       chainConfig.contracts->Array.flatMap(contract => contract.eventSignatures)
     // Convert rpcs to EvmChain.rpc format
-    let evmRpcs: array<EvmChain.rpc> =
-      rpcs->Array.map((rpc): EvmChain.rpc => {
-        let syncConfig = rpc.syncConfig
-        {
-          url: rpc.url,
-          sourceFor: rpc.sourceFor,
-          ?syncConfig,
-        }
-      })
+    let evmRpcs: array<EvmChain.rpc> = rpcs->Array.map((rpc): EvmChain.rpc => {
+      let syncConfig = rpc.syncConfig
+      let ws = rpc.ws
+      {
+        url: rpc.url,
+        sourceFor: rpc.sourceFor,
+        ?syncConfig,
+        ?ws,
+      }
+    })
     EvmChain.makeSources(
       ~chain,
       ~contracts=evmContracts,
@@ -264,7 +266,13 @@ let make = (
   }
 }
 
-let makeFromConfig = (chainConfig: Config.chain, ~config, ~registrations, ~targetBufferSize) => {
+let makeFromConfig = (
+  chainConfig: Config.chain,
+  ~config,
+  ~registrations,
+  ~targetBufferSize,
+  ~knownHeight,
+) => {
   let logger = Logging.createChild(~params={"chainId": chainConfig.id})
 
   make(
@@ -284,6 +292,7 @@ let makeFromConfig = (chainConfig: Config.chain, ~config, ~registrations, ~targe
     ~logger,
     ~dynamicContracts=[],
     ~isInReorgThreshold=false,
+    ~knownHeight,
   )
 }
 
@@ -446,12 +455,12 @@ let handleQueryResult = (
   | _ => chainFetcher.fetchState->FetchState.registerDynamicContracts(newItemsWithDcs)
   }
 
-  fs
-  ->FetchState.handleQueryResult(~query, ~latestFetchedBlock, ~newItems)
-  ->Result.map(fs => {
+  {
     ...chainFetcher,
-    fetchState: fs->FetchState.updateKnownHeight(~knownHeight),
-  })
+    fetchState: fs
+    ->FetchState.handleQueryResult(~query, ~latestFetchedBlock, ~newItems)
+    ->FetchState.updateKnownHeight(~knownHeight),
+  }
 }
 
 /**

package/src/ChainFetcher.res.mjs

@@ -13,7 +13,6 @@ import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as FetchState from "./FetchState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as Belt_Result from "rescript/lib/es6/belt_Result.js";
 import * as Caml_option from "rescript/lib/es6/caml_option.js";
 import * as EventRouter from "./sources/EventRouter.res.mjs";
 import * as UserContext from "./UserContext.res.mjs";
@@ -125,10 +124,12 @@ function make(chainConfig, dynamicContracts, startBlock, endBlock, firstEventBlo
               }));
         var evmRpcs = Belt_Array.map(sources.rpcs, (function (rpc) {
                 var syncConfig = rpc.syncConfig;
+                var ws = rpc.ws;
                 return {
                         url: rpc.url,
                         sourceFor: rpc.sourceFor,
-                        syncConfig: syncConfig
+                        syncConfig: syncConfig,
+                        ws: ws
                       };
               }));
         sources$1 = EvmChain.makeSources(chain, evmContracts, sources.hypersync, allEventSignatures, evmRpcs, lowercaseAddresses);
@@ -163,11 +164,11 @@ function make(chainConfig, dynamicContracts, startBlock, endBlock, firstEventBlo
         };
 }
 
-function makeFromConfig(chainConfig, config, registrations, targetBufferSize) {
+function makeFromConfig(chainConfig, config, registrations, targetBufferSize, knownHeight) {
   var logger = Logging.createChild({
         chainId: chainConfig.id
       });
-  return make(chainConfig, [], chainConfig.startBlock, chainConfig.endBlock, undefined, -1, config, registrations, targetBufferSize, logger, undefined, 0, 0, false, [], chainConfig.maxReorgDepth, undefined);
+  return make(chainConfig, [], chainConfig.startBlock, chainConfig.endBlock, undefined, -1, config, registrations, targetBufferSize, logger, undefined, 0, 0, false, [], chainConfig.maxReorgDepth, knownHeight);
 }
 
 async function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInReorgThreshold, config, registrations, targetBufferSize) {
@@ -254,22 +255,20 @@ async function runContractRegistersOrThrow(itemsWithContractRegister, chain, con
 
 function handleQueryResult(chainFetcher, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight) {
   var fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(chainFetcher.fetchState, newItemsWithDcs) : chainFetcher.fetchState;
-  return Belt_Result.map(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), (function (fs) {
-                return {
-                        logger: chainFetcher.logger,
-                        fetchState: FetchState.updateKnownHeight(fs, knownHeight),
-                        sourceManager: chainFetcher.sourceManager,
-                        chainConfig: chainFetcher.chainConfig,
-                        isProgressAtHead: chainFetcher.isProgressAtHead,
-                        timestampCaughtUpToHeadOrEndblock: chainFetcher.timestampCaughtUpToHeadOrEndblock,
-                        committedProgressBlockNumber: chainFetcher.committedProgressBlockNumber,
-                        firstEventBlockNumber: chainFetcher.firstEventBlockNumber,
-                        numEventsProcessed: chainFetcher.numEventsProcessed,
-                        numBatchesFetched: chainFetcher.numBatchesFetched,
-                        reorgDetection: chainFetcher.reorgDetection,
-                        safeCheckpointTracking: chainFetcher.safeCheckpointTracking
-                      };
-              }));
+  return {
+          logger: chainFetcher.logger,
+          fetchState: FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight),
+          sourceManager: chainFetcher.sourceManager,
+          chainConfig: chainFetcher.chainConfig,
+          isProgressAtHead: chainFetcher.isProgressAtHead,
+          timestampCaughtUpToHeadOrEndblock: chainFetcher.timestampCaughtUpToHeadOrEndblock,
+          committedProgressBlockNumber: chainFetcher.committedProgressBlockNumber,
+          firstEventBlockNumber: chainFetcher.firstEventBlockNumber,
+          numEventsProcessed: chainFetcher.numEventsProcessed,
+          numBatchesFetched: chainFetcher.numBatchesFetched,
+          reorgDetection: chainFetcher.reorgDetection,
+          safeCheckpointTracking: chainFetcher.safeCheckpointTracking
+        };
 }
 
 function hasProcessedToEndblock(self) {

package/src/ChainManager.res

@@ -16,29 +16,17 @@ let isProgressInReorgThreshold = (~progressBlockNumber, ~sourceBlockNumber, ~max
   progressBlockNumber > sourceBlockNumber - maxReorgDepth
 }
 
-let calculateTargetBufferSize = (~activeChainsCount, ~config: Config.t) => {
-  let targetBatchesInBuffer = 3
+let calculateTargetBufferSize = (~activeChainsCount) => {
   switch Env.targetBufferSize {
   | Some(size) => size
   | None =>
-    config.batchSize * (activeChainsCount > targetBatchesInBuffer ? 1 : targetBatchesInBuffer)
-  }
-}
-
-let makeFromConfig = (~config: Config.t, ~registrations): t => {
-  let targetBufferSize = calculateTargetBufferSize(
-    ~activeChainsCount=config.chainMap->ChainMap.size,
-    ~config,
-  )
-  let chainFetchers =
-    config.chainMap->ChainMap.map(
-      ChainFetcher.makeFromConfig(_, ~config, ~registrations, ~targetBufferSize),
-    )
-  {
-    committedCheckpointId: 0.,
-    chainFetchers,
-    multichain: config.multichain,
-    isInReorgThreshold: false,
+    switch activeChainsCount {
+    | 1 => 50_000
+    | 2 => 30_000
+    | 3 => 20_000
+    | 4 => 15_000
+    | _ => 10_000
+    }
   }
 }
 
@@ -62,7 +50,6 @@ let makeFromDbState = async (
 
   let targetBufferSize = calculateTargetBufferSize(
     ~activeChainsCount=initialState.chains->Array.length,
-    ~config,
   )
   Prometheus.ProcessingMaxBatchSize.set(~maxBatchSize=config.batchSize)
   Prometheus.IndexingTargetBufferSize.set(~targetBufferSize)

package/src/ChainManager.res.mjs

@@ -18,32 +18,29 @@ function isProgressInReorgThreshold(progressBlockNumber, sourceBlockNumber, maxR
   }
 }
 
-function calculateTargetBufferSize(activeChainsCount, config) {
+function calculateTargetBufferSize(activeChainsCount) {
   if (Env.targetBufferSize !== undefined) {
     return Env.targetBufferSize;
-  } else {
-    return Math.imul(config.batchSize, activeChainsCount > 3 ? 1 : 3);
   }
-}
-
-function makeFromConfig(config, registrations) {
-  var targetBufferSize = calculateTargetBufferSize(ChainMap.size(config.chainMap), config);
-  var chainFetchers = ChainMap.map(config.chainMap, (function (__x) {
-          return ChainFetcher.makeFromConfig(__x, config, registrations, targetBufferSize);
-        }));
-  return {
-          committedCheckpointId: 0,
-          chainFetchers: chainFetchers,
-          multichain: config.multichain,
-          isInReorgThreshold: false
-        };
+  switch (activeChainsCount) {
+    case 1 :
+        return 50000;
+    case 2 :
+        return 30000;
+    case 3 :
+        return 20000;
+    case 4 :
+        return 15000;
+    default:
+      return 10000;
+  }
 }
 
 async function makeFromDbState(initialState, config, registrations) {
   var isInReorgThreshold = initialState.cleanRun ? false : Belt_Array.some(initialState.chains, (function (chain) {
             return isProgressInReorgThreshold(chain.progressBlockNumber, chain.sourceBlockNumber, chain.maxReorgDepth);
           }));
-  var targetBufferSize = calculateTargetBufferSize(initialState.chains.length, config);
+  var targetBufferSize = calculateTargetBufferSize(initialState.chains.length);
   Prometheus.ProcessingMaxBatchSize.set(config.batchSize);
   Prometheus.IndexingTargetBufferSize.set(targetBufferSize);
   Prometheus.ReorgThreshold.set(isInReorgThreshold);
@@ -137,7 +134,6 @@ function getSafeCheckpointId(chainManager) {
 export {
   isProgressInReorgThreshold ,
   calculateTargetBufferSize ,
-  makeFromConfig ,
   makeFromDbState ,
   getChainFetcher ,
   setChainFetcher ,

package/src/Config.res

@@ -8,6 +8,7 @@ type sourceSyncOptions = {
   backoffMillis?: int,
   queryTimeoutMillis?: int,
   fallbackStallTimeout?: int,
+  pollingInterval?: int,
 }
 
 type contract = {
@@ -38,6 +39,7 @@ type evmRpcConfig = {
   url: string,
   sourceFor: Source.sourceFor,
   syncConfig: option<sourceSyncOptions>,
+  ws: option<string>,
 }
 
 type sourceConfig =
@@ -65,6 +67,7 @@ type sourceSync = {
   backoffMillis: int,
   queryTimeoutMillis: int,
   fallbackStallTimeout: int,
+  pollingInterval: int,
 }
 
 type multichain = | @as("ordered") Ordered | @as("unordered") Unordered
@@ -102,6 +105,7 @@ let rpcConfigSchema = S.schema(s =>
   {
     "url": s.matches(S.string),
     "for": s.matches(rpcSourceForSchema),
+    "ws": s.matches(S.option(S.string)),
     "initialBlockInterval": s.matches(S.option(S.int)),
     "backoffMultiplicative": s.matches(S.option(S.float)),
     "accelerationAdditive": s.matches(S.option(S.int)),
@@ -109,6 +113,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 +328,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 +336,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 +347,7 @@ let fromPublic = (
                 ?backoffMillis,
                 ?queryTimeoutMillis,
                 ?fallbackStallTimeout,
+                ?pollingInterval,
               })
             } else {
               None
@@ -348,6 +356,7 @@ let fromPublic = (
               url: rpcConfig["url"],
               sourceFor: parseRpcSourceFor(rpcConfig["for"]),
               syncConfig,
+              ws: rpcConfig["ws"],
             }
           })
         EvmSourceConfig({hypersync: publicChainConfig["hypersync"], rpcs})

package/src/Config.res.mjs

@@ -24,13 +24,15 @@ var rpcConfigSchema = S$RescriptSchema.schema(function (s) {
       return {
               url: s.m(S$RescriptSchema.string),
               for: s.m(rpcSourceForSchema),
+              ws: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
               initialBlockInterval: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
               backoffMultiplicative: s.m(S$RescriptSchema.option(S$RescriptSchema.$$float)),
               accelerationAdditive: s.m(S$RescriptSchema.option(S$RescriptSchema.$$int)),
               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 +237,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,12 +246,14 @@ function fromPublic(publicConfigJson, codegenChainsOpt, maxAddrInPartitionOpt, u
                             intervalCeiling: intervalCeiling,
                             backoffMillis: backoffMillis,
                             queryTimeoutMillis: queryTimeoutMillis,
-                            fallbackStallTimeout: fallbackStallTimeout
+                            fallbackStallTimeout: fallbackStallTimeout,
+                            pollingInterval: pollingInterval
                           }) : undefined;
                       return {
                               url: rpcConfig.url,
                               sourceFor: parseRpcSourceFor(rpcConfig.for),
-                              syncConfig: syncConfig
+                              syncConfig: syncConfig,
+                              ws: rpcConfig.ws
                             };
                     }));
               sourceConfig = {