commonwarexyz · patrick-ogrady · Jun 3, 2025 · May 23, 2025 · May 23, 2025 · May 23, 2025
diff --git a/broadcast/src/buffered/mod.rs b/broadcast/src/buffered/mod.rs
@@ -36,7 +36,10 @@ mod tests {
     use super::{mocks::TestMessage, *};
     use crate::Broadcaster;
     use commonware_codec::RangeCfg;
-    use commonware_cryptography::{ed25519::PublicKey, Committable, Digestible, Ed25519, Signer};
+    use commonware_cryptography::{
+        ed25519::{PrivateKey, PublicKey},
+        Committable, Digestible, PrivateKeyExt as _, Signer as _,
+    };
     use commonware_macros::{select, test_traced};
     use commonware_p2p::{
         simulated::{Link, Network, Oracle, Receiver, Sender},
@@ -74,7 +77,7 @@ mod tests {
         network.start();
 
         let mut schemes = (0..num_peers)
-            .map(|i| Ed25519::from_seed(i as u64))
+            .map(|i| PrivateKey::from_seed(i as u64))
             .collect::<Vec<_>>();
         schemes.sort_by_key(|s| s.public_key());
         let peers: Vec<PublicKey> = schemes.iter().map(|c| (c.public_key())).collect();

diff --git a/consensus/src/ordered_broadcast/ack_manager.rs b/consensus/src/ordered_broadcast/ack_manager.rs
@@ -159,7 +159,8 @@ mod tests {
             dkg::ops::generate_shares,
             primitives::variant::{MinPk, MinSig},
         },
-        ed25519, sha256,
+        ed25519::PublicKey,
+        sha256,
     };
 
     /// Aggregated helper functions to reduce duplication in tests.
@@ -180,16 +181,16 @@ mod tests {
         }
 
         /// Generate a fixed public key for testing.
-        pub fn gen_public_key(val: u8) -> ed25519::PublicKey {
-            ed25519::PublicKey::decode([val; ed25519::PublicKey::SIZE].as_ref()).unwrap()
+        pub fn gen_public_key(val: u8) -> PublicKey {
+            PublicKey::decode([val; PublicKey::SIZE].as_ref()).unwrap()
         }
 
         /// Create an Ack by signing a partial with the provided share.
         pub fn create_ack<V: Variant>(
             share: &Share,
-            chunk: Chunk<ed25519::PublicKey, sha256::Digest>,
+            chunk: Chunk<PublicKey, sha256::Digest>,
             epoch: Epoch,
-        ) -> Ack<ed25519::PublicKey, V, sha256::Digest> {
+        ) -> Ack<PublicKey, V, sha256::Digest> {
             Ack::sign(NAMESPACE, share, chunk, epoch)
         }
 
@@ -204,7 +205,7 @@ mod tests {
         /// Generate a threshold signature directly from the shares specified by `indices`.
         pub fn generate_threshold_from_indices<V: Variant>(
             shares: &[Share],
-            chunk: &Chunk<ed25519::PublicKey, sha256::Digest>,
+            chunk: &Chunk<PublicKey, sha256::Digest>,
             epoch: &Epoch,
             quorum: u32,
             indices: &[usize],
@@ -219,10 +220,10 @@ mod tests {
         /// Create a vector of acks for the given share indices.
         pub fn create_acks_for_indices<V: Variant>(
             shares: &[Share],
-            chunk: Chunk<ed25519::PublicKey, sha256::Digest>,
+            chunk: Chunk<PublicKey, sha256::Digest>,
             epoch: Epoch,
             indices: &[usize],
-        ) -> Vec<Ack<ed25519::PublicKey, V, sha256::Digest>> {
+        ) -> Vec<Ack<PublicKey, V, sha256::Digest>> {
             indices
                 .iter()
                 .map(|&i| create_ack(&shares[i], chunk.clone(), epoch))
@@ -232,9 +233,9 @@ mod tests {
         /// Add acks (generated from the provided share indices) to the manager.
         /// Returns the threshold signature if produced.
         pub fn add_acks_for_indices<V: Variant>(
-            manager: &mut AckManager<ed25519::PublicKey, V, sha256::Digest>,
+            manager: &mut AckManager<PublicKey, V, sha256::Digest>,
             shares: &[Share],
-            chunk: Chunk<ed25519::PublicKey, sha256::Digest>,
+            chunk: Chunk<PublicKey, sha256::Digest>,
             epoch: Epoch,
             quorum: u32,
             indices: &[usize],
@@ -255,7 +256,7 @@ mod tests {
         let num_validators = 6;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
         let sequencer = helpers::gen_public_key(1);
         let height = 10;
         let epoch = 5;
@@ -284,7 +285,7 @@ mod tests {
         let num_validators = 4;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
         let sequencer = helpers::gen_public_key(1);
         let epoch = 10;
         let height1 = 10;
@@ -332,7 +333,7 @@ mod tests {
         let num_validators = 4;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
         let sequencer = helpers::gen_public_key(1);
         let epoch = 10;
 
@@ -401,7 +402,7 @@ mod tests {
         let num_validators = 4;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
         let sequencer = helpers::gen_public_key(1);
         let height = 30;
         let epoch1 = 1;
@@ -444,7 +445,7 @@ mod tests {
         let num_validators = 4;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
         let epoch = 99;
         let sequencer = helpers::gen_public_key(1);
         let height = 42;
@@ -482,7 +483,7 @@ mod tests {
         let num_validators = 4;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
         let sequencer = helpers::gen_public_key(1);
         let epoch = 1;
         let height = 10;
@@ -504,7 +505,7 @@ mod tests {
         let num_validators = 4;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
         let sequencer = helpers::gen_public_key(1);
         let epoch = 1;
         let height = 10;
@@ -534,7 +535,7 @@ mod tests {
         let num_validators = 4;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
 
         let sequencer1 = helpers::gen_public_key(1);
         let sequencer2 = helpers::gen_public_key(3);
@@ -567,7 +568,7 @@ mod tests {
         let num_validators = 4;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
         let sequencer = helpers::gen_public_key(1);
         let epoch = 1;
         let height = 10;
@@ -591,7 +592,7 @@ mod tests {
         let num_validators = 6;
         let quorum = 3;
         let shares = helpers::setup_shares::<V>(num_validators, quorum);
-        let mut acks = AckManager::<ed25519::PublicKey, V, sha256::Digest>::new();
+        let mut acks = AckManager::<PublicKey, V, sha256::Digest>::new();
         let sequencer = helpers::gen_public_key(1);
         let epoch = 1;
         let height = 10;

diff --git a/consensus/src/ordered_broadcast/config.rs b/consensus/src/ordered_broadcast/config.rs
@@ -1,16 +1,16 @@
 use super::types::{Activity, Context, Epoch};
 use crate::{Automaton, Monitor, Relay, Reporter, Supervisor, ThresholdSupervisor};
-use commonware_cryptography::{bls12381::primitives::variant::Variant, Digest, Scheme};
+use commonware_cryptography::{bls12381::primitives::variant::Variant, Digest, Signer};
 use std::time::Duration;
 
 /// Configuration for the [`Engine`](super::Engine).
 pub struct Config<
-    C: Scheme,
+    C: Signer,
     V: Variant,
     D: Digest,
     A: Automaton<Context = Context<C::PublicKey>, Digest = D>,
     R: Relay<Digest = D>,
-    Z: Reporter<Activity = Activity<C, V, D>>,
+    Z: Reporter<Activity = Activity<C::PublicKey, V, D>>,
     M: Monitor<Index = Epoch>,
     Su: Supervisor<Index = Epoch, PublicKey = C::PublicKey>,
     TSu: ThresholdSupervisor<Index = Epoch, PublicKey = C::PublicKey>,

diff --git a/consensus/src/ordered_broadcast/engine.rs b/consensus/src/ordered_broadcast/engine.rs
@@ -15,7 +15,7 @@ use super::{
 use crate::{Automaton, Monitor, Relay, Reporter, Supervisor, ThresholdSupervisor};
 use commonware_cryptography::{
     bls12381::primitives::{group, poly, variant::Variant},
-    Digest, Scheme,
+    Digest, PublicKey, Signer,
 };
 use commonware_macros::select;
 use commonware_p2p::{
@@ -44,22 +44,22 @@ use std::{
 use tracing::{debug, error, info, warn};
 
 /// Represents a pending verification request to the automaton.
-struct Verify<C: Scheme, D: Digest, E: Clock> {
+struct Verify<C: PublicKey, D: Digest, E: Clock> {
     timer: histogram::Timer<E>,
-    context: Context<C::PublicKey>,
+    context: Context<C>,
     payload: D,
     result: Result<bool, Error>,
 }
 
 /// Instance of the engine.
 pub struct Engine<
     E: Clock + Spawner + Storage + Metrics,
-    C: Scheme,
+    C: Signer,
     V: Variant,
     D: Digest,
     A: Automaton<Context = Context<C::PublicKey>, Digest = D> + Clone,
     R: Relay<Digest = D>,
-    Z: Reporter<Activity = Activity<C, V, D>>,
+    Z: Reporter<Activity = Activity<C::PublicKey, V, D>>,
     M: Monitor<Index = Epoch>,
     Su: Supervisor<Index = Epoch, PublicKey = C::PublicKey>,
     TSu: ThresholdSupervisor<
@@ -130,7 +130,7 @@ pub struct Engine<
     //
     // There is no limit to the number of futures in this pool, so the automaton
     // can apply backpressure by dropping the verification requests if necessary.
-    pending_verifies: FuturesPool<Verify<C, D, E>>,
+    pending_verifies: FuturesPool<Verify<C::PublicKey, D, E>>,
 
     ////////////////////////////////////////
     // Storage
@@ -157,7 +157,7 @@ pub struct Engine<
 
     // A map of sequencer public keys to their journals.
     #[allow(clippy::type_complexity)]
-    journals: BTreeMap<C::PublicKey, Journal<E, Node<C, V, D>>>,
+    journals: BTreeMap<C::PublicKey, Journal<E, Node<C::PublicKey, V, D>>>,
 
     ////////////////////////////////////////
     // State
@@ -167,7 +167,7 @@ pub struct Engine<
     // The tip is a `Node` which is comprised of a `Chunk` and,
     // if not the genesis chunk for that sequencer,
     // a threshold signature over the parent chunk.
-    tip_manager: TipManager<C, V, D>,
+    tip_manager: TipManager<C::PublicKey, V, D>,
 
     // Tracks the acknowledgements for chunks.
     // This is comprised of partial signatures or threshold signatures.
@@ -202,12 +202,12 @@ pub struct Engine<
 
 impl<
         E: Clock + Spawner + Storage + Metrics,
-        C: Scheme,
+        C: Signer,
         V: Variant,
         D: Digest,
         A: Automaton<Context = Context<C::PublicKey>, Digest = D> + Clone,
         R: Relay<Digest = D>,
-        Z: Reporter<Activity = Activity<C, V, D>>,
+        Z: Reporter<Activity = Activity<C::PublicKey, V, D>>,
         M: Monitor<Index = Epoch>,
         Su: Supervisor<Index = Epoch, PublicKey = C::PublicKey>,
         TSu: ThresholdSupervisor<
@@ -247,7 +247,7 @@ impl<
             journal_name_prefix: cfg.journal_name_prefix,
             journal_compression: cfg.journal_compression,
             journals: BTreeMap::new(),
-            tip_manager: TipManager::<C, V, D>::new(),
+            tip_manager: TipManager::<C::PublicKey, V, D>::new(),
             ack_manager: AckManager::<C::PublicKey, V, D>::new(),
             epoch: 0,
             priority_proposals: cfg.priority_proposals,
@@ -603,7 +603,7 @@ impl<
     /// Handles a valid `Node` message, storing it as the tip.
     /// Alerts the automaton of the new node.
     /// Also appends the `Node` to the journal if it's new.
-    async fn handle_node(&mut self, node: &Node<C, V, D>) {
+    async fn handle_node(&mut self, node: &Node<C::PublicKey, V, D>) {
         // Store the tip
         let is_new = self.tip_manager.put(node);
 
@@ -680,7 +680,7 @@ impl<
         &mut self,
         context: Context<C::PublicKey>,
         payload: D,
-        node_sender: &mut WrappedSender<NetS, Node<C, V, D>>,
+        node_sender: &mut WrappedSender<NetS, Node<C::PublicKey, V, D>>,
     ) -> Result<(), Error> {
         let mut guard = self.metrics.propose.guard(Status::Dropped);
         let me = self.crypto.public_key();
@@ -747,7 +747,7 @@ impl<
     /// - this instance has not yet collected the threshold signature for the chunk.
     async fn rebroadcast(
         &mut self,
-        node_sender: &mut WrappedSender<NetS, Node<C, V, D>>,
+        node_sender: &mut WrappedSender<NetS, Node<C::PublicKey, V, D>>,
     ) -> Result<(), Error> {
         let mut guard = self.metrics.rebroadcast.guard(Status::Dropped);
 
@@ -784,8 +784,8 @@ impl<
     /// Send a  `Node` message to all validators in the given epoch.
     async fn broadcast(
         &mut self,
-        node: Node<C, V, D>,
-        node_sender: &mut WrappedSender<NetS, Node<C, V, D>>,
+        node: Node<C::PublicKey, V, D>,
+        node_sender: &mut WrappedSender<NetS, Node<C::PublicKey, V, D>>,
         epoch: Epoch,
     ) -> Result<(), Error> {
         // Get the validators for the epoch
@@ -823,7 +823,7 @@ impl<
     /// Else returns an error if the `Node` is invalid.
     fn validate_node(
         &mut self,
-        node: &Node<C, V, D>,
+        node: &Node<C::PublicKey, V, D>,
         sender: &C::PublicKey,
     ) -> Result<Option<Chunk<C::PublicKey, D>>, Error> {
         // Verify the sender
@@ -968,9 +968,10 @@ impl<
             codec_config: (),
             write_buffer: self.journal_write_buffer,
         };
-        let journal = Journal::<_, Node<C, V, D>>::init(self.context.with_label("journal"), cfg)
-            .await
-            .expect("unable to init journal");
+        let journal =
+            Journal::<_, Node<C::PublicKey, V, D>>::init(self.context.with_label("journal"), cfg)
+                .await
+                .expect("unable to init journal");
 
         // Replay journal
         {
@@ -985,7 +986,7 @@ impl<
 
             // Read from the stream, which may be in arbitrary order.
             // Remember the highest node height
-            let mut tip: Option<Node<C, V, D>> = None;
+            let mut tip: Option<Node<C::PublicKey, V, D>> = None;
             let mut num_items = 0;
             while let Some(msg) = stream.next().await {
                 let (_, _, _, node) = msg.expect("unable to read from journal");
@@ -1021,7 +1022,7 @@ impl<
     ///
     /// To prevent ever writing two conflicting `Chunk`s at the same height,
     /// the journal must already be open and replayed.
-    async fn journal_append(&mut self, node: Node<C, V, D>) {
+    async fn journal_append(&mut self, node: Node<C::PublicKey, V, D>) {
         let section = self.get_journal_section(node.chunk.height);
         self.journals
             .get_mut(&node.chunk.sequencer)