fix tests

satrs-example/src/acs.rs

@@ -1,7 +1,7 @@
 use std::sync::mpsc::{self, TryRecvError};
 
 use log::{info, warn};
-use satrs::pus::verification::VerificationReporterWithSender;
+use satrs::pus::verification::{VerificationReporterWithSender, VerificationReportingProvider};
 use satrs::pus::{EcssTmSender, PusTmWrapper};
 use satrs::request::TargetAndApidId;
 use satrs::spacepackets::ecss::hk::Subservice as HkSubservice;

satrs-example/src/events.rs

@@ -12,7 +12,7 @@ use satrs::{
             DefaultPusMgmtBackendProvider, EventReporter, EventRequest, EventRequestWithToken,
             PusEventDispatcher,
         },
-        verification::{TcStateStarted, VerificationReporterWithSender, VerificationToken},
+        verification::{TcStateStarted, VerificationReporterWithSender, VerificationToken, VerificationReportingProvider},
         EcssTmSender,
     },
     spacepackets::time::cds::{self, TimeProvider},

satrs-example/src/pus/action.rs

@@ -3,7 +3,7 @@ use satrs::action::ActionRequest;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::action::{PusActionToRequestConverter, PusService8ActionHandler};
 use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationToken,
+    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationToken, VerificationReportingProvider,
 };
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
@@ -33,7 +33,7 @@ impl PusActionToRequestConverter for ExampleActionRequestConverter {
         token: VerificationToken<TcStateAccepted>,
         tc: &PusTcReader,
         time_stamp: &[u8],
-        verif_reporter: &mut VerificationReporterWithSender,
+        verif_reporter: &impl VerificationReportingProvider,
     ) -> Result<(TargetId, ActionRequest), Self::Error> {
         let subservice = tc.subservice();
         let user_data = tc.user_data();
@@ -138,6 +138,7 @@ pub fn create_action_service_dynamic(
 pub struct Pus8Wrapper<TcInMemConverter: EcssTcInMemConverter> {
     pub(crate) pus_8_handler: PusService8ActionHandler<
         TcInMemConverter,
+        VerificationReporterWithSender,
         ExampleActionRequestConverter,
         GenericRequestRouter,
         GenericRoutingErrorHandler<8>,

satrs-example/src/pus/event.rs

@@ -76,7 +76,7 @@ pub fn create_event_service_dynamic(
 }
 
 pub struct Pus5Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus_5_handler: PusService5EventHandler<TcInMemConverter>,
+    pub pus_5_handler: PusService5EventHandler<TcInMemConverter, VerificationReporterWithSender>,
 }
 
 impl<TcInMemConverter: EcssTcInMemConverter> Pus5Wrapper<TcInMemConverter> {

satrs-example/src/pus/hk.rs

@@ -3,7 +3,7 @@ use satrs::hk::{CollectionIntervalFactor, HkRequest};
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::hk::{PusHkToRequestConverter, PusService3HkHandler};
 use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationToken,
+    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationToken, VerificationReportingProvider,
 };
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
@@ -33,7 +33,7 @@ impl PusHkToRequestConverter for ExampleHkRequestConverter {
         token: VerificationToken<TcStateAccepted>,
         tc: &PusTcReader,
         time_stamp: &[u8],
-        verif_reporter: &mut VerificationReporterWithSender,
+        verif_reporter: &impl VerificationReportingProvider,
     ) -> Result<(TargetId, HkRequest), Self::Error> {
         let user_data = tc.user_data();
         if user_data.is_empty() {
@@ -196,6 +196,7 @@ pub fn create_hk_service_dynamic(
 pub struct Pus3Wrapper<TcInMemConverter: EcssTcInMemConverter> {
     pub(crate) pus_3_handler: PusService3HkHandler<
         TcInMemConverter,
+        VerificationReporterWithSender,
         ExampleHkRequestConverter,
         GenericRequestRouter,
         GenericRoutingErrorHandler<3>,

satrs-example/src/pus/mod.rs

@@ -1,6 +1,6 @@
 use crate::tmtc::MpscStoreAndSendError;
 use log::warn;
-use satrs::pus::verification::{FailParams, StdVerifReporterWithSender};
+use satrs::pus::verification::{FailParams, StdVerifReporterWithSender, VerificationReportingProvider};
 use satrs::pus::{
     EcssTcAndToken, GenericRoutingError, PusPacketHandlerResult, PusRoutingErrorHandler, TcInMemory,
 };
@@ -169,7 +169,7 @@ impl<const SERVICE_ID: u8> PusRoutingErrorHandler for GenericRoutingErrorHandler
         _tc: &PusTcReader,
         error: Self::Error,
         time_stamp: &[u8],
-        verif_reporter: &mut satrs::pus::verification::VerificationReporterWithSender,
+        verif_reporter: &impl VerificationReportingProvider,
     ) {
         warn!("Routing request for service {SERVICE_ID} failed: {error:?}");
         match error {

satrs-example/src/pus/scheduler.rs

@@ -52,7 +52,8 @@ impl TcReleaser for mpsc::Sender<Vec<u8>> {
 }
 
 pub struct Pus11Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus_11_handler: PusService11SchedHandler<TcInMemConverter, PusScheduler>,
+    pub pus_11_handler:
+        PusService11SchedHandler<TcInMemConverter, VerificationReporterWithSender, PusScheduler>,
     pub sched_tc_pool: StaticMemoryPool,
     pub releaser_buf: [u8; 4096],
     pub tc_releaser: Box<dyn TcReleaser + Send>,

satrs-example/src/pus/test.rs

@@ -2,7 +2,7 @@ use log::{info, warn};
 use satrs::params::Params;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::test::PusService17TestHandler;
-use satrs::pus::verification::{FailParams, VerificationReporterWithSender};
+use satrs::pus::verification::{FailParams, VerificationReporterWithSender, VerificationReportingProvider};
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender,
     MpscTmInSharedPoolSender, PusPacketHandlerResult, PusServiceHelper,
@@ -79,7 +79,7 @@ pub fn create_test_service_dynamic(
 }
 
 pub struct Service17CustomWrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus17_handler: PusService17TestHandler<TcInMemConverter>,
+    pub pus17_handler: PusService17TestHandler<TcInMemConverter, VerificationReporterWithSender>,
     pub test_srv_event_sender: Sender<(EventU32, Option<Params>)>,
 }
 
@@ -125,14 +125,12 @@ impl<TcInMemConverter: EcssTcInMemConverter> Service17CustomWrapper<TcInMemConve
                         .service_helper
                         .common
                         .verification_handler
-                        .get_mut()
                         .start_success(token, Some(&stamp_buf))
                         .expect("Error sending start success");
                     self.pus17_handler
                         .service_helper
                         .common
                         .verification_handler
-                        .get_mut()
                         .completion_success(start_token, Some(&stamp_buf))
                         .expect("Error sending completion success");
                 } else {
@@ -141,7 +139,6 @@ impl<TcInMemConverter: EcssTcInMemConverter> Service17CustomWrapper<TcInMemConve
                         .service_helper
                         .common
                         .verification_handler
-                        .get_mut()
                         .start_failure(
                             token,
                             FailParams::new(

satrs/CHANGELOG.md

@@ -8,6 +8,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
+# [v0.2.0]
+
+## Added
+
+- New PUS service abstractions for HK (PUS 3) and actions (PUS 8). Introducing new abstractions
+  allows to move some boilerplate code into the framework.
+- New `VerificationReportingProvider` abstraction to avoid relying on a concrete verification
+  reporting provider.
+
 # [v0.1.1] 2024-02-12
 
 - Minor fixes for crate config `homepage` entries and links in documentation.

satrs/src/pus/action.rs

@@ -27,7 +27,7 @@ pub trait PusActionRequestRouter {
 pub mod alloc_mod {
     use spacepackets::ecss::tc::PusTcReader;
 
-    use crate::pus::verification::VerificationReporterWithSender;
+    use crate::pus::verification::VerificationReportingProvider;
 
     use super::*;
 
@@ -53,7 +53,7 @@ pub mod alloc_mod {
             token: VerificationToken<TcStateAccepted>,
             tc: &PusTcReader,
             time_stamp: &[u8],
-            verif_reporter: &mut VerificationReporterWithSender,
+            verif_reporter: &impl VerificationReportingProvider,
         ) -> Result<(TargetId, ActionRequest), Self::Error>;
     }
 }
@@ -62,8 +62,9 @@ pub mod alloc_mod {
 #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub mod std_mod {
     use crate::pus::{
-        EcssTcInMemConverter, GenericRoutingError, PusPacketHandlerResult, PusPacketHandlingError,
-        PusRoutingErrorHandler, PusServiceBase, PusServiceHelper,
+        verification::VerificationReportingProvider, EcssTcInMemConverter, GenericRoutingError,
+        PusPacketHandlerResult, PusPacketHandlingError, PusRoutingErrorHandler, PusServiceBase,
+        PusServiceHelper,
     };
 
     use super::*;
@@ -81,12 +82,13 @@ pub mod std_mod {
     /// 4. Handle all routing errors using the provided [PusRoutingErrorHandler].
     pub struct PusService8ActionHandler<
         TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
         RequestConverter: PusActionToRequestConverter,
-        RequestRouter: PusActionRequestRouter<Error=RoutingError>,
-        RoutingErrorHandler: PusRoutingErrorHandler<Error=RoutingError>,
-        RoutingError = GenericRoutingError
+        RequestRouter: PusActionRequestRouter<Error = RoutingError>,
+        RoutingErrorHandler: PusRoutingErrorHandler<Error = RoutingError>,
+        RoutingError = GenericRoutingError,
     > {
-        service_helper: PusServiceHelper<TcInMemConverter>,
+        service_helper: PusServiceHelper<TcInMemConverter, VerificationReporter>,
         request_converter: RequestConverter,
         request_router: RequestRouter,
         routing_error_handler: RoutingErrorHandler,
@@ -94,21 +96,23 @@ pub mod std_mod {
 
     impl<
             TcInMemConverter: EcssTcInMemConverter,
+            VerificationReporter: VerificationReportingProvider,
             RequestConverter: PusActionToRequestConverter<Error = PusPacketHandlingError>,
             RequestRouter: PusActionRequestRouter<Error = RoutingError>,
             RoutingErrorHandler: PusRoutingErrorHandler<Error = RoutingError>,
-            RoutingError
+            RoutingError,
         >
         PusService8ActionHandler<
             TcInMemConverter,
+            VerificationReporter,
             RequestConverter,
             RequestRouter,
             RoutingErrorHandler,
-            RoutingError
+            RoutingError,
         >
     {
         pub fn new(
-            service_helper: PusServiceHelper<TcInMemConverter>,
+            service_helper: PusServiceHelper<TcInMemConverter, VerificationReporter>,
             request_converter: RequestConverter,
             request_router: RequestRouter,
             routing_error_handler: RoutingErrorHandler,
@@ -133,12 +137,15 @@ pub mod std_mod {
                 .tc_in_mem_converter
                 .convert_ecss_tc_in_memory_to_reader(&ecss_tc_and_token.tc_in_memory)?;
             let mut partial_error = None;
-            let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
+            let time_stamp =
+                PusServiceBase::<VerificationReporter>::get_current_cds_short_timestamp(
+                    &mut partial_error,
+                );
             let (target_id, action_request) = self.request_converter.convert(
                 ecss_tc_and_token.token,
                 &tc,
                 &time_stamp,
-                &mut self.service_helper.common.verification_handler.borrow_mut(),
+                &self.service_helper.common.verification_handler,
             )?;
             if let Err(e) =
                 self.request_router
@@ -150,10 +157,47 @@ pub mod std_mod {
                     &tc,
                     e,
                     &time_stamp,
-                    &mut self.service_helper.common.verification_handler.borrow_mut(),
+                    &self.service_helper.common.verification_handler,
                 );
             }
             Ok(PusPacketHandlerResult::RequestHandled)
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use spacepackets::ecss::tc::PusTcReader;
+
+    use crate::pus::{verification::VerificationReportingProvider, GenericRoutingError};
+
+    use super::*;
+    pub struct TestRouter {}
+
+    impl PusActionRequestRouter for TestRouter {
+        type Error = GenericRoutingError;
+
+        fn route(
+            &self,
+            target_id: TargetId,
+            hk_request: ActionRequest,
+            token: VerificationToken<TcStateAccepted>,
+        ) -> Result<(), Self::Error> {
+            todo!()
+        }
+    }
+
+    pub struct TestConverter {}
+    impl PusActionToRequestConverter for TestConverter {
+        type Error = GenericRoutingError;
+        fn convert(
+            &mut self,
+            token: VerificationToken<TcStateAccepted>,
+            tc: &PusTcReader,
+            time_stamp: &[u8],
+            verif_reporter: &impl VerificationReportingProvider,
+        ) -> Result<(TargetId, ActionRequest), Self::Error> {
+            todo!()
+        }
+    }
+}

satrs/src/pus/event_srv.rs

@@ -6,16 +6,24 @@ use spacepackets::ecss::event::Subservice;
 use spacepackets::ecss::PusPacket;
 use std::sync::mpsc::Sender;
 
+use super::verification::VerificationReportingProvider;
 use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHelper};
 
-pub struct PusService5EventHandler<TcInMemConverter: EcssTcInMemConverter> {
-    pub service_helper: PusServiceHelper<TcInMemConverter>,
+pub struct PusService5EventHandler<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
+    pub service_helper: PusServiceHelper<TcInMemConverter, VerificationReporter>,
     event_request_tx: Sender<EventRequestWithToken>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> PusService5EventHandler<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > PusService5EventHandler<TcInMemConverter, VerificationReporter>
+{
     pub fn new(
-        service_handler: PusServiceHelper<TcInMemConverter>,
+        service_handler: PusServiceHelper<TcInMemConverter, VerificationReporter>,
         event_request_tx: Sender<EventRequestWithToken>,
     ) -> Self {
         Self {
@@ -54,7 +62,6 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService5EventHandler<TcInMemConv
                 .service_helper
                 .common
                 .verification_handler
-                .borrow_mut()
                 .start_success(ecss_tc_and_token.token, Some(&stamp))
                 .map_err(|_| PartialPusHandlingError::Verification);
             let partial_error = start_token.clone().err();
@@ -86,7 +93,9 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService5EventHandler<TcInMemConv
             Ok(PusPacketHandlerResult::RequestHandled)
         };
         let mut partial_error = None;
-        let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
+        let time_stamp = PusServiceBase::<VerificationReporter>::get_current_cds_short_timestamp(
+            &mut partial_error,
+        );
         match srv.unwrap() {
             Subservice::TmInfoReport
             | Subservice::TmLowSeverityReport
@@ -128,7 +137,7 @@ mod tests {
 
     use crate::pus::event_man::EventRequest;
     use crate::pus::tests::SimplePusPacketHandler;
-    use crate::pus::verification::RequestId;
+    use crate::pus::verification::{RequestId, VerificationReporterWithSender};
     use crate::{
         events::EventU32,
         pus::{
@@ -145,7 +154,8 @@ mod tests {
 
     struct Pus5HandlerWithStoreTester {
         common: PusServiceHandlerWithSharedStoreCommon,
-        handler: PusService5EventHandler<EcssTcInSharedStoreConverter>,
+        handler:
+            PusService5EventHandler<EcssTcInSharedStoreConverter, VerificationReporterWithSender>,
     }
 
     impl Pus5HandlerWithStoreTester {

satrs/src/pus/hk.rs

@@ -29,7 +29,7 @@ pub trait PusHkRequestRouter {
 pub mod alloc_mod {
     use spacepackets::ecss::tc::PusTcReader;
 
-    use crate::pus::verification::VerificationReporterWithSender;
+    use crate::pus::verification::VerificationReportingProvider;
 
     use super::*;
 
@@ -55,7 +55,7 @@ pub mod alloc_mod {
             token: VerificationToken<TcStateAccepted>,
             tc: &PusTcReader,
             time_stamp: &[u8],
-            verif_reporter: &mut VerificationReporterWithSender,
+            verif_reporter: &impl VerificationReportingProvider,
         ) -> Result<(TargetId, HkRequest), Self::Error>;
     }
 }
@@ -64,8 +64,9 @@ pub mod alloc_mod {
 #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub mod std_mod {
     use crate::pus::{
-        EcssTcInMemConverter, GenericRoutingError, PusPacketHandlerResult, PusPacketHandlingError,
-        PusRoutingErrorHandler, PusServiceBase, PusServiceHelper,
+        verification::VerificationReportingProvider, EcssTcInMemConverter, GenericRoutingError,
+        PusPacketHandlerResult, PusPacketHandlingError, PusRoutingErrorHandler, PusServiceBase,
+        PusServiceHelper,
     };
 
     use super::*;
@@ -85,12 +86,13 @@ pub mod std_mod {
     ///    type is constrained to the [GenericRoutingError] for the concrete implementation.
     pub struct PusService3HkHandler<
         TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
         RequestConverter: PusHkToRequestConverter,
-        RequestRouter: PusHkRequestRouter<Error=RoutingError>,
-        RoutingErrorHandler: PusRoutingErrorHandler<Error=RoutingError>,
-        RoutingError = GenericRoutingError
+        RequestRouter: PusHkRequestRouter<Error = RoutingError>,
+        RoutingErrorHandler: PusRoutingErrorHandler<Error = RoutingError>,
+        RoutingError = GenericRoutingError,
     > {
-        service_helper: PusServiceHelper<TcInMemConverter>,
+        service_helper: PusServiceHelper<TcInMemConverter, VerificationReporter>,
         request_converter: RequestConverter,
         request_router: RequestRouter,
         routing_error_handler: RoutingErrorHandler,
@@ -98,15 +100,23 @@ pub mod std_mod {
 
     impl<
             TcInMemConverter: EcssTcInMemConverter,
+            VerificationReporter: VerificationReportingProvider,
             RequestConverter: PusHkToRequestConverter<Error = PusPacketHandlingError>,
             RequestRouter: PusHkRequestRouter<Error = RoutingError>,
             RoutingErrorHandler: PusRoutingErrorHandler<Error = RoutingError>,
             RoutingError,
         >
-        PusService3HkHandler<TcInMemConverter, RequestConverter, RequestRouter, RoutingErrorHandler, RoutingError>
+        PusService3HkHandler<
+            TcInMemConverter,
+            VerificationReporter,
+            RequestConverter,
+            RequestRouter,
+            RoutingErrorHandler,
+            RoutingError,
+        >
     {
         pub fn new(
-            service_helper: PusServiceHelper<TcInMemConverter>,
+            service_helper: PusServiceHelper<TcInMemConverter, VerificationReporter>,
             request_converter: RequestConverter,
             request_router: RequestRouter,
             routing_error_handler: RoutingErrorHandler,
@@ -130,12 +140,15 @@ pub mod std_mod {
                 .tc_in_mem_converter
                 .convert_ecss_tc_in_memory_to_reader(&ecss_tc_and_token.tc_in_memory)?;
             let mut partial_error = None;
-            let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
+            let time_stamp =
+                PusServiceBase::<VerificationReporter>::get_current_cds_short_timestamp(
+                    &mut partial_error,
+                );
             let (target_id, hk_request) = self.request_converter.convert(
                 ecss_tc_and_token.token,
                 &tc,
                 &time_stamp,
-                &mut self.service_helper.common.verification_handler.borrow_mut(),
+                &self.service_helper.common.verification_handler,
             )?;
             if let Err(e) =
                 self.request_router
@@ -147,7 +160,7 @@ pub mod std_mod {
                     &tc,
                     e,
                     &time_stamp,
-                    &mut self.service_helper.common.verification_handler.borrow_mut(),
+                    &self.service_helper.common.verification_handler,
                 );
             }
             Ok(PusPacketHandlerResult::RequestHandled)

satrs/src/pus/mod.rs

@@ -262,10 +262,10 @@ pub trait ReceivesEcssPusTc {
 mod alloc_mod {
     use crate::TargetId;
 
-    use self::verification::VerificationReporterWithSender;
-
     use super::*;
 
+    use crate::pus::verification::VerificationReportingProvider;
+
     /// Extension trait for [EcssTmSenderCore].
     ///
     /// It provides additional functionality, for example by implementing the [Downcast] trait
@@ -355,7 +355,7 @@ mod alloc_mod {
             tc: &PusTcReader,
             error: Self::Error,
             time_stamp: &[u8],
-            verif_reporter: &mut VerificationReporterWithSender,
+            verif_reporter: &impl VerificationReportingProvider,
         );
     }
 }
@@ -364,9 +364,7 @@ mod alloc_mod {
 #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 pub mod std_mod {
     use crate::pool::{PoolProvider, PoolProviderWithGuards, SharedStaticMemoryPool, StoreAddr};
-    use crate::pus::verification::{
-        StdVerifReporterWithSender, TcStateAccepted, VerificationToken,
-    };
+    use crate::pus::verification::{TcStateAccepted, VerificationToken};
     use crate::pus::{
         EcssChannel, EcssTcAndToken, EcssTcReceiver, EcssTcReceiverCore, EcssTmSender,
         EcssTmSenderCore, EcssTmtcError, GenericRecvError, GenericSendError, PusTmWrapper,
@@ -383,13 +381,12 @@ pub mod std_mod {
     use spacepackets::time::cds::TimeProvider;
     use spacepackets::time::StdTimestampError;
     use spacepackets::time::TimeWriter;
-    use std::cell::RefCell;
     use std::string::String;
     use std::sync::mpsc;
     use std::sync::mpsc::TryRecvError;
     use thiserror::Error;
 
-    use super::verification::VerificationReporterWithSender;
+    use super::verification::VerificationReportingProvider;
     use super::{AcceptedEcssTcAndToken, TcInMemory};
 
     impl From<mpsc::SendError<StoreAddr>> for EcssTmtcError {
@@ -814,18 +811,18 @@ pub mod std_mod {
         }
     }
 
-    pub struct PusServiceBase {
+    pub struct PusServiceBase<VerificationReporter: VerificationReportingProvider> {
         pub tc_receiver: Box<dyn EcssTcReceiver>,
         pub tm_sender: Box<dyn EcssTmSender>,
         pub tm_apid: u16,
         /// The verification handler is wrapped in a [RefCell] to allow the interior mutability
         /// pattern. This makes writing methods which are not mutable a lot easier.
-        pub verification_handler: RefCell<StdVerifReporterWithSender>,
+        pub verification_handler: VerificationReporter,
     }
 
-    impl PusServiceBase {
+    impl<VerificationReporter: VerificationReportingProvider> PusServiceBase<VerificationReporter> {
         #[cfg(feature = "std")]
-        pub fn get_current_timestamp(
+        pub fn get_current_cds_short_timestamp(
             partial_error: &mut Option<PartialPusHandlingError>,
         ) -> [u8; 7] {
             let mut time_stamp: [u8; 7] = [0; 7];
@@ -839,11 +836,10 @@ pub mod std_mod {
             }
             time_stamp
         }
-
         #[cfg(feature = "std")]
         pub fn get_current_timestamp_ignore_error() -> [u8; 7] {
             let mut dummy = None;
-            Self::get_current_timestamp(&mut dummy)
+            Self::get_current_cds_short_timestamp(&mut dummy)
         }
     }
 
@@ -856,17 +852,24 @@ pub mod std_mod {
     /// This base class can handle PUS telecommands backed by different memory storage machanisms
     /// by using the [EcssTcInMemConverter] abstraction. This object provides some convenience
     /// methods to make the generic parts of TC handling easier.
-    pub struct PusServiceHelper<TcInMemConverter: EcssTcInMemConverter> {
-        pub common: PusServiceBase,
+    pub struct PusServiceHelper<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > {
+        pub common: PusServiceBase<VerificationReporter>,
         pub tc_in_mem_converter: TcInMemConverter,
     }
 
-    impl<TcInMemConverter: EcssTcInMemConverter> PusServiceHelper<TcInMemConverter> {
+    impl<
+            TcInMemConverter: EcssTcInMemConverter,
+            VerificationReporter: VerificationReportingProvider,
+        > PusServiceHelper<TcInMemConverter, VerificationReporter>
+    {
         pub fn new(
             tc_receiver: Box<dyn EcssTcReceiver>,
             tm_sender: Box<dyn EcssTmSender>,
             tm_apid: u16,
-            verification_handler: VerificationReporterWithSender,
+            verification_handler: VerificationReporter,
             tc_in_mem_converter: TcInMemConverter,
         ) -> Self {
             Self {
@@ -874,7 +877,7 @@ pub mod std_mod {
                     tc_receiver,
                     tm_sender,
                     tm_apid,
-                    verification_handler: RefCell::new(verification_handler),
+                    verification_handler,
                 },
                 tc_in_mem_converter,
             }
@@ -945,7 +948,8 @@ pub mod tests {
     use crate::tmtc::tm_helper::SharedTmPool;
 
     use super::verification::{
-        TcStateAccepted, VerificationReporterCfg, VerificationReporterWithSender, VerificationToken,
+        TcStateAccepted, VerificationReporterCfg, VerificationReporterWithSender,
+        VerificationReportingProvider, VerificationToken,
     };
     use super::{
         EcssTcAndToken, EcssTcInSharedStoreConverter, EcssTcInVecConverter, MpscTcReceiver,
@@ -1005,7 +1009,10 @@ pub mod tests {
         /// [PusServiceHandler] which might be required for a specific PUS service handler.
         ///
         /// The PUS service handler is instantiated with a [EcssTcInStoreConverter].
-        pub fn new() -> (Self, PusServiceHelper<EcssTcInSharedStoreConverter>) {
+        pub fn new() -> (
+            Self,
+            PusServiceHelper<EcssTcInSharedStoreConverter, VerificationReporterWithSender>,
+        ) {
             let pool_cfg = StaticPoolConfig::new(vec![(16, 16), (8, 32), (4, 64)], false);
             let tc_pool = StaticMemoryPool::new(pool_cfg.clone());
             let tm_pool = StaticMemoryPool::new(pool_cfg);
@@ -1106,7 +1113,10 @@ pub mod tests {
     }
 
     impl PusServiceHandlerWithVecCommon {
-        pub fn new() -> (Self, PusServiceHelper<EcssTcInVecConverter>) {
+        pub fn new() -> (
+            Self,
+            PusServiceHelper<EcssTcInVecConverter, VerificationReporterWithSender>,
+        ) {
             let (test_srv_tc_tx, test_srv_tc_rx) = mpsc::channel();
             let (tm_tx, tm_rx) = mpsc::channel();
 

satrs/src/pus/scheduler_srv.rs

@@ -1,4 +1,5 @@
 use super::scheduler::PusSchedulerProvider;
+use super::verification::VerificationReportingProvider;
 use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHelper};
 use crate::pool::PoolProvider;
 use crate::pus::{PusPacketHandlerResult, PusPacketHandlingError};
@@ -16,16 +17,23 @@ use spacepackets::time::cds::TimeProvider;
 /// telecommands when applicable.
 pub struct PusService11SchedHandler<
     TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
     PusScheduler: PusSchedulerProvider,
 > {
-    pub service_helper: PusServiceHelper<TcInMemConverter>,
+    pub service_helper: PusServiceHelper<TcInMemConverter, VerificationReporter>,
     scheduler: PusScheduler,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
-    PusService11SchedHandler<TcInMemConverter, Scheduler>
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+        Scheduler: PusSchedulerProvider,
+    > PusService11SchedHandler<TcInMemConverter, VerificationReporter, Scheduler>
 {
-    pub fn new(service_helper: PusServiceHelper<TcInMemConverter>, scheduler: Scheduler) -> Self {
+    pub fn new(
+        service_helper: PusServiceHelper<TcInMemConverter, VerificationReporter>,
+        scheduler: Scheduler,
+    ) -> Self {
         Self {
             service_helper,
             scheduler,
@@ -62,14 +70,15 @@ impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
             ));
         }
         let mut partial_error = None;
-        let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
+        let time_stamp = PusServiceBase::<VerificationReporter>::get_current_cds_short_timestamp(
+            &mut partial_error,
+        );
         match standard_subservice.unwrap() {
             scheduling::Subservice::TcEnableScheduling => {
                 let start_token = self
                     .service_helper
                     .common
                     .verification_handler
-                    .get_mut()
                     .start_success(ecss_tc_and_token.token, Some(&time_stamp))
                     .expect("Error sending start success");
 
@@ -78,7 +87,6 @@ impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
                     self.service_helper
                         .common
                         .verification_handler
-                        .get_mut()
                         .completion_success(start_token, Some(&time_stamp))
                         .expect("Error sending completion success");
                 } else {
@@ -92,7 +100,6 @@ impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
                     .service_helper
                     .common
                     .verification_handler
-                    .get_mut()
                     .start_success(ecss_tc_and_token.token, Some(&time_stamp))
                     .expect("Error sending start success");
 
@@ -101,7 +108,6 @@ impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
                     self.service_helper
                         .common
                         .verification_handler
-                        .get_mut()
                         .completion_success(start_token, Some(&time_stamp))
                         .expect("Error sending completion success");
                 } else {
@@ -115,7 +121,6 @@ impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
                     .service_helper
                     .common
                     .verification_handler
-                    .get_mut()
                     .start_success(ecss_tc_and_token.token, Some(&time_stamp))
                     .expect("Error sending start success");
 
@@ -126,7 +131,6 @@ impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
                 self.service_helper
                     .common
                     .verification_handler
-                    .get_mut()
                     .completion_success(start_token, Some(&time_stamp))
                     .expect("Error sending completion success");
             }
@@ -135,7 +139,6 @@ impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
                     .service_helper
                     .common
                     .verification_handler
-                    .get_mut()
                     .start_success(ecss_tc_and_token.token, Some(&time_stamp))
                     .expect("error sending start success");
 
@@ -147,7 +150,6 @@ impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
                 self.service_helper
                     .common
                     .verification_handler
-                    .get_mut()
                     .completion_success(start_token, Some(&time_stamp))
                     .expect("sending completion success failed");
             }
@@ -172,6 +174,7 @@ impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
 mod tests {
     use crate::pool::{StaticMemoryPool, StaticPoolConfig};
     use crate::pus::tests::TEST_APID;
+    use crate::pus::verification::VerificationReporterWithSender;
     use crate::pus::{
         scheduler::{self, PusSchedulerProvider, TcInfo},
         tests::{PusServiceHandlerWithSharedStoreCommon, PusTestHarness},
@@ -194,7 +197,11 @@ mod tests {
 
     struct Pus11HandlerWithStoreTester {
         common: PusServiceHandlerWithSharedStoreCommon,
-        handler: PusService11SchedHandler<EcssTcInSharedStoreConverter, TestScheduler>,
+        handler: PusService11SchedHandler<
+            EcssTcInSharedStoreConverter,
+            VerificationReporterWithSender,
+            TestScheduler,
+        >,
         sched_tc_pool: StaticMemoryPool,
     }
 

satrs/src/pus/test.rs

@@ -5,16 +5,24 @@ use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
 use spacepackets::ecss::PusPacket;
 use spacepackets::SpHeader;
 
+use super::verification::VerificationReportingProvider;
 use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHelper};
 
 /// This is a helper class for [std] environments to handle generic PUS 17 (test service) packets.
 /// This handler only processes ping requests and generates a ping reply for them accordingly.
-pub struct PusService17TestHandler<TcInMemConverter: EcssTcInMemConverter> {
-    pub service_helper: PusServiceHelper<TcInMemConverter>,
+pub struct PusService17TestHandler<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
+    pub service_helper: PusServiceHelper<TcInMemConverter, VerificationReporter>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> PusService17TestHandler<TcInMemConverter> {
-    pub fn new(service_helper: PusServiceHelper<TcInMemConverter>) -> Self {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > PusService17TestHandler<TcInMemConverter, VerificationReporter>
+{
+    pub fn new(service_helper: PusServiceHelper<TcInMemConverter, VerificationReporter>) -> Self {
         Self { service_helper }
     }
 
@@ -33,12 +41,14 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService17TestHandler<TcInMemConv
         }
         if tc.subservice() == 1 {
             let mut partial_error = None;
-            let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
+            let time_stamp =
+                PusServiceBase::<VerificationReporter>::get_current_cds_short_timestamp(
+                    &mut partial_error,
+                );
             let result = self
                 .service_helper
                 .common
                 .verification_handler
-                .get_mut()
                 .start_success(ecss_tc_and_token.token, Some(&time_stamp))
                 .map_err(|_| PartialPusHandlingError::Verification);
             let start_token = if let Ok(result) = result {
@@ -67,7 +77,6 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService17TestHandler<TcInMemConv
                     .service_helper
                     .common
                     .verification_handler
-                    .get_mut()
                     .completion_success(start_token, Some(&time_stamp))
                     .is_err()
                 {
@@ -95,7 +104,9 @@ mod tests {
         PusServiceHandlerWithSharedStoreCommon, PusServiceHandlerWithVecCommon, PusTestHarness,
         SimplePusPacketHandler, TEST_APID,
     };
-    use crate::pus::verification::RequestId;
+    use crate::pus::verification::{
+        RequestId, VerificationReporterWithSender, VerificationReportingProvider,
+    };
     use crate::pus::verification::{TcStateAccepted, VerificationToken};
     use crate::pus::{
         EcssTcInSharedStoreConverter, EcssTcInVecConverter, PusPacketHandlerResult,
@@ -111,7 +122,8 @@ mod tests {
 
     struct Pus17HandlerWithStoreTester {
         common: PusServiceHandlerWithSharedStoreCommon,
-        handler: PusService17TestHandler<EcssTcInSharedStoreConverter>,
+        handler:
+            PusService17TestHandler<EcssTcInSharedStoreConverter, VerificationReporterWithSender>,
     }
 
     impl Pus17HandlerWithStoreTester {
@@ -149,7 +161,7 @@ mod tests {
 
     struct Pus17HandlerWithVecTester {
         common: PusServiceHandlerWithVecCommon,
-        handler: PusService17TestHandler<EcssTcInVecConverter>,
+        handler: PusService17TestHandler<EcssTcInVecConverter, VerificationReporterWithSender>,
     }
 
     impl Pus17HandlerWithVecTester {

satrs/src/pus/verification.rs

@@ -16,7 +16,9 @@
 //! use std::sync::{Arc, mpsc, RwLock};
 //! use std::time::Duration;
 //! use satrs::pool::{PoolProviderWithGuards, StaticMemoryPool, StaticPoolConfig};
-//! use satrs::pus::verification::{VerificationReporterCfg, VerificationReporterWithSender};
+//! use satrs::pus::verification::{
+//!     VerificationReportingProvider, VerificationReporterCfg, VerificationReporterWithSender
+//! };
 //! use satrs::seq_count::SeqCountProviderSimple;
 //! use satrs::pus::MpscTmInSharedPoolSender;
 //! use satrs::tmtc::tm_helper::SharedTmPool;
@@ -399,6 +401,64 @@ impl<'src_data, TcState: WasAtLeastAccepted + Copy>
     pub fn send_success_step_or_completion_success(self) {}
 }
 
+pub trait VerificationReportingProvider {
+    fn add_tc(
+        &mut self,
+        pus_tc: &(impl CcsdsPacket + IsPusTelecommand),
+    ) -> VerificationToken<TcStateNone>;
+
+    fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone>;
+
+    fn acceptance_success(
+        &self,
+        token: VerificationToken<TcStateNone>,
+        time_stamp: Option<&[u8]>,
+    ) -> Result<VerificationToken<TcStateAccepted>, VerificationOrSendErrorWithToken<TcStateNone>>;
+
+    fn acceptance_failure(
+        &self,
+        token: VerificationToken<TcStateNone>,
+        params: FailParams,
+    ) -> Result<(), VerificationOrSendErrorWithToken<TcStateNone>>;
+
+    fn start_success(
+        &self,
+        token: VerificationToken<TcStateAccepted>,
+        time_stamp: Option<&[u8]>,
+    ) -> Result<VerificationToken<TcStateStarted>, VerificationOrSendErrorWithToken<TcStateAccepted>>;
+
+    fn start_failure(
+        &self,
+        token: VerificationToken<TcStateAccepted>,
+        params: FailParams,
+    ) -> Result<(), VerificationOrSendErrorWithToken<TcStateAccepted>>;
+
+    fn step_success(
+        &self,
+        token: &VerificationToken<TcStateStarted>,
+        time_stamp: Option<&[u8]>,
+        step: impl EcssEnumeration,
+    ) -> Result<(), EcssTmtcError>;
+
+    fn step_failure(
+        &self,
+        token: VerificationToken<TcStateStarted>,
+        params: FailParamsWithStep,
+    ) -> Result<(), VerificationOrSendErrorWithToken<TcStateStarted>>;
+
+    fn completion_success<TcState: WasAtLeastAccepted + Copy>(
+        &self,
+        token: VerificationToken<TcState>,
+        time_stamp: Option<&[u8]>,
+    ) -> Result<(), VerificationOrSendErrorWithToken<TcState>>;
+
+    fn completion_failure<TcState: WasAtLeastAccepted + Copy>(
+        &self,
+        token: VerificationToken<TcState>,
+        params: FailParams,
+    ) -> Result<(), VerificationOrSendErrorWithToken<TcState>>;
+}
+
 /// Primary verification handler. It provides an API to send PUS 1 verification telemetry packets
 /// and verify the various steps of telecommand handling as specified in the PUS standard.
 ///
@@ -1226,14 +1286,24 @@ mod alloc_mod {
             to self.reporter {
                 pub fn set_apid(&mut self, apid: u16) -> bool;
                 pub fn apid(&self) -> u16;
-                pub fn add_tc(&mut self, pus_tc: &(impl CcsdsPacket + IsPusTelecommand)) -> VerificationToken<TcStateNone>;
-                pub fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone>;
                 pub fn dest_id(&self) -> u16;
                 pub fn set_dest_id(&mut self, dest_id: u16);
             }
         }
+    }
 
-        pub fn acceptance_success(
+    impl VerificationReportingProvider for VerificationReporterWithSender {
+        delegate! {
+            to self.reporter {
+                fn add_tc(
+                    &mut self,
+                    pus_tc: &(impl CcsdsPacket + IsPusTelecommand),
+                ) -> VerificationToken<TcStateNone>;
+                fn add_tc_with_req_id(&mut self, req_id: RequestId) -> VerificationToken<TcStateNone>;
+            }
+        }
+
+        fn acceptance_success(
             &self,
             token: VerificationToken<TcStateNone>,
             time_stamp: Option<&[u8]>,
@@ -1243,7 +1313,7 @@ mod alloc_mod {
                 .acceptance_success(token, self.sender.as_ref(), time_stamp)
         }
 
-        pub fn acceptance_failure(
+        fn acceptance_failure(
             &self,
             token: VerificationToken<TcStateNone>,
             params: FailParams,
@@ -1252,7 +1322,7 @@ mod alloc_mod {
                 .acceptance_failure(token, self.sender.as_ref(), params)
         }
 
-        pub fn start_success(
+        fn start_success(
             &self,
             token: VerificationToken<TcStateAccepted>,
             time_stamp: Option<&[u8]>,
@@ -1264,7 +1334,7 @@ mod alloc_mod {
                 .start_success(token, self.sender.as_ref(), time_stamp)
         }
 
-        pub fn start_failure(
+        fn start_failure(
             &self,
             token: VerificationToken<TcStateAccepted>,
             params: FailParams,
@@ -1273,7 +1343,7 @@ mod alloc_mod {
                 .start_failure(token, self.sender.as_ref(), params)
         }
 
-        pub fn step_success(
+        fn step_success(
             &self,
             token: &VerificationToken<TcStateStarted>,
             time_stamp: Option<&[u8]>,
@@ -1283,7 +1353,7 @@ mod alloc_mod {
                 .step_success(token, self.sender.as_ref(), time_stamp, step)
         }
 
-        pub fn step_failure(
+        fn step_failure(
             &self,
             token: VerificationToken<TcStateStarted>,
             params: FailParamsWithStep,
@@ -1292,7 +1362,7 @@ mod alloc_mod {
                 .step_failure(token, self.sender.as_ref(), params)
         }
 
-        pub fn completion_success<TcState: WasAtLeastAccepted + Copy>(
+        fn completion_success<TcState: WasAtLeastAccepted + Copy>(
             &self,
             token: VerificationToken<TcState>,
             time_stamp: Option<&[u8]>,
@@ -1301,7 +1371,7 @@ mod alloc_mod {
                 .completion_success(token, self.sender.as_ref(), time_stamp)
         }
 
-        pub fn completion_failure<TcState: WasAtLeastAccepted + Copy>(
+        fn completion_failure<TcState: WasAtLeastAccepted + Copy>(
             &self,
             token: VerificationToken<TcState>,
             params: FailParams,
@@ -1347,6 +1417,8 @@ mod tests {
     use std::vec;
     use std::vec::Vec;
 
+    use super::VerificationReportingProvider;
+
     fn is_send<T: Send>(_: &T) {}
     #[allow(dead_code)]
     fn is_sync<T: Sync>(_: &T) {}
@@ -1682,7 +1754,7 @@ mod tests {
         let accepted_token =
             b.vr.acceptance_success(tok, &sender, Some(&EMPTY_STAMP))
                 .expect("Sending acceptance success failed");
-        b.vr.start_failure(accepted_token, &mut sender, fail_params)
+        b.vr.start_failure(accepted_token, &sender, fail_params)
             .expect("Start failure failure");
         start_fail_check(&mut sender, tok.req_id, fail_data_raw);
     }
@@ -1905,12 +1977,11 @@ mod tests {
         );
 
         let accepted_token =
-            b.vr.acceptance_success(tok, &mut sender, Some(&EMPTY_STAMP))
+            b.vr.acceptance_success(tok, &sender, Some(&EMPTY_STAMP))
                 .expect("Sending acceptance success failed");
         let started_token =
-            b.vr.start_success(accepted_token, &mut sender, Some(&[0, 1, 0, 1, 0, 1, 0]))
+            b.vr.start_success(accepted_token, &sender, Some(&[0, 1, 0, 1, 0, 1, 0]))
                 .expect("Sending start success failed");
-        let mut empty =
             b.vr.step_success(
                 &started_token,
                 &mut sender,
@@ -1918,11 +1989,8 @@ mod tests {
                 EcssEnumU8::new(0),
             )
             .expect("Sending completion success failed");
-        assert_eq!(empty, ());
-        empty =
-            b.vr.step_failure(started_token, &mut sender, fail_params)
+            b.vr.step_failure(started_token, &sender, fail_params)
                 .expect("Step failure failed");
-        assert_eq!(empty, ());
         check_step_failure(&mut sender, req_id, fail_data_raw);
     }
 
@@ -2024,10 +2092,8 @@ mod tests {
         let started_token =
             b.vr.start_success(accepted_token, &mut sender, Some(&[0, 1, 0, 1, 0, 1, 0]))
                 .expect("Sending start success failed");
-        let empty =
-            b.vr.completion_failure(started_token, &mut sender, fail_params)
-                .expect("Completion failure");
-        assert_eq!(empty, ());
+        b.vr.completion_failure(started_token, &mut sender, fail_params)
+            .expect("Completion failure");
         completion_fail_check(&mut sender, req_id);
     }
 
@@ -2046,11 +2112,9 @@ mod tests {
             .helper
             .start_success(accepted_token, Some(&[0, 1, 0, 1, 0, 1, 0]))
             .expect("Sending start success failed");
-        let empty = b
-            .helper
+        b.helper
             .completion_failure(started_token, fail_params)
             .expect("Completion failure");
-        assert_eq!(empty, ());
         let sender: &mut TestSender = b.helper.sender.downcast_mut().unwrap();
         completion_fail_check(sender, req_id);
     }
@@ -2104,12 +2168,12 @@ mod tests {
         let (b, tok) = base_init(false);
         let mut sender = TestSender::default();
         let accepted_token =
-            b.vr.acceptance_success(tok, &mut sender, Some(&EMPTY_STAMP))
+            b.vr.acceptance_success(tok, &sender, Some(&EMPTY_STAMP))
                 .expect("Sending acceptance success failed");
         let started_token =
-            b.vr.start_success(accepted_token, &mut sender, Some(&[0, 1, 0, 1, 0, 1, 0]))
+            b.vr.start_success(accepted_token, &sender, Some(&[0, 1, 0, 1, 0, 1, 0]))
                 .expect("Sending start success failed");
-        b.vr.completion_success(started_token, &mut sender, Some(&EMPTY_STAMP))
+        b.vr.completion_success(started_token, &sender, Some(&EMPTY_STAMP))
             .expect("Sending completion success failed");
         completion_success_check(&mut sender, tok.req_id);
     }

satrs/tests/pus_verification.rs

@@ -3,7 +3,7 @@ pub mod crossbeam_test {
     use hashbrown::HashMap;
     use satrs::pool::{PoolProvider, PoolProviderWithGuards, StaticMemoryPool, StaticPoolConfig};
     use satrs::pus::verification::{
-        FailParams, RequestId, VerificationReporterCfg, VerificationReporterWithSender,
+        FailParams, RequestId, VerificationReporterCfg, VerificationReporterWithSender, VerificationReportingProvider,
     };
     use satrs::pus::CrossbeamTmInStoreSender;
     use satrs::tmtc::tm_helper::SharedTmPool;