cfg type

Author: clabby

glue/src/stateful/wrapper.rs

@@ -36,6 +36,34 @@ use commonware_runtime::{Clock, Metrics, Spawner};
 use rand::Rng;
 use std::collections::HashMap;
 
+/// Configuration for constructing a [`Stateful`] wrapper.
+pub struct Config<E, A, P>
+where
+    E: Rng + Spawner + Metrics + Clock,
+    A: Application<E>,
+    P: BlockProvider<Block = A::Block>,
+{
+    /// The inner application that drives state transitions.
+    pub app: A,
+
+    /// The set of databases whose batch lifecycle is managed by the wrapper.
+    pub databases: A::Databases,
+
+    /// Source of input (e.g. transactions) passed to the application on
+    /// propose.
+    pub input_provider: A::InputProvider,
+
+    /// Provider for fetching blocks during lazy recovery.
+    pub block_provider: P,
+
+    /// The payload of the last finalized block, or `None` if no
+    /// finalization has occurred yet.
+    ///
+    /// Should be set to the genesis payload on first boot, or the last
+    /// finalized payload on restart.
+    pub finalized_payload: Option<A::Payload>,
+}
+
 /// Wraps an [`Application`] and manages the pending-tip DAG of merkleized
 /// batches on its behalf, implementing the consensus
 /// [`Application`](ConsensusApplication) and
@@ -64,15 +92,13 @@ where
     input_provider: A::InputProvider,
 
     /// Provider for fetching blocks during lazy recovery.
-    provider: P,
+    block_provider: P,
 
     /// The payload of the last finalized block, or `None` if no
     /// finalization has occurred.
     ///
     /// Used during lazy recovery to detect when the walk-back has reached
-    /// the committed database state boundary. The caller should initialize
-    /// this to the genesis payload (or the last finalized payload on
-    /// restart).
+    /// the committed database state boundary.
     finalized_payload: Option<A::Payload>,
 
     /// Pending merkleized batches keyed by block payload, tagged with the
@@ -87,7 +113,7 @@ where
 
 /// `Stateful` is `Clone` for the fields consensus needs. The `databases`
 /// field clones cheaply (each database is behind an `Arc`). The pending
-/// map is not shared - each clone starts with a fresh map because
+/// map is not shared -- each clone starts with a fresh map because
 /// pending state is local to a single consensus actor.
 impl<E, A, P> Clone for Stateful<E, A, P>
 where
@@ -101,7 +127,7 @@ where
             inner: self.inner.clone(),
             databases: self.databases.clone(),
             input_provider: self.input_provider.clone(),
-            provider: self.provider.clone(),
+            block_provider: self.block_provider.clone(),
             finalized_payload: self.finalized_payload,
             pending: HashMap::new(),
         }
@@ -114,21 +140,14 @@ where
     A: Application<E>,
     P: BlockProvider<Block = A::Block>,
 {
-    pub fn new(
-        context: E,
-        inner: A,
-        databases: A::Databases,
-        input_provider: A::InputProvider,
-        provider: P,
-        finalized_payload: Option<A::Payload>,
-    ) -> Self {
+    pub fn new(context: E, cfg: Config<E, A, P>) -> Self {
         Self {
             context,
-            inner,
-            databases,
-            input_provider,
-            provider,
-            finalized_payload,
+            inner: cfg.app,
+            databases: cfg.databases,
+            input_provider: cfg.input_provider,
+            block_provider: cfg.block_provider,
+            finalized_payload: cfg.finalized_payload,
             pending: HashMap::new(),
         }
     }
@@ -160,7 +179,7 @@ where
         let mut current = target;
 
         loop {
-            let Some(block) = self.provider.clone().fetch_block(current).await else {
+            let Some(block) = self.block_provider.clone().fetch_block(current).await else {
                 // Reached end of chain (e.g. genesis parent).
                 break;
             };