fix(operator): configurable confirmation poll interval and permanent RPC error handling

Dockerfile

@@ -65,7 +65,8 @@ RUN touch contra-escrow-program/program/src/lib.rs contra-escrow-program/tests/i
     test_utils/src/lib.rs scripts/devnet/src/lib.rs \
     contra-escrow-program/clients/rust/src/lib.rs contra-withdraw-program/clients/rust/src/lib.rs \
     core/src/lib.rs metrics/src/lib.rs auth/src/lib.rs && \
-    printf 'fn main() {}\n' > bench-tps/src/main.rs
+    printf 'fn main() {}\n' > bench-tps/src/main.rs && \
+    printf 'fn main() {}\n' > auth/src/main.rs
 
 # Build the project with the dummy files. We can cache this layer.
 RUN cargo build --release

indexer/config/local/operator-contra.toml

@@ -20,8 +20,10 @@ type = "postgres"
 max_connections = 10
 
 [operator]
-poll_interval_secs = 5
+poll_interval_secs = 1
 batch_size = 10
 retry_max_attempts = 3
 retry_base_delay_secs = 1
 channel_buffer_size = 100
+# Solana block time is ~400 ms
+confirmation_poll_interval_ms = 400

indexer/config/local/operator-solana.toml

@@ -20,8 +20,11 @@ type = "postgres"
 max_connections = 10
 
 [operator]
-poll_interval_secs = 5
-batch_size = 10
+# Faster poll/batch settings suited to higher-throughput
+poll_interval_secs = 1
+batch_size = 100
 retry_max_attempts = 3
 retry_base_delay_secs = 1
-channel_buffer_size = 100
+channel_buffer_size = 1000
+# Contra block time is 100 ms so poll quickly
+confirmation_poll_interval_ms = 100

indexer/config/railway/operator-contra.toml

@@ -18,8 +18,10 @@ type = "postgres"
 max_connections = 10
 
 [operator]
-poll_interval_secs = 5
+poll_interval_secs = 1
 batch_size = 10
 retry_max_attempts = 3
 retry_base_delay_secs = 1
 channel_buffer_size = 100
+# Solana mainnet block time is ~400 ms
+confirmation_poll_interval_ms = 400

indexer/config/railway/operator-solana.toml

@@ -19,8 +19,10 @@ type = "postgres"
 max_connections = 10
 
 [operator]
-poll_interval_secs = 5
-batch_size = 10
+poll_interval_secs = 1
+batch_size = 100
 retry_max_attempts = 3
 retry_base_delay_secs = 1
-channel_buffer_size = 100
+channel_buffer_size = 1000
+# Contra block time is ~100 ms; poll faster than the 400 ms default
+confirmation_poll_interval_ms = 100

indexer/src/bin/indexer.rs

@@ -1,4 +1,5 @@
 use clap::{Parser, Subcommand};
+use contra_indexer::config::DEFAULT_CONFIRMATION_POLL_INTERVAL_MS;
 use contra_indexer::{
     BackfillConfig, ContraIndexerConfig, DatasourceType, IndexerConfig, OperatorConfig,
     PostgresConfig, ProgramType, ReconciliationConfig, RpcPollingConfig, StorageType,
@@ -96,6 +97,8 @@ struct OperatorSection {
     reconciliation_webhook_url: Option<String>,
     #[serde(default = "default_feepayer_monitor_interval_secs")]
     feepayer_monitor_interval_secs: u64,
+    #[serde(default = "default_confirmation_poll_interval_ms")]
+    confirmation_poll_interval_ms: u64,
 }
 
 fn default_reconciliation_interval_secs() -> u64 {
@@ -110,6 +113,10 @@ fn default_feepayer_monitor_interval_secs() -> u64 {
     60
 }
 
+fn default_confirmation_poll_interval_ms() -> u64 {
+    DEFAULT_CONFIRMATION_POLL_INTERVAL_MS
+}
+
 #[derive(Parser, Debug)]
 #[command(name = "contra-indexer", about = "Index data from Contra programs")]
 struct Args {
@@ -401,6 +408,7 @@ async fn run_operator(figment: Figment, verbose: bool) -> Result<(), Box<dyn std
         reconciliation_tolerance_bps: operator.reconciliation_tolerance_bps,
         reconciliation_webhook_url: operator.reconciliation_webhook_url,
         feepayer_monitor_interval: Duration::from_secs(operator.feepayer_monitor_interval_secs),
+        confirmation_poll_interval_ms: operator.confirmation_poll_interval_ms,
     };
 
     // Validate signer configuration early (from environment variables)

indexer/src/config.rs

@@ -270,8 +270,17 @@ pub struct OperatorConfig {
     /// How often to check the feepayer SOL balance (escrow operators only)
     #[serde(default = "default_feepayer_monitor_interval")]
     pub feepayer_monitor_interval: std::time::Duration,
+    /// Milliseconds between `getSignatureStatuses` polls when confirming a sent transaction.
+    /// Lower values reduce per-tx latency on Contra (~100 ms); higher values suit Solana
+    /// (~400 ms block time). Defaults to `DEFAULT_CONFIRMATION_POLL_INTERVAL_MS`.
+    #[serde(default = "default_confirmation_poll_interval_ms")]
+    pub confirmation_poll_interval_ms: u64,
 }
 
+/// Default poll interval for `confirmation_poll_interval_ms`, matching Solana's ~400 ms block time.
+/// operator-solana overrides this to 100 ms since Contra confirms faster.
+pub const DEFAULT_CONFIRMATION_POLL_INTERVAL_MS: u64 = 400;
+
 fn default_reconciliation_interval() -> std::time::Duration {
     std::time::Duration::from_secs(5 * 60) // 5 minutes
 }
@@ -284,6 +293,10 @@ fn default_feepayer_monitor_interval() -> std::time::Duration {
     std::time::Duration::from_secs(60)
 }
 
+fn default_confirmation_poll_interval_ms() -> u64 {
+    DEFAULT_CONFIRMATION_POLL_INTERVAL_MS
+}
+
 impl OperatorConfig {
     /// Validate that required signers are configured
     ///

indexer/src/operator/fetcher.rs

@@ -116,6 +116,7 @@ mod tests {
             reconciliation_tolerance_bps: 10,
             reconciliation_webhook_url: None,
             feepayer_monitor_interval: Duration::from_secs(60),
+            confirmation_poll_interval_ms: 400,
         }
     }
 

indexer/src/operator/operator.rs

@@ -115,6 +115,7 @@ pub async fn run(
             sender_token,
             sender_storage,
             config.retry_max_attempts,
+            config.confirmation_poll_interval_ms,
             sender_source_rpc,
         )
         .await

indexer/src/operator/reconciliation.rs

@@ -738,6 +738,7 @@ mod tests {
             reconciliation_tolerance_bps: 10,
             reconciliation_webhook_url: None,
             feepayer_monitor_interval: std::time::Duration::from_secs(60),
+            confirmation_poll_interval_ms: 400,
         }
     }
 

indexer/src/operator/sender/mint.rs

@@ -120,6 +120,7 @@ pub(super) async fn try_jit_mint_initialization(
         &sig,
         CommitmentConfig::confirmed(),
         &init_tx_builder.extra_error_checks_policy(),
+        state.confirmation_poll_interval_ms,
     )
     .await
     {

indexer/src/operator/sender/mod.rs

@@ -38,6 +38,7 @@ pub async fn run_sender(
     cancellation_token: tokio_util::sync::CancellationToken,
     storage: Arc<Storage>,
     retry_max_attempts: u32,
+    confirmation_poll_interval_ms: u64,
     source_rpc_client: Option<Arc<RpcClientWithRetry>>,
 ) -> Result<(), OperatorError> {
     info!("Starting sender");
@@ -53,6 +54,7 @@ pub async fn run_sender(
         instance_pda,
         storage,
         retry_max_attempts,
+        confirmation_poll_interval_ms,
         source_rpc_client,
     )?;
 
@@ -123,6 +125,7 @@ pub async fn run_sender(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::config::DEFAULT_CONFIRMATION_POLL_INTERVAL_MS;
     use crate::config::{PostgresConfig, ProgramType, StorageType};
     use crate::storage::common::storage::mock::MockStorage;
     use crate::ContraIndexerConfig;
@@ -168,6 +171,7 @@ mod tests {
             cancellation_token,
             storage,
             3,
+            DEFAULT_CONFIRMATION_POLL_INTERVAL_MS,
             None,
         )
         .await;
@@ -200,6 +204,7 @@ mod tests {
             cancellation_token,
             storage,
             3,
+            DEFAULT_CONFIRMATION_POLL_INTERVAL_MS,
             None,
         )
         .await;

indexer/src/operator/sender/proof.rs

@@ -229,6 +229,7 @@ mod tests {
             mint_builders: HashMap::new(),
             mint_cache: MintCache::new(storage),
             retry_max_attempts: 3,
+            confirmation_poll_interval_ms: 400,
             rotation_retry_queue: Vec::new(),
             pending_rotation: None,
             program_type: crate::config::ProgramType::Escrow,

indexer/src/operator/sender/remint.rs

@@ -94,6 +94,7 @@ async fn attempt_remint(
         &signature,
         CommitmentConfig::confirmed(),
         &ExtraErrorCheckPolicy::None,
+        state.confirmation_poll_interval_ms,
     )
     .await
     .map_err(|e| format!("Failed to confirm remint transaction: {}", e))?;
@@ -342,6 +343,7 @@ mod tests {
             mint_builders: HashMap::new(),
             mint_cache: MintCache::new(storage),
             retry_max_attempts: 3,
+            confirmation_poll_interval_ms: 400,
             rotation_retry_queue: Vec::new(),
             pending_rotation: None,
             program_type: crate::config::ProgramType::Escrow,
@@ -384,6 +386,7 @@ mod tests {
             mint_builders: HashMap::new(),
             mint_cache: MintCache::new(storage),
             retry_max_attempts: 3,
+            confirmation_poll_interval_ms: 400,
             rotation_retry_queue: Vec::new(),
             pending_rotation: None,
             program_type: crate::config::ProgramType::Escrow,

indexer/src/operator/sender/state.rs

@@ -29,6 +29,7 @@ impl SenderState {
         instance_pda: Option<Pubkey>,
         storage: Arc<Storage>,
         retry_max_attempts: u32,
+        confirmation_poll_interval_ms: u64,
         source_rpc_client: Option<Arc<RpcClientWithRetry>>,
     ) -> Result<Self, OperatorError> {
         // Initialize global RPC client with retry
@@ -52,6 +53,7 @@ impl SenderState {
             mint_cache,
             mint_builders: HashMap::new(),
             retry_max_attempts,
+            confirmation_poll_interval_ms,
             rotation_retry_queue: Vec::new(),
             pending_rotation: None,
             program_type: config.program_type,
@@ -349,6 +351,7 @@ mod tests {
             mint_builders: HashMap::new(),
             mint_cache: MintCache::new(storage),
             retry_max_attempts: 3,
+            confirmation_poll_interval_ms: 400,
             rotation_retry_queue: Vec::new(),
             pending_rotation: None,
             program_type: crate::config::ProgramType::Escrow,
@@ -801,6 +804,7 @@ mod tests {
             mint_builders: HashMap::new(),
             mint_cache: MintCache::new(storage),
             retry_max_attempts: 3,
+            confirmation_poll_interval_ms: 400,
             rotation_retry_queue: Vec::new(),
             pending_rotation: None,
             program_type: ProgramType::Escrow,
@@ -849,7 +853,15 @@ mod tests {
         let storage = Arc::new(Storage::Mock(mock));
         let config = make_config();
 
-        let result = SenderState::new(&config, CommitmentLevel::Confirmed, None, storage, 3, None);
+        let result = SenderState::new(
+            &config,
+            CommitmentLevel::Confirmed,
+            None,
+            storage,
+            3,
+            400,
+            None,
+        );
 
         assert!(result.is_ok());
         let state = result.unwrap();
@@ -874,6 +886,7 @@ mod tests {
             Some(instance_pda),
             storage,
             5,
+            400,
             None,
         );
 

indexer/src/operator/sender/transaction.rs

@@ -290,6 +290,7 @@ pub(super) async fn send_and_confirm(
                 &signature,
                 commitment_config,
                 extra_error_checks_policy,
+                state.confirmation_poll_interval_ms,
             )
             .await;
 
@@ -764,6 +765,7 @@ mod tests {
             mint_builders: HashMap::new(),
             mint_cache: MintCache::new(storage),
             retry_max_attempts: 3,
+            confirmation_poll_interval_ms: 400,
             rotation_retry_queue: Vec::new(),
             pending_rotation: None,
             program_type: ProgramType::Escrow,

indexer/src/operator/sender/types.rs

@@ -46,6 +46,8 @@ pub struct SenderState {
     pub mint_builders: HashMap<i64, MintToBuilder>,
     pub mint_cache: MintCache,
     pub retry_max_attempts: u32,
+    /// Milliseconds between `getSignatureStatuses` polls. Populated from `OperatorConfig`.
+    pub confirmation_poll_interval_ms: u64,
     pub rotation_retry_queue: Vec<(TransactionContext, ReleaseFundsBuilder)>,
     /// Pending ResetSmtRoot transaction waiting for in-flight txs to settle
     pub pending_rotation: Option<Box<ResetSmtRootBuilder>>,

indexer/src/operator/utils/rpc_util.rs

@@ -1,7 +1,9 @@
 use solana_client::nonblocking::rpc_client::RpcClient;
 use solana_client::rpc_client::GetConfirmedSignaturesForAddress2Config;
 use solana_rpc_client_api::client_error;
+use solana_rpc_client_api::client_error::ErrorKind;
 use solana_rpc_client_api::config::RpcTransactionConfig;
+use solana_rpc_client_api::request::RpcError;
 use solana_sdk::account::Account;
 use solana_sdk::commitment_config::CommitmentConfig;
 use solana_sdk::hash::Hash;
@@ -39,6 +41,18 @@ impl Default for RetryConfig {
     }
 }
 
+/// Returns `true` for errors that will never succeed on retry.
+///
+/// `-32601` (Method not found) is a permanent protocol-level rejection; retrying
+/// wastes the full backoff budget without any chance of recovery.
+// TODO: remove once the RPC endpoint implements all required methods.
+fn is_permanent_rpc_error(e: &client_error::Error) -> bool {
+    matches!(
+        e.kind(),
+        ErrorKind::RpcError(RpcError::RpcResponseError { code: -32601, .. })
+    )
+}
+
 pub struct RpcClientWithRetry {
     pub rpc_client: Arc<RpcClient>,
     pub retry_config: RetryConfig,
@@ -91,12 +105,15 @@ impl RpcClientWithRetry {
                     match f().await {
                         Ok(result) => return Ok(result),
                         Err(e) => {
-                            if attempts >= self.retry_config.max_attempts {
+                            let err: Box<client_error::Error> = e.into();
+                            if attempts >= self.retry_config.max_attempts
+                                || is_permanent_rpc_error(&err)
+                            {
                                 warn!(
                                     "{} failed after {} attempts: {}",
-                                    operation_name, attempts, e
+                                    operation_name, attempts, err
                                 );
-                                return Err(e.into());
+                                return Err(err);
                             }
 
                             let delay = self.retry_config.base_delay * 2_u32.pow(attempts - 1);