[cryptography/bls12381] Support Both MinPk and MinSig Variants (#906)

Author: patrick-ogrady

consensus/src/ordered_broadcast/ack_manager.rs

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

consensus/src/ordered_broadcast/config.rs

@@ -14,7 +14,7 @@ use super::{
 };
 use crate::{Automaton, Monitor, Relay, Reporter, Supervisor, ThresholdSupervisor};
 use commonware_cryptography::{
-    bls12381::primitives::{group, poly},
+    bls12381::primitives::{group, poly, variant::Variant},
     Digest, Scheme,
 };
 use commonware_macros::select;
@@ -55,17 +55,18 @@ struct Verify<C: Scheme, D: Digest, E: Clock> {
 pub struct Engine<
     E: Clock + Spawner + Storage + Metrics,
     C: Scheme,
+    V: Variant,
     D: Digest,
     A: Automaton<Context = Context<C::PublicKey>, Digest = D> + Clone,
     R: Relay<Digest = D>,
-    Z: Reporter<Activity = Activity<C, D>>,
+    Z: Reporter<Activity = Activity<C, V, D>>,
     M: Monitor<Index = Epoch>,
     Su: Supervisor<Index = Epoch, PublicKey = C::PublicKey>,
     TSu: ThresholdSupervisor<
         Index = Epoch,
         PublicKey = C::PublicKey,
         Share = group::Share,
-        Identity = poly::Public,
+        Identity = poly::Public<V>,
     >,
     NetS: Sender<PublicKey = C::PublicKey>,
     NetR: Receiver<PublicKey = C::PublicKey>,
@@ -151,7 +152,8 @@ pub struct Engine<
     journal_compression: Option<u8>,
 
     // A map of sequencer public keys to their journals.
-    journals: BTreeMap<C::PublicKey, Journal<E, Node<C, D>>>,
+    #[allow(clippy::type_complexity)]
+    journals: BTreeMap<C::PublicKey, Journal<E, Node<C, V, D>>>,
 
     ////////////////////////////////////////
     // State
@@ -161,11 +163,11 @@ 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, D>,
+    tip_manager: TipManager<C, V, D>,
 
     // Tracks the acknowledgements for chunks.
     // This is comprised of partial signatures or threshold signatures.
-    ack_manager: AckManager<C::PublicKey, D>,
+    ack_manager: AckManager<C::PublicKey, V, D>,
 
     // The current epoch.
     epoch: Epoch,
@@ -197,24 +199,25 @@ pub struct Engine<
 impl<
         E: Clock + Spawner + Storage + Metrics,
         C: Scheme,
+        V: Variant,
         D: Digest,
         A: Automaton<Context = Context<C::PublicKey>, Digest = D> + Clone,
         R: Relay<Digest = D>,
-        Z: Reporter<Activity = Activity<C, D>>,
+        Z: Reporter<Activity = Activity<C, V, D>>,
         M: Monitor<Index = Epoch>,
         Su: Supervisor<Index = Epoch, PublicKey = C::PublicKey>,
         TSu: ThresholdSupervisor<
             Index = Epoch,
             PublicKey = C::PublicKey,
             Share = group::Share,
-            Identity = poly::Public,
+            Identity = poly::Public<V>,
         >,
         NetS: Sender<PublicKey = C::PublicKey>,
         NetR: Receiver<PublicKey = C::PublicKey>,
-    > Engine<E, C, D, A, R, Z, M, Su, TSu, NetS, NetR>
+    > Engine<E, C, V, D, A, R, Z, M, Su, TSu, NetS, NetR>
 {
     /// Creates a new engine with the given context and configuration.
-    pub fn new(context: E, cfg: Config<C, D, A, R, Z, M, Su, TSu>) -> Self {
+    pub fn new(context: E, cfg: Config<C, V, D, A, R, Z, M, Su, TSu>) -> Self {
         let metrics = metrics::Metrics::init(context.clone());
 
         Self {
@@ -238,8 +241,8 @@ impl<
             journal_name_prefix: cfg.journal_name_prefix,
             journal_compression: cfg.journal_compression,
             journals: BTreeMap::new(),
-            tip_manager: TipManager::<C, D>::new(),
-            ack_manager: AckManager::<C::PublicKey, D>::new(),
+            tip_manager: TipManager::<C, V, D>::new(),
+            ack_manager: AckManager::<C::PublicKey, V, D>::new(),
             epoch: 0,
             priority_proposals: cfg.priority_proposals,
             priority_acks: cfg.priority_acks,
@@ -475,7 +478,7 @@ impl<
         &mut self,
         context: &Context<C::PublicKey>,
         payload: &D,
-        ack_sender: &mut WrappedSender<NetS, Ack<C::PublicKey, D>>,
+        ack_sender: &mut WrappedSender<NetS, Ack<C::PublicKey, V, D>>,
     ) -> Result<(), Error> {
         // Get the tip
         let Some(tip) = self.tip_manager.get(&context.sequencer) else {
@@ -548,7 +551,7 @@ impl<
         &mut self,
         chunk: &Chunk<C::PublicKey, D>,
         epoch: Epoch,
-        threshold: group::Signature,
+        threshold: V::Signature,
     ) {
         // Set the threshold signature, returning early if it already exists
         if !self
@@ -573,7 +576,7 @@ impl<
     ///
     /// Returns an error if the ack is invalid, or can be ignored
     /// (e.g. already exists, threshold already exists, is outside the epoch bounds, etc.).
-    async fn handle_ack(&mut self, ack: &Ack<C::PublicKey, D>) -> Result<(), Error> {
+    async fn handle_ack(&mut self, ack: &Ack<C::PublicKey, V, D>) -> Result<(), Error> {
         // Get the quorum
         let Some(identity) = self.validators.identity(ack.epoch) else {
             return Err(Error::UnknownIdentity(ack.epoch));
@@ -594,7 +597,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, D>) {
+    async fn handle_node(&mut self, node: &Node<C, V, D>) {
         // Store the tip
         let is_new = self.tip_manager.put(node);
 
@@ -671,7 +674,7 @@ impl<
         &mut self,
         context: Context<C::PublicKey>,
         payload: D,
-        node_sender: &mut WrappedSender<NetS, Node<C, D>>,
+        node_sender: &mut WrappedSender<NetS, Node<C, V, D>>,
     ) -> Result<(), Error> {
         let mut guard = self.metrics.propose.guard(Status::Dropped);
         let me = self.crypto.public_key();
@@ -738,7 +741,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, D>>,
+        node_sender: &mut WrappedSender<NetS, Node<C, V, D>>,
     ) -> Result<(), Error> {
         let mut guard = self.metrics.rebroadcast.guard(Status::Dropped);
 
@@ -775,8 +778,8 @@ impl<
     /// Send a  `Node` message to all validators in the given epoch.
     async fn broadcast(
         &mut self,
-        node: Node<C, D>,
-        node_sender: &mut WrappedSender<NetS, Node<C, D>>,
+        node: Node<C, V, D>,
+        node_sender: &mut WrappedSender<NetS, Node<C, V, D>>,
         epoch: Epoch,
     ) -> Result<(), Error> {
         // Get the validators for the epoch
@@ -814,7 +817,7 @@ impl<
     /// Else returns an error if the `Node` is invalid.
     fn validate_node(
         &mut self,
-        node: &Node<C, D>,
+        node: &Node<C, V, D>,
         sender: &C::PublicKey,
     ) -> Result<Option<Chunk<C::PublicKey, D>>, Error> {
         // Verify the sender
@@ -838,7 +841,7 @@ impl<
             let Some(identity) = self.validators.identity(parent.epoch) else {
                 return Err(Error::UnknownIdentity(parent.epoch));
             };
-            Some(poly::public(identity))
+            Some(poly::public::<V>(identity))
         } else {
             None
         };
@@ -852,7 +855,11 @@ impl<
     ///
     /// Returns the chunk, epoch, and partial signature if the ack is valid.
     /// Returns an error if the ack is invalid.
-    fn validate_ack(&self, ack: &Ack<C::PublicKey, D>, sender: &C::PublicKey) -> Result<(), Error> {
+    fn validate_ack(
+        &self,
+        ack: &Ack<C::PublicKey, V, D>,
+        sender: &C::PublicKey,
+    ) -> Result<(), Error> {
         // Validate chunk
         self.validate_chunk(&ack.chunk, ack.epoch)?;
 
@@ -964,7 +971,7 @@ impl<
             compression: self.journal_compression,
             codec_config: (),
         };
-        let journal = Journal::<_, Node<C, D>>::init(self.context.with_label("journal"), cfg)
+        let journal = Journal::<_, Node<C, V, D>>::init(self.context.with_label("journal"), cfg)
             .await
             .expect("unable to init journal");
 
@@ -981,7 +988,7 @@ impl<
 
             // Read from the stream, which may be in arbitrary order.
             // Remember the highest node height
-            let mut tip: Option<Node<C, D>> = None;
+            let mut tip: Option<Node<C, V, D>> = None;
             let mut num_items = 0;
             while let Some(msg) = stream.next().await {
                 let (_, _, _, node) = msg.expect("unable to read from journal");
@@ -1017,7 +1024,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, D>) {
+    async fn journal_append(&mut self, node: Node<C, V, D>) {
         let section = self.get_journal_section(node.chunk.height);
         self.journals
             .get_mut(&node.chunk.sequencer)

consensus/src/ordered_broadcast/engine.rs

@@ -3,30 +3,30 @@ use crate::{
     Reporter as Z,
 };
 use commonware_codec::{DecodeExt, Encode};
-use commonware_cryptography::{bls12381::primitives::group, Digest, Verifier};
+use commonware_cryptography::{bls12381::primitives::variant::Variant, Digest, Verifier};
 use futures::{
     channel::{mpsc, oneshot},
     SinkExt, StreamExt,
 };
 use std::collections::{btree_map::Entry, BTreeMap, HashMap, HashSet};
 
 #[allow(clippy::large_enum_variant)]
-enum Message<C: Verifier, D: Digest> {
+enum Message<C: Verifier, V: Variant, D: Digest> {
     Proposal(Proposal<C, D>),
-    Locked(Lock<C::PublicKey, D>),
+    Locked(Lock<C::PublicKey, V, D>),
     GetTip(C::PublicKey, oneshot::Sender<Option<(u64, Epoch)>>),
     GetContiguousTip(C::PublicKey, oneshot::Sender<Option<u64>>),
     Get(C::PublicKey, u64, oneshot::Sender<Option<(D, Epoch)>>),
 }
 
-pub struct Reporter<C: Verifier, D: Digest> {
-    mailbox: mpsc::Receiver<Message<C, D>>,
+pub struct Reporter<C: Verifier, V: Variant, D: Digest> {
+    mailbox: mpsc::Receiver<Message<C, V, D>>,
 
     // Application namespace
     namespace: Vec<u8>,
 
     // Public key of the group
-    public: group::Public,
+    public: V::Public,
 
     // Notified proposals
     proposals: HashSet<Chunk<C::PublicKey, D>>,
@@ -42,12 +42,12 @@ pub struct Reporter<C: Verifier, D: Digest> {
     highest: HashMap<C::PublicKey, (u64, Epoch)>,
 }
 
-impl<C: Verifier, D: Digest> Reporter<C, D> {
+impl<C: Verifier, V: Variant, D: Digest> Reporter<C, V, D> {
     pub fn new(
         namespace: &[u8],
-        public: group::Public,
+        public: V::Public,
         limit_misses: Option<usize>,
-    ) -> (Self, Mailbox<C, D>) {
+    ) -> (Self, Mailbox<C, V, D>) {
         let (sender, receiver) = mpsc::channel(1024);
         (
             Reporter {
@@ -89,7 +89,7 @@ impl<C: Verifier, D: Digest> Reporter<C, D> {
 
                     // Test encoding/decoding
                     let encoded = lock.encode();
-                    Lock::<C::PublicKey, D>::decode(encoded).unwrap();
+                    Lock::<C::PublicKey, V, D>::decode(encoded).unwrap();
 
                     // Check if the proposal is known
                     if let Some(misses_allowed) = self.limit_misses {
@@ -166,12 +166,12 @@ impl<C: Verifier, D: Digest> Reporter<C, D> {
 }
 
 #[derive(Clone)]
-pub struct Mailbox<C: Verifier, D: Digest> {
-    sender: mpsc::Sender<Message<C, D>>,
+pub struct Mailbox<C: Verifier, V: Variant, D: Digest> {
+    sender: mpsc::Sender<Message<C, V, D>>,
 }
 
-impl<C: Verifier, D: Digest> Z for Mailbox<C, D> {
-    type Activity = Activity<C, D>;
+impl<C: Verifier, V: Variant, D: Digest> Z for Mailbox<C, V, D> {
+    type Activity = Activity<C, V, D>;
 
     async fn report(&mut self, activity: Self::Activity) {
         match activity {
@@ -191,7 +191,7 @@ impl<C: Verifier, D: Digest> Z for Mailbox<C, D> {
     }
 }
 
-impl<C: Verifier, D: Digest> Mailbox<C, D> {
+impl<C: Verifier, V: Variant, D: Digest> Mailbox<C, V, D> {
     pub async fn get_tip(&mut self, sequencer: C::PublicKey) -> Option<(u64, Epoch)> {
         let (sender, receiver) = oneshot::channel();
         self.sender

consensus/src/ordered_broadcast/mocks/reporter.rs

@@ -1,21 +1,20 @@
 use crate::{ordered_broadcast::types::Epoch, Supervisor, ThresholdSupervisor};
-use commonware_cryptography::bls12381::primitives::{
-    group::{self, Public, Share},
-    poly::Poly,
-};
+use commonware_cryptography::bls12381::primitives::{group::Share, poly::Public, variant::Variant};
 use commonware_utils::Array;
-use std::collections::HashMap;
+use std::{collections::HashMap, marker::PhantomData};
 
 #[derive(Clone)]
-pub struct Validators<P: Array> {
-    identity: Poly<Public>,
+pub struct Validators<P: Array, V: Variant> {
+    identity: Public<V>,
     validators: Vec<P>,
     validators_map: HashMap<P, u32>,
     share: Option<Share>,
+
+    _phantom: PhantomData<V>,
 }
 
-impl<P: Array> Validators<P> {
-    pub fn new(identity: Poly<Public>, mut validators: Vec<P>, share: Option<Share>) -> Self {
+impl<P: Array, V: Variant> Validators<P, V> {
+    pub fn new(identity: Public<V>, mut validators: Vec<P>, share: Option<Share>) -> Self {
         // Setup validators
         validators.sort();
         let mut validators_map = HashMap::new();
@@ -28,11 +27,13 @@ impl<P: Array> Validators<P> {
             validators,
             validators_map,
             share,
+
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<P: Array> Supervisor for Validators<P> {
+impl<P: Array, V: Variant> Supervisor for Validators<P, V> {
     type Index = Epoch;
     type PublicKey = P;
 
@@ -49,10 +50,10 @@ impl<P: Array> Supervisor for Validators<P> {
     }
 }
 
-impl<P: Array> ThresholdSupervisor for Validators<P> {
-    type Identity = Poly<Public>;
+impl<P: Array, V: Variant> ThresholdSupervisor for Validators<P, V> {
+    type Identity = Public<V>;
     type Share = Share;
-    type Seed = group::Signature;
+    type Seed = V::Signature;
 
     fn leader(&self, _: Self::Index, _: Self::Seed) -> Option<Self::PublicKey> {
         unimplemented!()