feat: add poll interval arg

bin/silius/src/cli/args.rs

@@ -1,5 +1,5 @@
 use crate::utils::{
-    parse_address, parse_enr, parse_send_bundle_mode, parse_u256, parse_uopool_mode,
+    parse_address, parse_duration, parse_enr, parse_send_bundle_mode, parse_u256, parse_uopool_mode,
 };
 use clap::{Parser, ValueEnum};
 use discv5::Enr;
@@ -19,6 +19,7 @@ use silius_primitives::{
 use std::{
     net::{IpAddr, Ipv4Addr},
     path::PathBuf,
+    time::Duration,
 };
 
 #[derive(ValueEnum, Debug, Clone)]
@@ -111,7 +112,7 @@ pub struct UoPoolArgs {
 }
 
 /// Common CLI args for bundler and uopool
-#[derive(Debug, Clone, Parser)]
+#[derive(Debug, Clone, Parser, PartialEq)]
 pub struct BundlerAndUoPoolArgs {
     /// Ethereum execution client RPC endpoint.
     #[clap(long, default_value = "http://127.0.0.1:8545")]
@@ -124,6 +125,10 @@ pub struct BundlerAndUoPoolArgs {
     /// Entry point addresses.
     #[clap(long, value_delimiter=',', value_parser=parse_address)]
     pub entry_points: Vec<Address>,
+
+    /// Poll interval event filters and pending transactions in milliseconds.
+    #[clap(long, default_value = "500", value_parser= parse_duration)]
+    pub poll_interval: Duration,
 }
 
 /// RPC CLI args
@@ -328,6 +333,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn bundler_and_uopool_args() {
+        let args = vec![
+            "bundleranduopoolargs",
+            "--eth-client-address",
+            "http://127.0.0.1:8545",
+            "--entry-points",
+            "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+            "--poll-interval",
+            "5000",
+        ];
+        assert_eq!(
+            BundlerAndUoPoolArgs {
+                eth_client_address: String::from("http://127.0.0.1:8545"),
+                chain: None,
+                entry_points: vec![
+                    Address::from_str("0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990").unwrap()
+                ],
+                poll_interval: Duration::from_millis(5000),
+            },
+            BundlerAndUoPoolArgs::try_parse_from(args).unwrap()
+        );
+    }
+
     #[test]
     fn rpc_args_when_http_and_ws_flag() {
         let args = vec![

bin/silius/src/cli/commands.rs

@@ -30,7 +30,10 @@ impl NodeCommand {
     /// Execute the command
     pub async fn execute(self) -> eyre::Result<()> {
         if self.common.eth_client_address.clone().starts_with("http") {
-            let eth_client = Arc::new(create_http_provider(&self.common.eth_client_address).await?);
+            let eth_client = Arc::new(
+                create_http_provider(&self.common.eth_client_address, self.common.poll_interval)
+                    .await?,
+            );
             let block_streams =
                 create_http_block_streams(eth_client.clone(), self.common.entry_points.len()).await;
             launch_bundler(
@@ -81,7 +84,10 @@ impl BundlerCommand {
     /// Execute the command
     pub async fn execute(self) -> eyre::Result<()> {
         if self.common.eth_client_address.clone().starts_with("http") {
-            let eth_client = Arc::new(create_http_provider(&self.common.eth_client_address).await?);
+            let eth_client = Arc::new(
+                create_http_provider(&self.common.eth_client_address, self.common.poll_interval)
+                    .await?,
+            );
             launch_bundling(
                 self.bundler,
                 eth_client,
@@ -122,7 +128,10 @@ impl UoPoolCommand {
     /// Execute the command
     pub async fn execute(self) -> eyre::Result<()> {
         if self.common.eth_client_address.clone().starts_with("http") {
-            let eth_client = Arc::new(create_http_provider(&self.common.eth_client_address).await?);
+            let eth_client = Arc::new(
+                create_http_provider(&self.common.eth_client_address, self.common.poll_interval)
+                    .await?,
+            );
             let block_streams =
                 create_http_block_streams(eth_client.clone(), self.common.entry_points.len()).await;
             launch_uopool(

bin/silius/src/utils.rs

@@ -4,7 +4,7 @@ use ethers::types::{Address, U256};
 use expanded_pathbuf::ExpandedPathBuf;
 use pin_utils::pin_mut;
 use silius_primitives::{bundler::SendStrategy, UoPoolMode};
-use std::{future::Future, str::FromStr};
+use std::{future::Future, str::FromStr, time::Duration};
 use tracing::info;
 
 /// Unwrap path or returns home directory
@@ -44,6 +44,11 @@ pub fn parse_enr(enr: &str) -> Result<Enr, String> {
     Enr::from_str(enr).map_err(|_| format!("Enr {enr} is not a valid enr."))
 }
 
+pub fn parse_duration(duration: &str) -> Result<Duration, String> {
+    let seconds: u64 = duration.parse().map_err(|_| format!("{duration} must be unsigned int"))?;
+    Ok(Duration::from_millis(seconds))
+}
+
 /// Runs the future to completion or until:
 /// - `ctrl-c` is received.
 /// - `SIGTERM` is received (unix only).

bundler-spec-tests/launcher.sh

@@ -24,7 +24,8 @@ case $1 in
         --ws \
         --ws.addr 0.0.0.0 \
         --ws.port 3001 \
-        --ws.api eth,debug,web3 & echo $! > bundler.pid
+        --ws.api eth,debug,web3 \
+        --poll-interval 5 & echo $! > bundler.pid
     popd
     cd @account-abstraction && yarn deploy --network localhost
 	;;

crates/primitives/src/provider.rs

@@ -3,24 +3,21 @@
 use async_stream::stream;
 use ethers::{
     providers::{Http, Middleware, Provider, Ws},
-    types::{Chain, H256},
+    types::H256,
 };
 use futures_util::{Stream, StreamExt};
 use std::{pin::Pin, sync::Arc, time::Duration};
 
 pub type BlockStream = Pin<Box<dyn Stream<Item = eyre::Result<H256>> + Send>>;
 
 /// Creates ethers provider with HTTP connection
-pub async fn create_http_provider(addr: &str) -> eyre::Result<Provider<Http>> {
+pub async fn create_http_provider(
+    addr: &str,
+    poll_interval: Duration,
+) -> eyre::Result<Provider<Http>> {
     let provider = Provider::<Http>::try_from(addr)?;
 
-    let chain_id = provider.get_chainid().await?;
-
-    Ok(provider.interval(if chain_id == Chain::Dev.into() {
-        Duration::from_millis(5u64)
-    } else {
-        Duration::from_millis(500u64)
-    }))
+    Ok(provider.interval(poll_interval))
 }
 
 /// Creates ethers provider with WebSockets connection

examples/storage/examples/database.rs

@@ -21,6 +21,7 @@ use std::{
     env,
     str::FromStr,
     sync::Arc,
+    time::Duration,
 };
 use tempdir::TempDir;
 
@@ -34,7 +35,8 @@ async fn main() -> eyre::Result<()> {
         env.create_tables().expect("Create mdbx database tables failed");
         println!("Database uopool created!");
 
-        let provider = Arc::new(create_http_provider(provider_url.as_str()).await?);
+        let provider =
+            Arc::new(create_http_provider(provider_url.as_str(), Duration::from_secs(1)).await?);
         let ep = Address::from_str(ADDRESS)?;
         let chain = Chain::dev();
         let entry_point = EntryPoint::new(provider.clone(), ep);

examples/storage/examples/memory.rs

@@ -20,13 +20,15 @@ use std::{
     env,
     str::FromStr,
     sync::Arc,
+    time::Duration,
 };
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {
     //  uopool needs connection to the execution client
     if let Ok(provider_url) = env::var("PROVIDER_URL") {
-        let provider = Arc::new(create_http_provider(provider_url.as_str()).await?);
+        let provider =
+            Arc::new(create_http_provider(provider_url.as_str(), Duration::from_secs(1)).await?);
         let ep = Address::from_str(ADDRESS)?;
         let chain = Chain::dev();
         let entry_point = EntryPoint::new(provider.clone(), ep);