Add prune command to BandwidthController

common/bandwidth-controller/src/config.rs

@@ -10,6 +10,7 @@ use crate::ticketbooks::AvailableTicketbooks;
 #[derive(Debug, Clone)]
 pub struct BandwidthControllerConfig {
     // How often the controller proactively checks whether any ticket type needs restocking.
+    // It is also pruning any expired tickets from storage before restocking.
     pub topup_interval: Duration,
     // Threshold to determine if a ticket is soon expired
     pub soon_expiry_threshold: Duration,

common/bandwidth-controller/src/controller.rs

@@ -155,6 +155,7 @@ impl<St: Storage> BandwidthController<St> {
                     break;
                 }
                 _ = topup_interval.tick() => {
+                    self.prune_expired().await;
                     let _ = self.print_info().await;
                     self.check_and_restock(self.config.managed_ticket_types.clone()).await;
                 }
@@ -496,6 +497,15 @@ impl<St: Storage> BandwidthController<St> {
         self.prefetch_global_data().await;
     }
 
+    // Removes expired ticketbooks from storage and expired ticketbooks that are still in pending.
+    pub async fn prune_expired(&self) {
+        if let Err(err) = self.storage.cleanup_expired().await {
+            tracing::warn!("Could not cleanup expired ticketbooks: {err}");
+        } else {
+            tracing::debug!("Finished pruning of expired ticketbooks");
+        }
+    }
+
     /// Spawns a background fetch for `ticket_type` unless one is already in flight for it.
     /// Non-blocking: the result is drained later in the `run` loop via `on_fetch_complete`.
     fn ensure_stocked(&mut self, ticket_type: TicketType) {

common/bandwidth-fetcher/Cargo.toml

@@ -34,6 +34,9 @@ nym-validator-client = { workspace = true }
 sqlx = { workspace = true }
 nym-sqlx-pool-guard = { workspace = true }
 
+[dev-dependencies]
+serde = { workspace = true }
+
 [build-dependencies]
 anyhow = { workspace = true }
 sqlx = { workspace = true, features = [

common/bandwidth-fetcher/src/credentials.rs

@@ -185,6 +185,41 @@ where
 
         Ok(issuance_data.to_issued_ticketbook(wallet, epoch_id))
     }
+
+    async fn cancel_expired_ticketbooks(&self) -> Result<(), NyxdFetcherError> {
+        let mut pruned_pending_ticketbooks = 0;
+
+        for expired_pending_ticketbook_id in self
+            .pending_storage
+            .get_pending_ticketbooks()
+            .await?
+            .iter()
+            .filter_map(|ticket_book| {
+                if ticket_book.pending_ticketbook.expired() {
+                    Some(ticket_book.pending_id)
+                } else {
+                    None
+                }
+            })
+        {
+            if let Err(err) = self
+                .pending_storage
+                .remove_pending_ticketbook(expired_pending_ticketbook_id)
+                .await
+            {
+                tracing::warn!(
+                    "Failed to remove expired ticketbook id {expired_pending_ticketbook_id} from pending storage: {err}"
+                );
+            } else {
+                pruned_pending_ticketbooks += 1;
+            }
+        }
+        tracing::debug!(
+            "Cancelled {pruned_pending_ticketbooks} expired ticketbooks that were pending"
+        );
+
+        Ok(())
+    }
 }
 
 impl<C> NyxdCredentialFetcher<C>
@@ -317,6 +352,10 @@ where
         &self,
         ticketbook_type: TicketType,
     ) -> Result<Vec<NymCredential>, CredentialFetcherError> {
+        if let Err(err) = self.cancel_expired_ticketbooks().await {
+            tracing::warn!("Could not cancel expired ticketbooks: {err}");
+        }
+
         self.block_until_ecash_is_available().await?;
 
         if let Ok(recovered_ticketbooks) = self.recover_deposits(ticketbook_type).await {
@@ -436,6 +475,10 @@ pub(crate) mod recovery {
             &self,
             ticketbook_type: TicketType,
         ) -> Result<Vec<NymCredential>, CredentialFetcherError> {
+            if let Err(err) = self.0.cancel_expired_ticketbooks().await {
+                tracing::warn!("Could not cancel expired ticketbooks: {err}");
+            }
+
             self.0.block_until_ecash_is_available().await?;
 
             let recovered_ticketbooks = self.0.recover_deposits(ticketbook_type).await?;
@@ -460,3 +503,131 @@ pub(crate) mod recovery {
         }
     }
 }
+
+#[cfg(test)]
+#[allow(clippy::unreachable)]
+mod tests {
+    use std::env::temp_dir;
+
+    use serde::Deserialize;
+
+    use nym_validator_client::nyxd::{
+        Fee,
+        contract_traits::dkg_query_client::DkgQueryMsg,
+        cosmwasm_client::types::ExecuteResult,
+        error::NyxdError,
+        nym_ecash_contract_common::msg::{ExecuteMsg, QueryMsg},
+    };
+    use tokio::fs::remove_file;
+
+    use super::*;
+
+    struct MockPruneClient {}
+
+    #[async_trait]
+    impl DkgQueryClient for MockPruneClient {
+        async fn query_dkg_contract<T>(
+            &self,
+            _query: DkgQueryMsg,
+        ) -> std::result::Result<T, NyxdError>
+        where
+            for<'a> T: Deserialize<'a>,
+        {
+            unreachable!("client not used in prune unit tests");
+        }
+    }
+
+    #[async_trait]
+    impl EcashSigningClient for MockPruneClient {
+        async fn execute_ecash_contract(
+            &self,
+            _fee: Option<Fee>,
+            _msg: ExecuteMsg,
+            _memo: String,
+            _funds: Vec<Coin>,
+        ) -> Result<ExecuteResult, NyxdError> {
+            unreachable!("client not used in prune unit tests");
+        }
+    }
+
+    #[async_trait]
+    impl EcashQueryClient for MockPruneClient {
+        async fn query_ecash_contract<T>(&self, _query: QueryMsg) -> Result<T, NyxdError>
+        where
+            for<'a> T: Deserialize<'a>,
+        {
+            unreachable!("client not used in prune unit tests");
+        }
+    }
+
+    #[tokio::test]
+    async fn prune_expired() {
+        let mut db_path = temp_dir();
+        db_path.push("prune_expired_unittest.db");
+        let fetcher = NyxdCredentialFetcher::new(
+            Arc::new(MockPruneClient {}),
+            &db_path,
+            Zeroizing::new(Vec::new()),
+        )
+        .await
+        .unwrap();
+
+        // pruning empty database doesn't fail
+        fetcher.cancel_expired_ticketbooks().await.unwrap();
+
+        // insert late expiration ticketbook
+        let expired_ticketbook = IssuanceTicketBook::new_with_expiration(
+            0,
+            [],
+            ed25519::PrivateKey::new(&mut OsRng),
+            TicketType::V1WireguardEntry,
+            Date::MIN,
+        );
+        fetcher
+            .pending_storage
+            .insert_pending_ticketbook(&expired_ticketbook)
+            .await
+            .unwrap();
+
+        // check pruning emptied it
+        fetcher.cancel_expired_ticketbooks().await.unwrap();
+        assert_eq!(
+            fetcher
+                .pending_storage
+                .get_pending_ticketbooks()
+                .await
+                .unwrap()
+                .len(),
+            0
+        );
+
+        // insert late expiration ticketbook
+        let unexpired_ticketbook = IssuanceTicketBook::new_with_expiration(
+            0,
+            [],
+            ed25519::PrivateKey::new(&mut OsRng),
+            TicketType::V1WireguardEntry,
+            Date::MAX,
+        );
+        fetcher
+            .pending_storage
+            .insert_pending_ticketbook(&unexpired_ticketbook)
+            .await
+            .unwrap();
+
+        // check pruning doesn't affect it
+        fetcher.cancel_expired_ticketbooks().await.unwrap();
+        assert_ne!(
+            fetcher
+                .pending_storage
+                .get_pending_ticketbooks()
+                .await
+                .unwrap()
+                .len(),
+            0
+        );
+
+        fetcher.pending_storage.close().await;
+        remove_file(db_path).await.unwrap();
+    }
+}

sdk/rust/nym-sdk-session/tests/support/mod.rs

@@ -13,6 +13,7 @@
 
 pub mod fake_dkg;
 pub mod http_harness;
+pub mod prune;
 
 use nym_compact_ecash::scheme::keygen::{KeyPairAuth, SecretKeyAuth};
 use nym_compact_ecash::tests::helpers::{
@@ -77,11 +78,13 @@ impl TestEcash {
         }
     }
 
-    /// Fabricate a real threshold-signed ticketbook for `typ`. Distinct `seed`s
-    /// yield distinct books (fresh user keypair per book).
-    pub fn ticketbook(&self, typ: TicketType, seed: u64) -> IssuedTicketBook {
+    pub fn ticketbook_with_expiration(
+        &self,
+        typ: TicketType,
+        seed: u64,
+        expiration_date: Date,
+    ) -> IssuedTicketBook {
         let user = generate_keypair_user_from_seed(seed.to_be_bytes());
-        let expiration_date = ecash_default_expiration_date();
         let expiration_ts = expiration_date.ecash_unix_timestamp();
 
         let (req, req_info) = withdrawal_request(user.secret_key(), expiration_ts, typ.encode())
@@ -118,6 +121,13 @@ impl TestEcash {
         )
     }
 
+    /// Fabricate a real threshold-signed ticketbook for `typ`. Distinct `seed`s
+    /// yield distinct books (fresh user keypair per book).
+    pub fn ticketbook(&self, typ: TicketType, seed: u64) -> IssuedTicketBook {
+        let expiration_date = ecash_default_expiration_date();
+        self.ticketbook_with_expiration(typ, seed, expiration_date)
+    }
+
     /// The master verification key as the fetcher would serve it.
     pub fn epoch_verification_key(&self, epoch_id: u64) -> EpochVerificationKey {
         EpochVerificationKey {

sdk/rust/nym-sdk-session/tests/support/prune.rs

@@ -0,0 +1,36 @@
+use nym_bandwidth_controller::{BandwidthController, TicketType};
+use nym_credential_storage::{initialise_ephemeral_storage, storage::Storage};
+use time::Date;
+
+use crate::support::TestEcash;
+
+/// Calling prune on the bandwidth controller frees up expected data in ticketbook storage
+#[tokio::test]
+async fn prune_storage() {
+    let ecash = TestEcash::new();
+    let storage = initialise_ephemeral_storage();
+    let controller = BandwidthController::new(storage.clone());
+
+    // pruning on empty storage doesn't error
+    controller.prune_expired().await;
+
+    // pruning old ticketbooks leaves the storage empty
+    let ticketbook = ecash.ticketbook_with_expiration(
+        TicketType::V1WireguardEntry,
+        42,
+        Date::from_calendar_date(2000, 1.try_into().unwrap(), 1).unwrap(),
+    );
+    storage.insert_issued_ticketbook(&ticketbook).await.unwrap();
+    controller.prune_expired().await;
+    assert_eq!(storage.get_ticketbooks_info().await.unwrap().len(), 0);
+
+    // pruning non-expired ticketbooks doesn't touch them
+    let ticketbook = ecash.ticketbook_with_expiration(
+        TicketType::V1WireguardEntry,
+        42,
+        Date::from_calendar_date(2100, 1.try_into().unwrap(), 1).unwrap(),
+    );
+    storage.insert_issued_ticketbook(&ticketbook).await.unwrap();
+    controller.prune_expired().await;
+    assert_ne!(storage.get_ticketbooks_info().await.unwrap().len(), 0);
+}