cleanup

Author: sergeytimoshin

forester/src/compressible/bootstrap_helpers.rs

@@ -393,16 +393,17 @@ where
 {
     info!("Starting bootstrap of {} accounts", label);
 
-    // Set up shutdown flag
+    // Set up shutdown flag and listener task
     let shutdown_flag = Arc::new(AtomicBool::new(false));
 
-    if let Some(rx) = shutdown_rx {
+    // Spawn shutdown listener and keep handle for cleanup
+    let shutdown_listener_handle = shutdown_rx.map(|rx| {
         let shutdown_flag_clone = shutdown_flag.clone();
         tokio::spawn(async move {
             let _ = rx.await;
             shutdown_flag_clone.store(true, Ordering::SeqCst);
-        });
-    }
+        })
+    });
 
     let client = reqwest::Client::new();
 
@@ -413,15 +414,22 @@ where
 
     let result = if is_localhost(rpc_url) {
         debug!("Detected localhost, using standard getProgramAccounts");
-        let (fetched, inserted) = bootstrap_standard_api(
+        let api_result = bootstrap_standard_api(
             &client,
             rpc_url,
             program_id,
             filters,
             Some(&shutdown_flag),
             process_fn,
         )
-        .await?;
+        .await;
+
+        // Abort shutdown listener before returning (success or error)
+        if let Some(handle) = shutdown_listener_handle {
+            handle.abort();
+        }
+
+        let (fetched, inserted) = api_result?;
 
         info!(
             "{} bootstrap complete: {} fetched, {} inserted",
@@ -435,15 +443,22 @@ where
         }
     } else {
         debug!("Using getProgramAccountsV2 with pagination");
-        let (pages, fetched, inserted) = bootstrap_v2_api(
+        let api_result = bootstrap_v2_api(
             &client,
             rpc_url,
             program_id,
             filters,
             Some(&shutdown_flag),
             process_fn,
         )
-        .await?;
+        .await;
+
+        // Abort shutdown listener before returning (success or error)
+        if let Some(handle) = shutdown_listener_handle {
+            handle.abort();
+        }
+
+        let (pages, fetched, inserted) = api_result?;
 
         info!(
             "{} bootstrap complete: {} pages, {} fetched, {} inserted",

forester/src/compressible/mint/compressor.rs

@@ -159,14 +159,14 @@ impl<R: Rpc + Indexer> MintCompressor<R> {
                     "Batched CompressAndCloseMint tx (chunk {}) confirmed: {}",
                     chunk_idx, signature
                 );
+                // Only return confirmed signatures to callers
+                signatures.push(signature);
             } else {
                 tracing::warn!(
                     "CompressAndCloseMint tx not confirmed: {} - accounts kept in tracker for retry",
                     signature
                 );
             }
-
-            signatures.push(signature);
         }
 
         Ok(signatures)

forester/src/compressible/pda/compressor.rs

@@ -3,7 +3,6 @@ use std::sync::{
     Arc,
 };
 
-use borsh::BorshDeserialize;
 use forester_utils::rpc_pool::SolanaRpcPool;
 use futures::StreamExt;
 use light_client::{
@@ -81,7 +80,7 @@ impl<R: Rpc + Indexer> PdaCompressor<R> {
         // Get the compressible config PDA for this program (config_bump = 0)
         let (config_pda, _) = LightConfig::derive_pda(program_id, 0);
 
-        // Fetch the config to get rent_sponsor and address_space
+        // Fetch the config account
         let rpc = self.rpc_pool.get_connection().await?;
         let config_account = rpc
             .get_account(config_pda)
@@ -91,38 +90,22 @@ impl<R: Rpc + Indexer> PdaCompressor<R> {
                 anyhow::anyhow!("Config account not found for program {}", program_id)
             })?;
 
-        // Verify account owner matches program_id (mirrors LightConfig::load_checked)
-        if config_account.owner != *program_id {
-            return Err(anyhow::anyhow!(
-                "Config account owner mismatch. Expected: {}. Found: {}",
-                program_id,
-                config_account.owner
-            ));
-        }
-
-        // Deserialize config
-        let config = LightConfig::try_from_slice(&config_account.data)
-            .map_err(|e| anyhow::anyhow!("Failed to deserialize config: {:?}", e))?;
-
-        // Validate config (checks config_bump == 0 and other constraints)
-        config.validate().map_err(|e| {
+        // Load and validate config using SDK validator
+        // This checks: owner == program_id, config_bump == 0, PDA derivation, and other constraints
+        let config = LightConfig::load_checked_client(
+            &config_account.data,
+            &config_account.owner,
+            &config_pda,
+            program_id,
+        )
+        .map_err(|e| {
             anyhow::anyhow!(
-                "LightConfig validation failed for program {}: {:?}",
+                "LightConfig validation failed for program {}: {}",
                 program_id,
                 e
             )
         })?;
 
-        // Verify PDA derivation matches (mirrors LightConfig::load_checked)
-        let (expected_pda, _) = LightConfig::derive_pda(program_id, config.config_bump);
-        if expected_pda != config_pda {
-            return Err(anyhow::anyhow!(
-                "Config PDA derivation mismatch. Expected: {}. Found: {}",
-                expected_pda,
-                config_pda
-            ));
-        }
-
         let rent_sponsor = config.rent_sponsor;
         let compression_authority = config.compression_authority;
         let address_tree = *config

forester/tests/test_compressible_ctoken.rs

@@ -529,7 +529,7 @@ async fn run_bootstrap_test(
             let account_state = accounts
                 .iter()
                 .find(|acc| acc.pubkey == *pubkey)
-                .expect(&format!("Bootstrap should have found account {}", pubkey));
+                .unwrap_or_else(|| panic!("Bootstrap should have found account {}", pubkey));
 
             println!(
                 "Verifying account {}: mint={:?}, lamports={}",

program-libs/CLAUDE.md

@@ -63,6 +63,7 @@ Some crates depend on external Light Protocol crates not in program-libs:
 ## Testing
 
 Unit tests run with `cargo test`:
+
 ```bash
 cargo test -p light-hasher --all-features
 cargo test -p light-compressed-account --all-features

sdk-libs/sdk/src/interface/config.rs

@@ -145,6 +145,55 @@ impl LightConfig {
 
         Ok(config)
     }
+
+    /// Client-side version of load_checked for off-chain validation.
+    ///
+    /// Validates config account data fetched via RPC, checking owner and PDA derivation.
+    /// This mirrors the on-chain `load_checked` but works with client-side Account data.
+    ///
+    /// # Arguments
+    /// * `account_data` - The account data bytes from RPC
+    /// * `account_owner` - The owner pubkey of the fetched account
+    /// * `account_key` - The pubkey of the fetched account (config_pda)
+    /// * `program_id` - The program that should own the config
+    ///
+    /// # Returns
+    /// * `Ok(LightConfig)` if validation passes
+    /// * `Err(String)` with description if validation fails
+    pub fn load_checked_client(
+        account_data: &[u8],
+        account_owner: &Pubkey,
+        account_key: &Pubkey,
+        program_id: &Pubkey,
+    ) -> Result<Self, String> {
+        // CHECK: Owner matches program_id
+        if account_owner != program_id {
+            return Err(format!(
+                "Config account owner mismatch. Expected: {}. Found: {}",
+                program_id, account_owner
+            ));
+        }
+
+        // Deserialize config
+        let config = Self::try_from_slice(account_data)
+            .map_err(|err| format!("Failed to deserialize config data: {:?}", err))?;
+
+        // Validate config (checks version, address_space, config_bump)
+        config
+            .validate()
+            .map_err(|err| format!("Config validation failed: {:?}", err))?;
+
+        // CHECK: PDA derivation matches account key
+        let (expected_pda, _) = Self::derive_pda(program_id, config.config_bump);
+        if expected_pda != *account_key {
+            return Err(format!(
+                "Config PDA derivation mismatch. Expected: {}. Found: {}",
+                expected_pda, account_key
+            ));
+        }
+
+        Ok(config)
+    }
 }
 
 /// Creates a new compressible config PDA