fix: authority-claimer polling interval

cmd/authority-claimer/src/config.rs

@@ -50,6 +50,7 @@ pub struct Config {
     pub tx_manager_priority: Priority,
     pub log_config: LogConfig,
     pub postgres_endpoint: String,
+    pub polling_interval: u64,
     pub genesis_block: u64,
     pub http_server_port: u16,
 }
@@ -86,12 +87,15 @@ impl Config {
 
         let postgres_endpoint = cli_config.postgres_endpoint;
 
+        let polling_interval = cli_config.polling_interval;
+
         Ok(Config {
             tx_manager_config,
             tx_signing_config,
             tx_manager_priority: Priority::Normal,
             log_config,
             postgres_endpoint,
+            polling_interval,
             genesis_block: cli_config.genesis_block,
             http_server_port: cli_config.http_server_port,
         })
@@ -115,6 +119,10 @@ struct AuthorityClaimerCLI {
     #[arg(long, env)]
     pub postgres_endpoint: String,
 
+    /// Dtatabase polling interval
+    #[arg(long, env, default_value_t = 7)]
+    pub polling_interval: u64,
+
     /// Genesis block for reading blockchain events
     #[arg(long, env, default_value_t = 1)]
     pub genesis_block: u64,

cmd/authority-claimer/src/lib.rs

@@ -35,7 +35,10 @@ pub async fn run(config: Config) -> Result<(), Box<dyn Error>> {
 
     // Creating repository.
     trace!("Creating the repository");
-    let repository = DefaultRepository::new(config.postgres_endpoint)?;
+    let repository = DefaultRepository::new(
+        config.postgres_endpoint,
+        config.polling_interval,
+    )?;
 
     // Creating the conditional signer.
     let conditional_signer =

cmd/authority-claimer/src/repository.rs

@@ -12,6 +12,7 @@ use sqlx::{
 };
 use std::sync::Arc;
 use std::{fmt::Debug, time::Duration};
+use tokio::time::sleep;
 
 use crate::rollups_events::{Address, Hash, RollupsClaim};
 
@@ -49,11 +50,16 @@ pub enum RepositoryError {
 pub struct DefaultRepository {
     // Connection is not thread-safe, we use a connection pool
     db_pool: Arc<Pool<Postgres>>,
+    // Polling interval in seconds
+    polling_interval: u64,
 }
 
 impl DefaultRepository {
     /// Create database connection pool, wait until database server is available
-    pub fn new(endpoint: String) -> Result<Self, RepositoryError> {
+    pub fn new(
+        endpoint: String,
+        polling_interval: u64,
+    ) -> Result<Self, RepositoryError> {
         let connection = PgPoolOptions::new()
             .acquire_timeout(REPOSITORY_ACQUIRE_TIMEOUT)
             .min_connections(REPOSITORY_MIN_CONNECTIONS)
@@ -62,6 +68,7 @@ impl DefaultRepository {
             .context(DatabaseSqlxSnafu)?;
         Ok(Self {
             db_pool: Arc::new(connection),
+            polling_interval,
         })
     }
 
@@ -132,7 +139,10 @@ impl Repository for DefaultRepository {
                     );
                     break;
                 }
-                None => continue,
+                None => {
+                    sleep(Duration::from_secs(self.polling_interval)).await;
+                    continue;
+                }
             }
         }
 

internal/config/config.go

@@ -38,6 +38,7 @@ type NodeConfig struct {
 	Auth                                   Auth
 	AdvancerPollingInterval                Duration
 	ValidatorPollingInterval               Duration
+	ClaimerPollingInterval                 Duration
 	// Temporary
 	MachineServerVerbosity cartesimachine.ServerVerbosity
 }
@@ -99,6 +100,7 @@ func FromEnv() NodeConfig {
 	}
 	config.AdvancerPollingInterval = GetAdvancerPollingInterval()
 	config.ValidatorPollingInterval = GetValidatorPollingInterval()
+	config.ClaimerPollingInterval = GetClaimerPollingInterval()
 	// Temporary.
 	config.MachineServerVerbosity = cartesimachine.ServerVerbosity(GetMachineServerVerbosity())
 	return config

internal/config/generate/Config.toml

@@ -68,6 +68,12 @@ go-type = "Duration"
 description = """
 How many seconds the node will wait before trying to finish epochs for all applications."""
 
+[rollups.CARTESI_CLAIMER_POLLING_INTERVAL]
+default = "7"
+go-type = "Duration"
+description = """
+How many seconds the node will wait before querying the database for new claims."""
+
 #
 # Blockchain
 #

internal/node/services.go

@@ -63,6 +63,7 @@ func newAuthorityClaimer(c config.NodeConfig, workDir string) services.Service {
 		c.BlockchainFinalityOffset))
 	s.Env = append(s.Env, fmt.Sprintf("POSTGRES_ENDPOINT=%v",
 		fmt.Sprintf("%v", c.PostgresEndpoint.Value)))
+	s.Env = append(s.Env, fmt.Sprintf("POLLING_INTERVAL=%v", c.ClaimerPollingInterval.Seconds()))
 	s.Env = append(s.Env, fmt.Sprintf("INPUT_BOX_ADDRESS=%v", c.ContractsInputBoxAddress))
 	s.Env = append(s.Env, fmt.Sprintf("GENESIS_BLOCK=%v",
 		c.ContractsInputBoxDeploymentBlockNumber))