Skip to main content

wsts/state_machine/signer/
mod.rs

1use core::num::TryFromIntError;
2use hashbrown::{HashMap, HashSet};
3use rand_core::{CryptoRng, RngCore};
4use std::{
5    collections::{BTreeMap, BTreeSet},
6    fmt,
7};
8use tracing::{debug, error, info, trace, warn};
9
10use crate::{
11    common::{
12        check_public_shares, validate_key_id, validate_signer_id, PolyCommitment, PublicNonce,
13        TupleProof,
14    },
15    curve::{
16        ecdsa,
17        point::{Error as PointError, Point, G},
18        scalar::Scalar,
19    },
20    errors::{DkgError, EncryptionError},
21    net::{
22        BadPrivateShare, DkgBegin, DkgEnd, DkgEndBegin, DkgFailure, DkgPrivateBegin,
23        DkgPrivateShares, DkgPrivateSharesDone, DkgPrivateSharesDoneAck, DkgPublicShares,
24        DkgPublicSharesDone, DkgPublicSharesDoneAck, DkgStatus, Message, NonceRequest,
25        NonceResponse, Packet, SignatureShareRequest, SignatureShareResponse, SignatureType,
26    },
27    state_machine::{PublicKeys, StateMachine},
28    traits::{Signer as SignerTrait, SignerState as SignerSavedState},
29    util::{decrypt, encrypt, make_shared_secret},
30};
31
32#[cfg(any(test, feature = "testing"))]
33use crate::net::Signable;
34
35#[derive(Debug, Clone, PartialEq)]
36/// Signer states
37pub enum State {
38    /// The signer is idle
39    Idle,
40    /// The signer is distributing DKG public shares
41    DkgPublicDistribute,
42    /// The signer is gathering DKG public shares
43    DkgPublicGather,
44    /// The signer has acknowledged DkgPublicSharesDone and is waiting for DkgPrivateBegin
45    DkgPublicSharesDoneAck,
46    /// The signer is distributing DKG private shares
47    DkgPrivateDistribute,
48    /// The signer is gathering DKG private shares
49    DkgPrivateGather,
50    /// The signer has acknowledged DkgPrivateSharesDone and is waiting for DkgEndBegin
51    DkgPrivateSharesDoneAck,
52    /// The signer has sent a nonce and is waiting for a signature share request
53    SignGather,
54}
55
56#[derive(thiserror::Error, Clone, Debug)]
57/// Config errors for a signer
58pub enum ConfigError {
59    /// Insufficient keys for the number of signers
60    #[error("Insufficient keys for the number of signers")]
61    InsufficientKeys,
62    /// The threshold was invalid
63    #[error("InvalidThreshold")]
64    InvalidThreshold,
65    /// The signer ID was invalid
66    #[error("Invalid signer ID {0}")]
67    InvalidSignerId(u32),
68    /// The key ID was invalid
69    #[error("Invalid key ID {0}")]
70    InvalidKeyId(u32),
71}
72
73#[derive(thiserror::Error, Clone, Debug)]
74/// The error type for a signer
75pub enum Error {
76    /// Config error
77    #[error("Config error {0}")]
78    Config(#[from] ConfigError),
79    /// The party ID was invalid
80    #[error("InvalidPartyID")]
81    InvalidPartyID,
82    /// A DKG public share was invalid
83    #[error("InvalidDkgPublicShares")]
84    InvalidDkgPublicShares,
85    /// A DKG private share was invalid
86    #[error("InvalidDkgPrivateShares")]
87    InvalidDkgPrivateShares(Vec<u32>),
88    /// A nonce response was invalid
89    #[error("InvalidNonceResponse")]
90    InvalidNonceResponse,
91    /// A signature share was invalid
92    #[error("InvalidSignatureShare")]
93    InvalidSignatureShare,
94    /// A bad state change was made
95    #[error("Bad State Change: {0}")]
96    BadStateChange(String),
97    /// An encryption error occurred
98    #[error("Encryption error: {0}")]
99    Encryption(#[from] EncryptionError),
100    #[error("integer conversion error")]
101    /// An error during integer conversion operations
102    TryFromInt(#[from] TryFromIntError),
103    #[error("Missing coordinator public key")]
104    /// Missing coordinator public key
105    MissingCoordinatorPublicKey,
106    #[error("A packet had an invalid signature")]
107    /// A packet had an invalid signature
108    InvalidPacketSignature,
109    #[error("A curve point error {0}")]
110    /// A curve point error
111    Point(#[from] PointError),
112    #[error("missing kex public key for key_id {0}")]
113    /// Missing KEX public key for a key_id
114    MissingKexPublicKey(u32),
115}
116
117/// The saved state required to reconstruct a signer
118#[derive(Clone)]
119pub struct SavedState {
120    /// current DKG round ID
121    pub dkg_id: u64,
122    /// current signing round ID
123    pub sign_id: u64,
124    /// current signing iteration ID
125    pub sign_iter_id: u64,
126    /// the threshold of the keys needed for a valid signature
127    pub threshold: u32,
128    /// the threshold of the keys needed for a valid DKG
129    pub dkg_threshold: u32,
130    /// the total number of signers
131    pub total_signers: u32,
132    /// the total number of keys
133    pub total_keys: u32,
134    /// the Signer object
135    pub signer: SignerSavedState,
136    /// the Signer ID
137    pub signer_id: u32,
138    /// the current state
139    pub state: State,
140    /// map of polynomial commitments for each party
141    /// party_id => PolyCommitment
142    pub commitments: HashMap<u32, PolyCommitment>,
143    /// map of decrypted DKG private shares
144    /// src_party_id => (dst_key_id => private_share)
145    decrypted_shares: HashMap<u32, HashMap<u32, Scalar>>,
146    /// shared secrets used to decrypt private shares
147    /// src_party_id => (signer_id, dh shared key)
148    decryption_keys: HashMap<u32, (u32, Point)>,
149    /// invalid private shares
150    /// signer_id => {shared_key, tuple_proof}
151    pub invalid_private_shares: HashMap<u32, BadPrivateShare>,
152    /// public nonces for this signing round
153    pub public_nonces: Vec<PublicNonce>,
154    /// the private key used to sign messages sent over the network
155    network_private_key: Scalar,
156    /// the public keys for all signers and coordinator
157    pub public_keys: PublicKeys,
158    /// the DKG public shares received in this round
159    pub dkg_public_shares: BTreeMap<u32, DkgPublicShares>,
160    /// the DKG private shares received in this round
161    pub dkg_private_shares: BTreeMap<u32, DkgPrivateShares>,
162    /// the DKG private begin message received in this round
163    pub dkg_private_begin_msg: Option<DkgPrivateBegin>,
164    /// the DKG end begin message received in this round
165    pub dkg_end_begin_msg: Option<DkgEndBegin>,
166    /// pending DkgPublicSharesDone waiting for all public shares to arrive
167    pending_public_shares_done: Option<DkgPublicSharesDone>,
168    /// pending DkgPrivateSharesDone waiting for all private shares to arrive
169    pending_private_shares_done: Option<DkgPrivateSharesDone>,
170    /// whether to verify the signature on Packets
171    pub verify_packet_sigs: bool,
172    /// coordinator public key
173    pub coordinator_public_key: Option<ecdsa::PublicKey>,
174    /// Ephemeral private key for key exchange
175    kex_private_key: Scalar,
176    /// Ephemeral public keys for key exchange indexed by key_id
177    kex_public_keys: HashMap<u32, Point>,
178    /// whether this signer successfully completed DKG for the current dkg_id
179    dkg_completed: bool,
180}
181
182impl fmt::Debug for SavedState {
183    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
184        f.debug_struct("SavedState")
185            .field("dkg_id", &self.dkg_id)
186            .field("sign_id", &self.sign_id)
187            .field("sign_iter_id", &self.sign_iter_id)
188            .field("threshold", &self.threshold)
189            .field("dkg_threshold", &self.dkg_threshold)
190            .field("total_signers", &self.total_signers)
191            .field("total_keys", &self.total_keys)
192            .field("signer", &self.signer)
193            .field("signer_id", &self.signer_id)
194            .field("state", &self.state)
195            .field("commitments", &self.commitments)
196            .field("invalid_private_shares", &self.invalid_private_shares)
197            .field("public_nonces", &self.public_nonces)
198            .field("public_keys", &self.public_keys)
199            .field("dkg_public_shares", &self.dkg_public_shares)
200            .field("dkg_private_begin_msg", &self.dkg_private_begin_msg)
201            .field("dkg_end_begin_msg", &self.dkg_end_begin_msg)
202            .finish_non_exhaustive()
203    }
204}
205
206/// A state machine for a signing round
207#[derive(Clone, PartialEq)]
208pub struct Signer<SignerType: SignerTrait> {
209    /// current DKG round ID
210    pub dkg_id: u64,
211    /// current signing round ID
212    pub sign_id: u64,
213    /// current signing iteration ID
214    pub sign_iter_id: u64,
215    /// the threshold of the keys needed for a valid signature
216    pub threshold: u32,
217    /// the threshold of the keys needed for a valid DKG
218    pub dkg_threshold: u32,
219    /// the total number of signers
220    pub total_signers: u32,
221    /// the total number of keys
222    pub total_keys: u32,
223    /// the Signer object
224    pub signer: SignerType,
225    /// the Signer ID
226    pub signer_id: u32,
227    /// the current state
228    pub state: State,
229    /// map of polynomial commitments for each party
230    /// party_id => PolyCommitment
231    pub commitments: HashMap<u32, PolyCommitment>,
232    /// map of decrypted DKG private shares
233    /// src_party_id => (dst_key_id => private_share)
234    pub decrypted_shares: HashMap<u32, HashMap<u32, Scalar>>,
235    /// shared secrets used to decrypt private shares
236    /// src_party_id => (signer_id, dh shared key)
237    pub decryption_keys: HashMap<u32, (u32, Point)>,
238    /// invalid private shares
239    /// signer_id => {shared_key, tuple_proof}
240    pub invalid_private_shares: HashMap<u32, BadPrivateShare>,
241    /// public nonces for this signing round
242    pub public_nonces: Vec<PublicNonce>,
243    /// the private key used to sign messages sent over the network
244    pub network_private_key: Scalar,
245    /// the public keys for all signers and coordinator
246    pub public_keys: PublicKeys,
247    /// the DKG public shares received in this round
248    pub dkg_public_shares: BTreeMap<u32, DkgPublicShares>,
249    /// the DKG private shares received in this round
250    pub dkg_private_shares: BTreeMap<u32, DkgPrivateShares>,
251    /// the DKG private begin message received in this round
252    pub dkg_private_begin_msg: Option<DkgPrivateBegin>,
253    /// the DKG end begin message received in this round
254    pub dkg_end_begin_msg: Option<DkgEndBegin>,
255    /// pending DkgPublicSharesDone waiting for all public shares to arrive
256    pending_public_shares_done: Option<DkgPublicSharesDone>,
257    /// pending DkgPrivateSharesDone waiting for all private shares to arrive
258    pending_private_shares_done: Option<DkgPrivateSharesDone>,
259    /// whether to verify the signature on Packets
260    pub verify_packet_sigs: bool,
261    /// coordinator public key
262    pub coordinator_public_key: Option<ecdsa::PublicKey>,
263    /// Ephemeral private key for key exchange
264    kex_private_key: Scalar,
265    /// Ephemeral public keys for key exchange indexed by key_id
266    kex_public_keys: HashMap<u32, Point>,
267    /// whether this signer successfully completed DKG for the current dkg_id
268    dkg_completed: bool,
269}
270
271impl<SignerType: SignerTrait> fmt::Debug for Signer<SignerType> {
272    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
273        f.debug_struct("Signer")
274            .field("dkg_id", &self.dkg_id)
275            .field("sign_id", &self.sign_id)
276            .field("sign_iter_id", &self.sign_iter_id)
277            .field("threshold", &self.threshold)
278            .field("dkg_threshold", &self.dkg_threshold)
279            .field("total_signers", &self.total_signers)
280            .field("total_keys", &self.total_keys)
281            .field("signer", &self.signer)
282            .field("signer_id", &self.signer_id)
283            .field("state", &self.state)
284            .field("commitments", &self.commitments)
285            .field("invalid_private_shares", &self.invalid_private_shares)
286            .field("public_nonces", &self.public_nonces)
287            .field("public_keys", &self.public_keys)
288            .field("dkg_public_shares", &self.dkg_public_shares)
289            .field("dkg_private_begin_msg", &self.dkg_private_begin_msg)
290            .field("dkg_end_begin_msg", &self.dkg_end_begin_msg)
291            .finish_non_exhaustive()
292    }
293}
294
295impl<SignerType: SignerTrait> Signer<SignerType> {
296    /// create a Signer
297    #[allow(clippy::too_many_arguments)]
298    pub fn new<R: RngCore + CryptoRng>(
299        threshold: u32,
300        dkg_threshold: u32,
301        total_signers: u32,
302        total_keys: u32,
303        signer_id: u32,
304        key_ids: Vec<u32>,
305        network_private_key: Scalar,
306        public_keys: PublicKeys,
307        rng: &mut R,
308    ) -> Result<Self, Error> {
309        if total_signers > total_keys {
310            return Err(Error::Config(ConfigError::InsufficientKeys));
311        }
312
313        if threshold == 0 || threshold > total_keys {
314            return Err(Error::Config(ConfigError::InvalidThreshold));
315        }
316
317        if dkg_threshold == 0 || dkg_threshold < threshold {
318            return Err(Error::Config(ConfigError::InvalidThreshold));
319        }
320
321        if !validate_signer_id(signer_id, total_signers) {
322            return Err(Error::Config(ConfigError::InvalidSignerId(signer_id)));
323        }
324
325        for key_id in &key_ids {
326            if !validate_key_id(*key_id, total_keys) {
327                return Err(Error::Config(ConfigError::InvalidKeyId(*key_id)));
328            }
329        }
330
331        public_keys.validate(total_signers, total_keys)?;
332
333        let mut signer = SignerType::new(
334            signer_id,
335            &key_ids,
336            total_signers,
337            total_keys,
338            threshold,
339            rng,
340        );
341
342        // immediately generate nonces with good entropy to avoid protocol attacks
343        signer.gen_nonces(&network_private_key, rng);
344
345        debug!("new Signer for signer_id {signer_id} with key_ids {key_ids:?}");
346        Ok(Self {
347            dkg_id: 0,
348            sign_id: 1,
349            sign_iter_id: 1,
350            threshold,
351            dkg_threshold,
352            total_signers,
353            total_keys,
354            signer,
355            signer_id,
356            state: State::Idle,
357            commitments: Default::default(),
358            decrypted_shares: Default::default(),
359            decryption_keys: Default::default(),
360            invalid_private_shares: Default::default(),
361            public_nonces: vec![],
362            network_private_key,
363            public_keys,
364            dkg_public_shares: Default::default(),
365            dkg_private_shares: Default::default(),
366            dkg_private_begin_msg: Default::default(),
367            dkg_end_begin_msg: Default::default(),
368            pending_public_shares_done: None,
369            pending_private_shares_done: None,
370            verify_packet_sigs: true,
371            coordinator_public_key: None,
372            kex_private_key: Scalar::random(rng),
373            kex_public_keys: Default::default(),
374            dkg_completed: false,
375        })
376    }
377
378    /// Load a coordinator from the previously saved `state`
379    pub fn load(state: &SavedState) -> Self {
380        Self {
381            dkg_id: state.dkg_id,
382            sign_id: state.sign_id,
383            sign_iter_id: state.sign_iter_id,
384            threshold: state.threshold,
385            dkg_threshold: state.dkg_threshold,
386            total_signers: state.total_signers,
387            total_keys: state.total_keys,
388            signer: SignerType::load(&state.signer),
389            signer_id: state.signer_id,
390            state: state.state.clone(),
391            commitments: state.commitments.clone(),
392            decrypted_shares: state.decrypted_shares.clone(),
393            decryption_keys: state.decryption_keys.clone(),
394            invalid_private_shares: state.invalid_private_shares.clone(),
395            public_nonces: state.public_nonces.clone(),
396            network_private_key: state.network_private_key,
397            public_keys: state.public_keys.clone(),
398            dkg_public_shares: state.dkg_public_shares.clone(),
399            dkg_private_shares: state.dkg_private_shares.clone(),
400            dkg_private_begin_msg: state.dkg_private_begin_msg.clone(),
401            dkg_end_begin_msg: state.dkg_end_begin_msg.clone(),
402            pending_public_shares_done: state.pending_public_shares_done.clone(),
403            pending_private_shares_done: state.pending_private_shares_done.clone(),
404            verify_packet_sigs: state.verify_packet_sigs,
405            coordinator_public_key: state.coordinator_public_key,
406            kex_private_key: state.kex_private_key,
407            kex_public_keys: state.kex_public_keys.clone(),
408            dkg_completed: state.dkg_completed,
409        }
410    }
411
412    /// Save the state required to reconstruct the coordinator
413    pub fn save(&self) -> SavedState {
414        SavedState {
415            dkg_id: self.dkg_id,
416            sign_id: self.sign_id,
417            sign_iter_id: self.sign_iter_id,
418            threshold: self.threshold,
419            dkg_threshold: self.dkg_threshold,
420            total_signers: self.total_signers,
421            total_keys: self.total_keys,
422            signer: self.signer.save(),
423            signer_id: self.signer_id,
424            state: self.state.clone(),
425            commitments: self.commitments.clone(),
426            decrypted_shares: self.decrypted_shares.clone(),
427            decryption_keys: self.decryption_keys.clone(),
428            invalid_private_shares: self.invalid_private_shares.clone(),
429            public_nonces: self.public_nonces.clone(),
430            network_private_key: self.network_private_key,
431            public_keys: self.public_keys.clone(),
432            dkg_public_shares: self.dkg_public_shares.clone(),
433            dkg_private_shares: self.dkg_private_shares.clone(),
434            dkg_private_begin_msg: self.dkg_private_begin_msg.clone(),
435            dkg_end_begin_msg: self.dkg_end_begin_msg.clone(),
436            pending_public_shares_done: self.pending_public_shares_done.clone(),
437            pending_private_shares_done: self.pending_private_shares_done.clone(),
438            verify_packet_sigs: self.verify_packet_sigs,
439            coordinator_public_key: self.coordinator_public_key,
440            kex_private_key: self.kex_private_key,
441            kex_public_keys: self.kex_public_keys.clone(),
442            dkg_completed: self.dkg_completed,
443        }
444    }
445
446    /// Reset internal state
447    pub fn reset<T: RngCore + CryptoRng>(&mut self, dkg_id: u64, rng: &mut T) {
448        self.dkg_id = dkg_id;
449        self.commitments.clear();
450        self.decrypted_shares.clear();
451        self.decryption_keys.clear();
452        self.invalid_private_shares.clear();
453        self.public_nonces.clear();
454        self.signer.reset_polys(rng);
455        self.dkg_public_shares.clear();
456        self.dkg_private_shares.clear();
457        self.dkg_private_begin_msg = None;
458        self.dkg_end_begin_msg = None;
459        self.pending_public_shares_done = None;
460        self.pending_private_shares_done = None;
461        self.kex_private_key = Scalar::random(rng);
462        self.kex_public_keys.clear();
463        self.dkg_completed = false;
464        self.state = State::Idle;
465    }
466
467    /// Process the slice of packets
468    #[cfg(any(test, feature = "testing"))]
469    pub fn process_inbound_messages<R: RngCore + CryptoRng>(
470        &mut self,
471        packets: &[Packet],
472        rng: &mut R,
473    ) -> Result<Vec<Packet>, Error> {
474        let mut responses = vec![];
475        for packet in packets {
476            let outbounds = self.process(packet, rng)?;
477            for out in outbounds {
478                let msg = Packet {
479                    sig: out
480                        .sign(&self.network_private_key)
481                        .expect("Failed to sign message"),
482                    msg: out,
483                };
484                responses.push(msg);
485            }
486        }
487        Ok(responses)
488    }
489
490    /// process the passed incoming message, and return any outgoing messages needed in response
491    pub fn process<R: RngCore + CryptoRng>(
492        &mut self,
493        packet: &Packet,
494        rng: &mut R,
495    ) -> Result<Vec<Message>, Error> {
496        if self.verify_packet_sigs {
497            let Some(coordinator_public_key) = self.coordinator_public_key else {
498                return Err(Error::MissingCoordinatorPublicKey);
499            };
500            if !packet.verify(&self.public_keys, &coordinator_public_key) {
501                return Err(Error::InvalidPacketSignature);
502            }
503        }
504        let out_msgs = match (&self.state, &packet.msg) {
505            // DkgBegin restarts DKG from any state
506            (_, Message::DkgBegin(msg)) => self.dkg_begin(msg, rng),
507            // DKG public phase
508            (State::DkgPublicGather, Message::DkgPublicShares(msg)) => self.dkg_public_share(msg),
509            (State::DkgPublicGather, Message::DkgPublicSharesDone(msg)) => {
510                self.dkg_public_shares_done(msg)
511            }
512            // DKG private phase
513            (State::DkgPublicSharesDoneAck, Message::DkgPrivateBegin(msg)) => {
514                self.dkg_private_begin(msg, rng)
515            }
516            (State::DkgPrivateGather, Message::DkgPrivateShares(msg)) => {
517                self.dkg_private_shares(msg, rng)
518            }
519            (State::DkgPrivateGather, Message::DkgPrivateSharesDone(msg)) => {
520                self.dkg_private_shares_done(msg)
521            }
522            // DKG end phase: by the time we reach DkgPrivateSharesDoneAck we have all
523            // public and private shares, so DkgEndBegin directly triggers dkg_ended
524            (State::DkgPrivateSharesDoneAck, Message::DkgEndBegin(msg)) => {
525                let mut out = self.dkg_end_begin(msg)?;
526                out.push(self.dkg_ended(rng)?);
527                self.move_to(State::Idle)?;
528                Ok(out)
529            }
530            // Signing phase: NonceRequest accepted from Idle or SignGather (coordinator retry)
531            (State::Idle | State::SignGather, Message::NonceRequest(msg)) => {
532                self.nonce_request(msg, rng)
533            }
534            (State::SignGather, Message::SignatureShareRequest(msg)) => {
535                self.sign_share_request(msg, rng)
536            }
537            // Messages signers never process
538            (
539                _,
540                Message::DkgEnd(_)
541                | Message::DkgPublicSharesDoneAck(_)
542                | Message::DkgPrivateSharesDoneAck(_)
543                | Message::NonceResponse(_)
544                | Message::SignatureShareResponse(_),
545            ) => Ok(vec![]),
546            // Unexpected state+message combination
547            (state, msg) => {
548                warn!(
549                    signer_id = %self.signer_id,
550                    ?state,
551                    msg_type = ?std::mem::discriminant(msg),
552                    "unexpected message in state, dropping"
553                );
554                Ok(vec![])
555            }
556        };
557
558        out_msgs
559    }
560
561    /// DKG is done so compute secrets
562    pub fn dkg_ended<R: RngCore + CryptoRng>(&mut self, rng: &mut R) -> Result<Message, Error> {
563        if !self.can_dkg_end() {
564            return Ok(Message::DkgEnd(DkgEnd {
565                dkg_id: self.dkg_id,
566                signer_id: self.signer_id,
567                status: DkgStatus::Failure(DkgFailure::BadState),
568            }));
569        }
570
571        // only use the public shares from the DkgEndBegin signers
572        let mut missing_public_shares = HashSet::new();
573        let mut missing_private_shares = HashSet::new();
574        let mut bad_public_shares = HashSet::new();
575        let threshold: usize = self.threshold.try_into().unwrap();
576
577        let Some(dkg_end_begin) = &self.dkg_end_begin_msg else {
578            // no cached DkgEndBegin message
579            return Ok(Message::DkgEnd(DkgEnd {
580                dkg_id: self.dkg_id,
581                signer_id: self.signer_id,
582                status: DkgStatus::Failure(DkgFailure::BadState),
583            }));
584        };
585
586        // fist check to see if dkg_threshold has been met
587        let signer_ids_set: HashSet<u32> = dkg_end_begin
588            .signer_ids
589            .iter()
590            .filter(|&&id| id < self.total_signers)
591            .copied()
592            .collect::<HashSet<u32>>();
593        let mut num_dkg_keys = 0u32;
594        for id in &signer_ids_set {
595            if let Some(key_ids) = self.public_keys.signer_key_ids.get(id) {
596                let len: u32 = key_ids.len().try_into()?;
597                num_dkg_keys = num_dkg_keys.saturating_add(len);
598            }
599        }
600
601        if num_dkg_keys < self.dkg_threshold {
602            return Ok(Message::DkgEnd(DkgEnd {
603                dkg_id: self.dkg_id,
604                signer_id: self.signer_id,
605                status: DkgStatus::Failure(DkgFailure::Threshold),
606            }));
607        }
608
609        for signer_id in &signer_ids_set {
610            if let Some(shares) = self.dkg_public_shares.get(signer_id) {
611                if shares.comms.is_empty() {
612                    missing_public_shares.insert(*signer_id);
613                } else {
614                    for (party_id, comm) in shares.comms.iter() {
615                        if !check_public_shares(comm, threshold, &self.dkg_id.to_be_bytes()) {
616                            bad_public_shares.insert(*signer_id);
617                        } else {
618                            self.commitments.insert(*party_id, comm.clone());
619                        }
620                    }
621                }
622            } else {
623                missing_public_shares.insert(*signer_id);
624            }
625            if let Some(shares) = self.dkg_private_shares.get(signer_id) {
626                // signer_id sent shares, but make sure that it sent shares for every one of this signer's key_ids
627                if shares.shares.is_empty() {
628                    missing_private_shares.insert(*signer_id);
629                } else {
630                    for dst_key_id in self.signer.get_key_ids() {
631                        for (_src_key_id, shares) in &shares.shares {
632                            if shares.get(&dst_key_id).is_none() {
633                                missing_private_shares.insert(*signer_id);
634                            }
635                        }
636                    }
637                }
638            } else {
639                missing_private_shares.insert(*signer_id);
640            }
641        }
642
643        if !missing_public_shares.is_empty() {
644            return Ok(Message::DkgEnd(DkgEnd {
645                dkg_id: self.dkg_id,
646                signer_id: self.signer_id,
647                status: DkgStatus::Failure(DkgFailure::MissingPublicShares(missing_public_shares)),
648            }));
649        }
650
651        if !bad_public_shares.is_empty() {
652            return Ok(Message::DkgEnd(DkgEnd {
653                dkg_id: self.dkg_id,
654                signer_id: self.signer_id,
655                status: DkgStatus::Failure(DkgFailure::BadPublicShares(bad_public_shares)),
656            }));
657        }
658
659        if !missing_private_shares.is_empty() {
660            return Ok(Message::DkgEnd(DkgEnd {
661                dkg_id: self.dkg_id,
662                signer_id: self.signer_id,
663                status: DkgStatus::Failure(DkgFailure::MissingPrivateShares(
664                    missing_private_shares,
665                )),
666            }));
667        }
668
669        let dkg_end = if self.invalid_private_shares.is_empty() {
670            match self.signer.compute_secrets(
671                &self.decrypted_shares,
672                &self.commitments,
673                &self.dkg_id.to_be_bytes(),
674            ) {
675                Ok(()) => DkgEnd {
676                    dkg_id: self.dkg_id,
677                    signer_id: self.signer_id,
678                    status: DkgStatus::Success,
679                },
680                Err(dkg_error_map) => {
681                    // we've handled everything except BadPrivateShares and Point both of which should map to DkgFailure::BadPrivateShares
682                    let mut bad_private_shares = HashMap::new();
683                    for (_my_party_id, dkg_error) in dkg_error_map {
684                        if let DkgError::BadPrivateShares(party_ids) = dkg_error {
685                            for party_id in party_ids {
686                                if let Some((party_signer_id, _shared_key)) =
687                                    &self.decryption_keys.get(&party_id)
688                                {
689                                    bad_private_shares.insert(
690                                        *party_signer_id,
691                                        self.make_bad_private_share(*party_signer_id, rng)?,
692                                    );
693                                } else {
694                                    warn!("DkgError::BadPrivateShares from party_id {party_id} but no (signer_id, shared_secret) cached");
695                                }
696                            }
697                        } else {
698                            warn!("Got unexpected dkg_error {dkg_error:?}");
699                        }
700                    }
701                    DkgEnd {
702                        dkg_id: self.dkg_id,
703                        signer_id: self.signer_id,
704                        status: DkgStatus::Failure(DkgFailure::BadPrivateShares(
705                            bad_private_shares,
706                        )),
707                    }
708                }
709            }
710        } else {
711            DkgEnd {
712                dkg_id: self.dkg_id,
713                signer_id: self.signer_id,
714                status: DkgStatus::Failure(DkgFailure::BadPrivateShares(
715                    self.invalid_private_shares.clone(),
716                )),
717            }
718        };
719
720        if matches!(dkg_end.status, DkgStatus::Success) {
721            self.dkg_completed = true;
722        }
723
724        info!(
725            signer_id = %self.signer_id,
726            dkg_id = %self.dkg_id,
727            status = ?dkg_end.status,
728            "sending DkgEnd"
729        );
730
731        let dkg_end = Message::DkgEnd(dkg_end);
732        Ok(dkg_end)
733    }
734
735    /// do we have all DkgPublicShares?
736    pub fn public_shares_done(&self) -> bool {
737        debug!(
738            "public_shares_done state {:?} commitments {}",
739            self.state,
740            self.commitments.len(),
741        );
742        self.state == State::DkgPublicGather
743            && self.commitments.len() == usize::try_from(self.signer.get_num_parties()).unwrap()
744    }
745
746    /// do we have all DkgPublicShares and DkgPrivateShares?
747    pub fn can_dkg_end(&self) -> bool {
748        debug!(
749            "can_dkg_end: state {:?} DkgPrivateBegin {} DkgEndBegin {}",
750            self.state,
751            self.dkg_private_begin_msg.is_some(),
752            self.dkg_end_begin_msg.is_some(),
753        );
754
755        if self.state == State::DkgPrivateGather || self.state == State::DkgPrivateSharesDoneAck {
756            if let Some(dkg_private_begin) = &self.dkg_private_begin_msg {
757                // need public shares from active signers
758                for signer_id in &dkg_private_begin.signer_ids {
759                    if !self.dkg_public_shares.contains_key(signer_id) {
760                        debug!("can_dkg_end: false, missing public shares from signer {signer_id}");
761                        return false;
762                    }
763                }
764
765                if let Some(dkg_end_begin) = &self.dkg_end_begin_msg {
766                    // need private shares from active signers
767                    for signer_id in &dkg_end_begin.signer_ids {
768                        if !self.dkg_private_shares.contains_key(signer_id) {
769                            debug!("can_dkg_end: false, missing private shares from signer {signer_id}");
770                            return false;
771                        }
772                    }
773                    debug!("can_dkg_end: true");
774
775                    return true;
776                }
777            }
778        } else {
779            debug!("can_dkg_end: false, bad state {:?}", self.state);
780            return false;
781        }
782        false
783    }
784
785    fn nonce_request<R: RngCore + CryptoRng>(
786        &mut self,
787        nonce_request: &NonceRequest,
788        rng: &mut R,
789    ) -> Result<Vec<Message>, Error> {
790        if nonce_request.dkg_id != self.dkg_id {
791            warn!(
792                signer_id = %self.signer_id,
793                got = %nonce_request.dkg_id,
794                expected = %self.dkg_id,
795                "NonceRequest dkg_id mismatch"
796            );
797            return Ok(vec![]);
798        }
799        if !self.dkg_completed {
800            warn!(
801                signer_id = %self.signer_id,
802                dkg_id = %self.dkg_id,
803                "NonceRequest rejected: DKG not completed"
804            );
805            return Ok(vec![]);
806        }
807        let mut msgs = vec![];
808        let signer_id = self.signer_id;
809        let key_ids = self.signer.get_key_ids();
810        let nonces = self.signer.gen_nonces(&self.network_private_key, rng);
811
812        let response = NonceResponse {
813            dkg_id: nonce_request.dkg_id,
814            sign_id: nonce_request.sign_id,
815            sign_iter_id: nonce_request.sign_iter_id,
816            signer_id,
817            key_ids,
818            nonces,
819            message: nonce_request.message.clone(),
820        };
821
822        let response = Message::NonceResponse(response);
823
824        info!(
825            %signer_id,
826            dkg_id = %nonce_request.dkg_id,
827            sign_id = %nonce_request.sign_id,
828            sign_iter_id = %nonce_request.sign_iter_id,
829            "sending NonceResponse"
830        );
831        msgs.push(response);
832        self.move_to(State::SignGather)?;
833
834        Ok(msgs)
835    }
836
837    fn sign_share_request<R: RngCore + CryptoRng>(
838        &mut self,
839        sign_request: &SignatureShareRequest,
840        rng: &mut R,
841    ) -> Result<Vec<Message>, Error> {
842        if sign_request.dkg_id != self.dkg_id {
843            warn!(
844                signer_id = %self.signer_id,
845                got = %sign_request.dkg_id,
846                expected = %self.dkg_id,
847                "SignatureShareRequest dkg_id mismatch"
848            );
849            return Ok(vec![]);
850        }
851        if !self.dkg_completed {
852            warn!(
853                signer_id = %self.signer_id,
854                dkg_id = %self.dkg_id,
855                "SignatureShareRequest rejected: DKG not completed"
856            );
857            return Ok(vec![]);
858        }
859        let signer_id_set = sign_request
860            .nonce_responses
861            .iter()
862            .map(|nr| nr.signer_id)
863            .collect::<BTreeSet<u32>>();
864
865        // The expected usage is that Signer IDs start at zero and
866        // increment by one until self.total_signers - 1. So the checks
867        // here should be sufficient for catching empty signer ID sets,
868        // duplicate signer IDs, or unknown signer IDs.
869        let is_invalid_request = sign_request.nonce_responses.len() != signer_id_set.len()
870            || signer_id_set.is_empty()
871            || signer_id_set.last() >= Some(&self.total_signers);
872
873        if is_invalid_request {
874            warn!("received an invalid SignatureShareRequest");
875            return Err(Error::InvalidNonceResponse);
876        }
877
878        let nonces = sign_request
879            .nonce_responses
880            .iter()
881            .flat_map(|nr| nr.nonces.clone())
882            .collect::<Vec<PublicNonce>>();
883
884        for nonce in &nonces {
885            if !nonce.is_valid() {
886                warn!(
887                    signer_id = %self.signer_id,
888                    "received an SignatureShareRequest with invalid nonce"
889                );
890                return Err(Error::InvalidNonceResponse);
891            }
892        }
893
894        debug!(signer_id = %self.signer_id, "received a valid SignatureShareRequest");
895
896        if signer_id_set.contains(&self.signer_id) {
897            let key_ids: Vec<u32> = sign_request
898                .nonce_responses
899                .iter()
900                .flat_map(|nr| nr.key_ids.iter().copied())
901                .collect::<Vec<u32>>();
902
903            let signer_ids = signer_id_set.into_iter().collect::<Vec<_>>();
904            let msg = &sign_request.message;
905            let signature_shares = match sign_request.signature_type {
906                SignatureType::Taproot(merkle_root) => {
907                    self.signer
908                        .sign_taproot(msg, &signer_ids, &key_ids, &nonces, merkle_root)
909                }
910                SignatureType::Schnorr => {
911                    self.signer
912                        .sign_schnorr(msg, &signer_ids, &key_ids, &nonces)
913                }
914                SignatureType::Frost => self.signer.sign(msg, &signer_ids, &key_ids, &nonces),
915            };
916
917            self.signer.gen_nonces(&self.network_private_key, rng);
918
919            let response = SignatureShareResponse {
920                dkg_id: sign_request.dkg_id,
921                sign_id: sign_request.sign_id,
922                sign_iter_id: sign_request.sign_iter_id,
923                signer_id: self.signer_id,
924                signature_shares,
925            };
926            info!(
927                signer_id = %self.signer_id,
928                dkg_id = %sign_request.dkg_id,
929                sign_id = %sign_request.sign_id,
930                sign_iter_id = %sign_request.sign_iter_id,
931                "sending SignatureShareResponse"
932            );
933
934            self.move_to(State::Idle)?;
935            Ok(vec![Message::SignatureShareResponse(response)])
936        } else {
937            debug!(signer_id = %self.signer_id, "signer not included in SignatureShareRequest");
938            self.move_to(State::Idle)?;
939            Ok(Vec::new())
940        }
941    }
942
943    fn dkg_begin<R: RngCore + CryptoRng>(
944        &mut self,
945        dkg_begin: &DkgBegin,
946        rng: &mut R,
947    ) -> Result<Vec<Message>, Error> {
948        self.reset(dkg_begin.dkg_id, rng);
949        self.move_to(State::DkgPublicDistribute)?;
950
951        self.dkg_public_begin(rng)
952    }
953
954    fn dkg_public_shares_done(&mut self, msg: &DkgPublicSharesDone) -> Result<Vec<Message>, Error> {
955        if msg.dkg_id != self.dkg_id {
956            warn!(
957                signer_id = %self.signer_id,
958                got = %msg.dkg_id,
959                expected = %self.dkg_id,
960                "DkgPublicSharesDone dkg_id mismatch"
961            );
962            return Ok(vec![]);
963        }
964        // Reject any unknown signer IDs
965        let unknown_ids: Vec<u32> = msg
966            .signer_ids
967            .iter()
968            .filter(|id| !self.public_keys.signers.contains_key(*id))
969            .copied()
970            .collect();
971        if !unknown_ids.is_empty() {
972            warn!(
973                signer_id = %self.signer_id,
974                ?unknown_ids,
975                "DkgPublicSharesDone contains unknown signer_ids"
976            );
977            return Ok(vec![]);
978        }
979        if !msg.signer_ids.contains(&self.signer_id) {
980            warn!(
981                signer_id = %self.signer_id,
982                "signer_id not in DkgPublicSharesDone, coordinator did not receive our public shares"
983            );
984            self.move_to(State::Idle)?;
985            return Ok(vec![]);
986        }
987        // Discard any shares already collected from signers not in the coordinator's accepted list
988        self.dkg_public_shares
989            .retain(|id, _| msg.signer_ids.contains(id));
990
991        let have_all = msg
992            .signer_ids
993            .iter()
994            .all(|id| self.dkg_public_shares.contains_key(id));
995        if have_all {
996            let ack = DkgPublicSharesDoneAck {
997                dkg_id: self.dkg_id,
998                signer_id: self.signer_id,
999            };
1000            self.move_to(State::DkgPublicSharesDoneAck)?;
1001            Ok(vec![Message::DkgPublicSharesDoneAck(ack)])
1002        } else {
1003            debug!(
1004                signer_id = %self.signer_id,
1005                "DkgPublicSharesDone received but missing some public shares, waiting"
1006            );
1007            self.pending_public_shares_done = Some(msg.clone());
1008            Ok(vec![])
1009        }
1010    }
1011
1012    fn dkg_private_shares_done(
1013        &mut self,
1014        msg: &DkgPrivateSharesDone,
1015    ) -> Result<Vec<Message>, Error> {
1016        if msg.dkg_id != self.dkg_id {
1017            warn!(
1018                signer_id = %self.signer_id,
1019                got = %msg.dkg_id,
1020                expected = %self.dkg_id,
1021                "DkgPrivateSharesDone dkg_id mismatch"
1022            );
1023            return Ok(vec![]);
1024        }
1025        // Reject any unknown signer IDs
1026        let unknown_ids: Vec<u32> = msg
1027            .signer_ids
1028            .iter()
1029            .filter(|id| !self.public_keys.signers.contains_key(*id))
1030            .copied()
1031            .collect();
1032        if !unknown_ids.is_empty() {
1033            warn!(
1034                signer_id = %self.signer_id,
1035                ?unknown_ids,
1036                "DkgPrivateSharesDone contains unknown signer_ids"
1037            );
1038            return Ok(vec![]);
1039        }
1040        if !msg.signer_ids.contains(&self.signer_id) {
1041            warn!(
1042                signer_id = %self.signer_id,
1043                "signer_id not in DkgPrivateSharesDone, coordinator did not receive our private shares"
1044            );
1045            self.move_to(State::Idle)?;
1046            return Ok(vec![]);
1047        }
1048        // Discard any shares already collected from signers not in the coordinator's accepted list
1049        self.dkg_private_shares
1050            .retain(|id, _| msg.signer_ids.contains(id));
1051
1052        let have_all = msg
1053            .signer_ids
1054            .iter()
1055            .all(|id| self.dkg_private_shares.contains_key(id));
1056        if have_all {
1057            let ack = DkgPrivateSharesDoneAck {
1058                dkg_id: self.dkg_id,
1059                signer_id: self.signer_id,
1060            };
1061            self.move_to(State::DkgPrivateSharesDoneAck)?;
1062            Ok(vec![Message::DkgPrivateSharesDoneAck(ack)])
1063        } else {
1064            debug!(
1065                signer_id = %self.signer_id,
1066                "DkgPrivateSharesDone received but missing some private shares, waiting"
1067            );
1068            self.pending_private_shares_done = Some(msg.clone());
1069            Ok(vec![])
1070        }
1071    }
1072
1073    fn dkg_public_begin<R: RngCore + CryptoRng>(
1074        &mut self,
1075        rng: &mut R,
1076    ) -> Result<Vec<Message>, Error> {
1077        let mut msgs = vec![];
1078        let comms = self
1079            .signer
1080            .get_poly_commitments(&self.dkg_id.to_be_bytes(), rng);
1081        let comms = comms
1082            .iter()
1083            .map(|poly| (poly.id.id.get_u32(), poly.clone()))
1084            .collect();
1085
1086        info!(
1087            signer_id = %self.signer_id,
1088            dkg_id = %self.dkg_id,
1089            "sending DkgPublicShares"
1090        );
1091
1092        let kex_proof = DkgPublicShares::kex_prove(
1093            self.dkg_id,
1094            self.signer_id,
1095            &comms,
1096            &self.kex_private_key,
1097            rng,
1098        );
1099        let public_share = DkgPublicShares {
1100            dkg_id: self.dkg_id,
1101            signer_id: self.signer_id,
1102            comms,
1103            kex_public_key: self.kex_private_key * G,
1104            kex_proof,
1105        };
1106
1107        let public_share = Message::DkgPublicShares(public_share);
1108        msgs.push(public_share);
1109
1110        self.move_to(State::DkgPublicGather)?;
1111        Ok(msgs)
1112    }
1113
1114    fn dkg_private_begin<R: RngCore + CryptoRng>(
1115        &mut self,
1116        dkg_private_begin: &DkgPrivateBegin,
1117        rng: &mut R,
1118    ) -> Result<Vec<Message>, Error> {
1119        if dkg_private_begin.dkg_id != self.dkg_id {
1120            warn!(
1121                signer_id = %self.signer_id,
1122                got = %dkg_private_begin.dkg_id,
1123                expected = %self.dkg_id,
1124                "DkgPrivateBegin dkg_id mismatch"
1125            );
1126            return Ok(vec![]);
1127        }
1128        let mut msgs = vec![];
1129        let mut private_shares = DkgPrivateShares {
1130            dkg_id: self.dkg_id,
1131            signer_id: self.signer_id,
1132            shares: Vec::new(),
1133        };
1134        let mut active_key_ids = HashSet::new();
1135        for signer_id in &dkg_private_begin.signer_ids {
1136            if let Some(key_ids) = self.public_keys.signer_key_ids.get(signer_id) {
1137                for key_id in key_ids {
1138                    active_key_ids.insert(*key_id);
1139                }
1140            }
1141        }
1142
1143        self.dkg_private_begin_msg = Some(dkg_private_begin.clone());
1144        self.move_to(State::DkgPrivateDistribute)?;
1145
1146        info!(
1147            signer_id = %self.signer_id,
1148            dkg_id = %self.dkg_id,
1149            "sending DkgPrivateShares"
1150        );
1151
1152        trace!(
1153            "Signer {} shares {:?}",
1154            self.signer_id,
1155            &self.signer.get_shares()
1156        );
1157        for (party_id, shares) in &self.signer.get_shares() {
1158            debug!(
1159                "Signer {} addding dkg private share for party_id {party_id}",
1160                self.signer_id
1161            );
1162            // encrypt each share for the recipient
1163            let mut encrypted_shares = HashMap::new();
1164
1165            for (dst_key_id, private_share) in shares {
1166                if active_key_ids.contains(dst_key_id) {
1167                    debug!("encrypting dkg private share for key_id {dst_key_id}");
1168                    let Some(kex_public_key) = self.kex_public_keys.get(dst_key_id) else {
1169                        error!("No KEX public key for key_id {dst_key_id}");
1170                        return Err(Error::MissingKexPublicKey(*dst_key_id));
1171                    };
1172                    let shared_secret = make_shared_secret(&self.kex_private_key, kex_public_key);
1173                    let encrypted_share = encrypt(&shared_secret, &private_share.to_bytes(), rng)?;
1174
1175                    encrypted_shares.insert(*dst_key_id, encrypted_share);
1176                }
1177            }
1178
1179            private_shares.shares.push((*party_id, encrypted_shares));
1180        }
1181
1182        let private_shares = Message::DkgPrivateShares(private_shares);
1183        msgs.push(private_shares);
1184
1185        self.move_to(State::DkgPrivateGather)?;
1186        Ok(msgs)
1187    }
1188
1189    /// handle incoming DkgEndBegin
1190    pub fn dkg_end_begin(&mut self, dkg_end_begin: &DkgEndBegin) -> Result<Vec<Message>, Error> {
1191        if dkg_end_begin.dkg_id != self.dkg_id {
1192            warn!(
1193                signer_id = %self.signer_id,
1194                got = %dkg_end_begin.dkg_id,
1195                expected = %self.dkg_id,
1196                "DkgEndBegin dkg_id mismatch"
1197            );
1198            return Ok(vec![]);
1199        }
1200        // Reject any unknown signer IDs
1201        let unknown_ids: Vec<u32> = dkg_end_begin
1202            .signer_ids
1203            .iter()
1204            .filter(|id| !self.public_keys.signers.contains_key(*id))
1205            .copied()
1206            .collect();
1207        if !unknown_ids.is_empty() {
1208            warn!(
1209                signer_id = %self.signer_id,
1210                ?unknown_ids,
1211                "DkgEndBegin contains unknown signer_ids"
1212            );
1213            return Ok(vec![]);
1214        }
1215        let num_keys: u32 = dkg_end_begin
1216            .signer_ids
1217            .iter()
1218            .filter_map(|id| self.public_keys.signer_key_ids.get(id))
1219            .map(|key_ids| key_ids.len() as u32)
1220            .sum();
1221        if num_keys < self.dkg_threshold {
1222            warn!(
1223                signer_id = %self.signer_id,
1224                num_keys,
1225                dkg_threshold = self.dkg_threshold,
1226                "DkgEndBegin below dkg_threshold"
1227            );
1228        }
1229        let msgs = vec![];
1230
1231        self.dkg_end_begin_msg = Some(dkg_end_begin.clone());
1232
1233        info!(
1234            signer_id = %self.signer_id,
1235            dkg_id = %self.dkg_id,
1236            "received DkgEndBegin"
1237        );
1238
1239        Ok(msgs)
1240    }
1241
1242    /// handle incoming DkgPublicShares
1243    pub fn dkg_public_share(
1244        &mut self,
1245        dkg_public_shares: &DkgPublicShares,
1246    ) -> Result<Vec<Message>, Error> {
1247        if dkg_public_shares.dkg_id != self.dkg_id {
1248            warn!(
1249                signer_id = %self.signer_id,
1250                got = %dkg_public_shares.dkg_id,
1251                expected = %self.dkg_id,
1252                "DkgPublicShares dkg_id mismatch"
1253            );
1254            return Ok(vec![]);
1255        }
1256        debug!(
1257            "received DkgPublicShares from signer {} {}/{}",
1258            dkg_public_shares.signer_id,
1259            self.commitments.len(),
1260            self.signer.get_num_parties(),
1261        );
1262
1263        let signer_id = dkg_public_shares.signer_id;
1264
1265        // check that the signer_id exists in the config
1266        let Some(_signer_public_key) = self.public_keys.signers.get(&signer_id) else {
1267            warn!(%signer_id, "No public key configured");
1268            return Ok(vec![]);
1269        };
1270
1271        for (party_id, _) in &dkg_public_shares.comms {
1272            if !SignerType::validate_party_id(
1273                signer_id,
1274                *party_id,
1275                &self.public_keys.signer_key_ids,
1276            ) {
1277                warn!(%signer_id, %party_id, "signer sent polynomial commitment for wrong party");
1278                return Ok(vec![]);
1279            }
1280        }
1281
1282        // If we already know which signers the coordinator accepted, discard others
1283        if let Some(pending) = &self.pending_public_shares_done {
1284            if !pending.signer_ids.contains(&signer_id) {
1285                debug!(%signer_id, "discarding DkgPublicShares from signer not in DkgPublicSharesDone");
1286                return Ok(vec![]);
1287            }
1288        }
1289
1290        let have_shares = self
1291            .dkg_public_shares
1292            .contains_key(&dkg_public_shares.signer_id);
1293
1294        if have_shares {
1295            info!(signer_id = %dkg_public_shares.signer_id, "received duplicate DkgPublicShares");
1296            return Ok(vec![]);
1297        }
1298
1299        let Some(signer_key_ids) = self.public_keys.signer_key_ids.get(&signer_id) else {
1300            warn!(%signer_id, "No key_ids configured");
1301            return Ok(vec![]);
1302        };
1303
1304        if !dkg_public_shares.kex_verify() {
1305            warn!(signer_id = %dkg_public_shares.signer_id, "received DkgPublicShares with invalid kex_proof");
1306            return Ok(vec![]);
1307        }
1308
1309        for key_id in signer_key_ids {
1310            self.kex_public_keys
1311                .insert(*key_id, dkg_public_shares.kex_public_key);
1312        }
1313
1314        self.dkg_public_shares
1315            .insert(dkg_public_shares.signer_id, dkg_public_shares.clone());
1316
1317        // If DkgPublicSharesDone arrived before this share, check if we now have everything
1318        if let Some(pending) = self.pending_public_shares_done.take() {
1319            if pending
1320                .signer_ids
1321                .iter()
1322                .all(|id| self.dkg_public_shares.contains_key(id))
1323            {
1324                let ack = DkgPublicSharesDoneAck {
1325                    dkg_id: self.dkg_id,
1326                    signer_id: self.signer_id,
1327                };
1328                self.move_to(State::DkgPublicSharesDoneAck)?;
1329                return Ok(vec![Message::DkgPublicSharesDoneAck(ack)]);
1330            }
1331            self.pending_public_shares_done = Some(pending);
1332        }
1333        Ok(vec![])
1334    }
1335
1336    /// handle incoming DkgPrivateShares
1337    pub fn dkg_private_shares<R: RngCore + CryptoRng>(
1338        &mut self,
1339        dkg_private_shares: &DkgPrivateShares,
1340        rng: &mut R,
1341    ) -> Result<Vec<Message>, Error> {
1342        if dkg_private_shares.dkg_id != self.dkg_id {
1343            warn!(
1344                signer_id = %self.signer_id,
1345                got = %dkg_private_shares.dkg_id,
1346                expected = %self.dkg_id,
1347                "DkgPrivateShares dkg_id mismatch"
1348            );
1349            return Ok(vec![]);
1350        }
1351        // go ahead and decrypt here, since we know the signer_id and hence the pubkey of the sender
1352        let src_signer_id = dkg_private_shares.signer_id;
1353
1354        // check that the signer_id exists in the config
1355        let Some(_signer_public_key) = self.public_keys.signers.get(&src_signer_id) else {
1356            warn!(%src_signer_id, "No public key configured");
1357            return Ok(vec![]);
1358        };
1359
1360        let Ok(kex_public_key) = self.get_kex_public_key(src_signer_id) else {
1361            return Ok(vec![]);
1362        };
1363
1364        for (party_id, _shares) in &dkg_private_shares.shares {
1365            if !SignerType::validate_party_id(
1366                src_signer_id,
1367                *party_id,
1368                &self.public_keys.signer_key_ids,
1369            ) {
1370                warn!("Signer {src_signer_id} sent a polynomial commitment for party {party_id}");
1371                return Ok(vec![]);
1372            }
1373        }
1374
1375        // If we already know which signers the coordinator accepted, discard others
1376        if let Some(pending) = &self.pending_private_shares_done {
1377            if !pending.signer_ids.contains(&src_signer_id) {
1378                debug!(%src_signer_id, "discarding DkgPrivateShares from signer not in DkgPrivateSharesDone");
1379                return Ok(vec![]);
1380            }
1381        }
1382
1383        if self.dkg_private_shares.contains_key(&src_signer_id) {
1384            info!(signer_id = %dkg_private_shares.signer_id, "received duplicate DkgPrivateShares");
1385            return Ok(vec![]);
1386        }
1387
1388        self.dkg_private_shares
1389            .insert(src_signer_id, dkg_private_shares.clone());
1390
1391        // make a HashSet of our key_ids so we can quickly query them
1392        let key_ids: HashSet<u32> = self.signer.get_key_ids().into_iter().collect();
1393
1394        let shared_key = self.kex_private_key * kex_public_key;
1395        let shared_secret = make_shared_secret(&self.kex_private_key, &kex_public_key);
1396
1397        for (src_id, shares) in &dkg_private_shares.shares {
1398            let mut decrypted_shares = HashMap::new();
1399            for (dst_key_id, bytes) in shares {
1400                if key_ids.contains(dst_key_id) {
1401                    match decrypt(&shared_secret, bytes) {
1402                        Ok(plain) => match Scalar::try_from(&plain[..]) {
1403                            Ok(s) => {
1404                                decrypted_shares.insert(*dst_key_id, s);
1405                            }
1406                            Err(e) => {
1407                                warn!("Failed to parse Scalar for dkg private share from src_id {src_id} to dst_id {dst_key_id}: {e:?}");
1408                                self.invalid_private_shares.insert(
1409                                    src_signer_id,
1410                                    self.make_bad_private_share(src_signer_id, rng)?,
1411                                );
1412                            }
1413                        },
1414                        Err(e) => {
1415                            warn!("Failed to decrypt dkg private share from src_id {src_id} to dst_id {dst_key_id}: {e:?}");
1416                            self.invalid_private_shares.insert(
1417                                src_signer_id,
1418                                self.make_bad_private_share(src_signer_id, rng)?,
1419                            );
1420                        }
1421                    }
1422                }
1423            }
1424            self.decrypted_shares.insert(*src_id, decrypted_shares);
1425            self.decryption_keys
1426                .insert(*src_id, (dkg_private_shares.signer_id, shared_key));
1427        }
1428        debug!(
1429            "received DkgPrivateShares from signer {} {}/{}",
1430            dkg_private_shares.signer_id,
1431            self.decrypted_shares.len(),
1432            self.signer.get_num_parties(),
1433        );
1434
1435        // If DkgPrivateSharesDone arrived before this share, check if we now have everything
1436        if let Some(pending) = self.pending_private_shares_done.take() {
1437            if pending
1438                .signer_ids
1439                .iter()
1440                .all(|id| self.dkg_private_shares.contains_key(id))
1441            {
1442                let ack = DkgPrivateSharesDoneAck {
1443                    dkg_id: self.dkg_id,
1444                    signer_id: self.signer_id,
1445                };
1446                self.move_to(State::DkgPrivateSharesDoneAck)?;
1447                return Ok(vec![Message::DkgPrivateSharesDoneAck(ack)]);
1448            }
1449            self.pending_private_shares_done = Some(pending);
1450        }
1451        Ok(vec![])
1452    }
1453
1454    fn get_kex_public_key(&self, signer_id: u32) -> Result<Point, Error> {
1455        let Some(signer_key_ids) = self.public_keys.signer_key_ids.get(&signer_id) else {
1456            warn!(%signer_id, "No key_ids configured");
1457            return Err(Error::Config(ConfigError::InvalidSignerId(signer_id)));
1458        };
1459
1460        let Some(signer_key_id) = signer_key_ids.iter().next() else {
1461            warn!(%signer_id, "No key_ids configured");
1462            return Err(Error::Config(ConfigError::InvalidSignerId(signer_id)));
1463        };
1464
1465        let Some(kex_public_key) = self.kex_public_keys.get(signer_key_id) else {
1466            warn!(%signer_id, %signer_key_id, "No KEX public key configured");
1467            return Err(Error::MissingKexPublicKey(*signer_key_id));
1468        };
1469
1470        Ok(*kex_public_key)
1471    }
1472
1473    #[allow(non_snake_case)]
1474    fn make_bad_private_share<R: RngCore + CryptoRng>(
1475        &self,
1476        signer_id: u32,
1477        rng: &mut R,
1478    ) -> Result<BadPrivateShare, Error> {
1479        let a = self.kex_private_key;
1480        let A = a * G;
1481        let B = self.get_kex_public_key(signer_id)?;
1482        let K = a * B;
1483        let tuple_proof = TupleProof::new(&a, &A, &B, &K, rng);
1484
1485        Ok(BadPrivateShare {
1486            shared_key: K,
1487            tuple_proof,
1488        })
1489    }
1490}
1491
1492impl<SignerType: SignerTrait> StateMachine<State, Error> for Signer<SignerType> {
1493    fn move_to(&mut self, state: State) -> Result<(), Error> {
1494        self.can_move_to(&state)?;
1495        self.state = state;
1496        Ok(())
1497    }
1498
1499    fn can_move_to(&self, state: &State) -> Result<(), Error> {
1500        let prev_state = &self.state;
1501        let accepted = match state {
1502            State::Idle => true,
1503            // DkgBegin can restart from any state
1504            State::DkgPublicDistribute => matches!(
1505                prev_state,
1506                State::Idle
1507                    | State::DkgPublicDistribute
1508                    | State::DkgPublicGather
1509                    | State::DkgPublicSharesDoneAck
1510                    | State::DkgPrivateDistribute
1511                    | State::DkgPrivateGather
1512                    | State::DkgPrivateSharesDoneAck
1513            ),
1514            State::DkgPublicGather => prev_state == &State::DkgPublicDistribute,
1515            State::DkgPublicSharesDoneAck => prev_state == &State::DkgPublicGather,
1516            State::DkgPrivateDistribute => prev_state == &State::DkgPublicSharesDoneAck,
1517            State::DkgPrivateGather => prev_state == &State::DkgPrivateDistribute,
1518            State::DkgPrivateSharesDoneAck => prev_state == &State::DkgPrivateGather,
1519            State::SignGather => prev_state == &State::Idle || prev_state == &State::SignGather,
1520        };
1521        if accepted {
1522            debug!("state change from {prev_state:?} to {state:?}");
1523            Ok(())
1524        } else {
1525            Err(Error::BadStateChange(format!(
1526                "{prev_state:?} to {state:?}"
1527            )))
1528        }
1529    }
1530}
1531#[cfg(test)]
1532/// Test module for signer functionality
1533pub mod test {
1534    use super::*;
1535    #[cfg(feature = "with_v1")]
1536    use crate::v1;
1537    use crate::{
1538        common::PolyCommitment,
1539        curve::{ecdsa, scalar::Scalar},
1540        net::{
1541            DkgBegin, DkgEndBegin, DkgPrivateBegin, DkgPrivateSharesDone, DkgPublicShares,
1542            DkgPublicSharesDone, DkgStatus, Message,
1543        },
1544        schnorr::ID,
1545        state_machine::{
1546            signer::{ConfigError, Error, Signer, State as SignerState},
1547            PublicKeys,
1548        },
1549        traits::Signer as SignerTrait,
1550        util::create_rng,
1551        v2,
1552    };
1553
1554    use hashbrown::HashSet;
1555
1556    #[test]
1557    #[cfg(feature = "with_v1")]
1558    fn bad_config_v1() {
1559        bad_config::<v1::Signer>();
1560    }
1561
1562    #[test]
1563    fn bad_config_v2() {
1564        bad_config::<v2::Signer>();
1565    }
1566
1567    fn bad_config<SignerType: SignerTrait>() {
1568        let mut rng = create_rng();
1569
1570        // more signers than keys
1571        assert!(matches!(
1572            Signer::<SignerType>::new(
1573                1,
1574                1,
1575                2,
1576                1,
1577                0,
1578                vec![1],
1579                Default::default(),
1580                Default::default(),
1581                &mut rng,
1582            ),
1583            Err(Error::Config(ConfigError::InsufficientKeys))
1584        ));
1585
1586        // threshold == 0
1587        assert!(matches!(
1588            Signer::<SignerType>::new(
1589                0,
1590                1,
1591                4,
1592                4,
1593                0,
1594                vec![1],
1595                Default::default(),
1596                Default::default(),
1597                &mut rng,
1598            ),
1599            Err(Error::Config(ConfigError::InvalidThreshold))
1600        ));
1601
1602        // dkg_threshold == 0
1603        assert!(matches!(
1604            Signer::<SignerType>::new(
1605                1,
1606                0,
1607                4,
1608                4,
1609                0,
1610                vec![1],
1611                Default::default(),
1612                Default::default(),
1613                &mut rng,
1614            ),
1615            Err(Error::Config(ConfigError::InvalidThreshold))
1616        ));
1617
1618        // threshold > total_keys
1619        assert!(matches!(
1620            Signer::<SignerType>::new(
1621                5,
1622                5,
1623                4,
1624                4,
1625                0,
1626                vec![1],
1627                Default::default(),
1628                Default::default(),
1629                &mut rng,
1630            ),
1631            Err(Error::Config(ConfigError::InvalidThreshold))
1632        ));
1633
1634        // dkg_threshold < threshold
1635        assert!(matches!(
1636            Signer::<SignerType>::new(
1637                2,
1638                1,
1639                4,
1640                4,
1641                0,
1642                vec![1],
1643                Default::default(),
1644                Default::default(),
1645                &mut rng,
1646            ),
1647            Err(Error::Config(ConfigError::InvalidThreshold))
1648        ));
1649
1650        // signer_id >= num_signers
1651        assert!(matches!(
1652            Signer::<SignerType>::new(
1653                2,
1654                2,
1655                4,
1656                4,
1657                4,
1658                vec![1],
1659                Default::default(),
1660                Default::default(),
1661                &mut rng,
1662            ),
1663            Err(Error::Config(ConfigError::InvalidSignerId(4)))
1664        ));
1665
1666        // key_id == 0
1667        assert!(matches!(
1668            Signer::<SignerType>::new(
1669                2,
1670                2,
1671                4,
1672                4,
1673                0,
1674                vec![0],
1675                Default::default(),
1676                Default::default(),
1677                &mut rng,
1678            ),
1679            Err(Error::Config(ConfigError::InvalidKeyId(0)))
1680        ));
1681
1682        // key_id > num_keys
1683        assert!(matches!(
1684            Signer::<SignerType>::new(
1685                2,
1686                2,
1687                4,
1688                4,
1689                0,
1690                vec![5],
1691                Default::default(),
1692                Default::default(),
1693                &mut rng,
1694            ),
1695            Err(Error::Config(ConfigError::InvalidKeyId(5)))
1696        ));
1697
1698        // public_keys: key_id == 0
1699    }
1700
1701    #[test]
1702    #[cfg(feature = "with_v1")]
1703    fn dkg_public_share_v1() {
1704        dkg_public_share::<v1::Signer>();
1705    }
1706
1707    #[test]
1708    fn dkg_public_share_v2() {
1709        dkg_public_share::<v2::Signer>();
1710    }
1711
1712    fn dkg_public_share<SignerType: SignerTrait>() {
1713        let ctx = 0u64.to_be_bytes();
1714        let mut rng = create_rng();
1715        let private_key = Scalar::random(&mut rng);
1716        let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
1717        let mut public_keys: PublicKeys = Default::default();
1718        let mut key_ids = HashSet::new();
1719
1720        public_keys.signers.insert(0, public_key);
1721        public_keys.key_ids.insert(1, public_key);
1722
1723        key_ids.insert(1);
1724        public_keys.signer_key_ids.insert(0, key_ids);
1725
1726        let mut signer =
1727            Signer::<SignerType>::new(1, 1, 1, 1, 0, vec![1], private_key, public_keys, &mut rng)
1728                .unwrap();
1729        let comms: Vec<(u32, PolyCommitment)> = signer
1730            .signer
1731            .get_poly_commitments(&ctx, &mut rng)
1732            .iter()
1733            .map(|comm| (comm.id.id.get_u32(), comm.clone()))
1734            .collect();
1735        let kex_private_key = Scalar::random(&mut rng);
1736        let kex_proof = DkgPublicShares::kex_prove(0, 0, &comms, &kex_private_key, &mut rng);
1737        let public_share = DkgPublicShares {
1738            dkg_id: 0,
1739            signer_id: 0,
1740            comms: comms.clone(),
1741            kex_public_key: Point::from(kex_private_key),
1742            kex_proof: kex_proof.clone(),
1743        };
1744        signer.dkg_public_share(&public_share).unwrap();
1745        assert_eq!(1, signer.dkg_public_shares.len());
1746
1747        // check that a duplicate public share is ignored
1748        let dup_public_share = DkgPublicShares {
1749            dkg_id: 0,
1750            signer_id: 0,
1751            comms: comms.clone(),
1752            kex_public_key: Point::from(kex_private_key),
1753            kex_proof: kex_proof.clone(),
1754        };
1755        signer.dkg_public_share(&dup_public_share).unwrap();
1756        assert_eq!(1, signer.dkg_public_shares.len());
1757        assert_eq!(
1758            public_share,
1759            signer.dkg_public_shares.iter().next().unwrap().1.clone()
1760        );
1761    }
1762
1763    #[test]
1764    #[cfg(feature = "with_v1")]
1765    fn public_shares_done_v1() {
1766        public_shares_done::<v1::Signer>();
1767    }
1768
1769    #[test]
1770    fn public_shares_done_v2() {
1771        public_shares_done::<v2::Signer>();
1772    }
1773
1774    fn public_shares_done<SignerType: SignerTrait>() {
1775        let ctx = 0u64.to_be_bytes();
1776        let mut rng = create_rng();
1777        let mut signer = Signer::<SignerType>::new(
1778            1,
1779            1,
1780            1,
1781            1,
1782            0,
1783            vec![1],
1784            Default::default(),
1785            Default::default(),
1786            &mut rng,
1787        )
1788        .unwrap();
1789        // publich_shares_done starts out as false
1790        assert!(!signer.public_shares_done());
1791
1792        // meet the conditions for all public keys received
1793        signer.state = SignerState::DkgPublicGather;
1794        signer.commitments.insert(
1795            1,
1796            PolyCommitment {
1797                id: ID::new(&Scalar::new(), &Scalar::new(), &ctx, &mut rng),
1798                poly: vec![],
1799            },
1800        );
1801
1802        // public_shares_done should be true
1803        assert!(signer.public_shares_done());
1804    }
1805
1806    #[test]
1807    #[cfg(feature = "with_v1")]
1808    /// test basic insertion and detection of duplicates for DkgPrivateShares for v1
1809    fn dkg_private_share_v1() {
1810        let mut rng = create_rng();
1811
1812        let private_key = Scalar::random(&mut rng);
1813        let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
1814        let private_key2 = Scalar::random(&mut rng);
1815        let public_key2 = ecdsa::PublicKey::new(&private_key2).unwrap();
1816        let mut public_keys: PublicKeys = Default::default();
1817        let kex_private_key = Scalar::random(&mut rng);
1818        let kex_public_key = Point::from(&kex_private_key);
1819
1820        public_keys.signers.insert(0, public_key);
1821        public_keys.signers.insert(1, public_key2);
1822        public_keys.key_ids.insert(1, public_key);
1823        public_keys.key_ids.insert(2, public_key2);
1824
1825        let mut key_ids = HashSet::new();
1826        key_ids.insert(1);
1827        public_keys.signer_key_ids.insert(0, key_ids);
1828
1829        let mut key_ids2 = HashSet::new();
1830        key_ids2.insert(2);
1831        public_keys.signer_key_ids.insert(1, key_ids2);
1832
1833        let mut signer =
1834            Signer::<v1::Signer>::new(1, 1, 2, 2, 0, vec![1], private_key, public_keys, &mut rng)
1835                .unwrap();
1836
1837        let kex_proof = DkgPublicShares::kex_prove(0, 1, &vec![], &kex_private_key, &mut rng);
1838        let public_share = DkgPublicShares {
1839            dkg_id: 0,
1840            signer_id: 1,
1841            comms: vec![],
1842            kex_public_key,
1843            kex_proof: kex_proof.clone(),
1844        };
1845        signer.dkg_public_share(&public_share).unwrap();
1846        assert_eq!(1, signer.dkg_public_shares.len());
1847
1848        let private_share = DkgPrivateShares {
1849            dkg_id: 0,
1850            signer_id: 1,
1851            shares: vec![(2, HashMap::new())],
1852        };
1853        signer.dkg_private_shares(&private_share, &mut rng).unwrap();
1854        assert_eq!(1, signer.dkg_private_shares.len());
1855
1856        // check that a duplicate private share is ignored
1857        let dup_private_share = DkgPrivateShares {
1858            dkg_id: 0,
1859            signer_id: 1,
1860            shares: vec![(2, HashMap::new())],
1861        };
1862        signer
1863            .dkg_private_shares(&dup_private_share, &mut rng)
1864            .unwrap();
1865        assert_eq!(1, signer.dkg_private_shares.len());
1866        assert_eq!(
1867            private_share,
1868            signer.dkg_private_shares.iter().next().unwrap().1.clone()
1869        );
1870    }
1871
1872    #[test]
1873    /// test basic insertion and detection of duplicates for DkgPrivateShares for v2
1874    fn dkg_private_share_v2() {
1875        let mut rng = create_rng();
1876
1877        let private_key = Scalar::random(&mut rng);
1878        let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
1879        let private_key2 = Scalar::random(&mut rng);
1880        let public_key2 = ecdsa::PublicKey::new(&private_key2).unwrap();
1881        let mut public_keys: PublicKeys = Default::default();
1882        let kex_private_key = Scalar::random(&mut rng);
1883        let kex_public_key = Point::from(&kex_private_key);
1884
1885        public_keys.signers.insert(0, public_key);
1886        public_keys.signers.insert(1, public_key2);
1887        public_keys.key_ids.insert(1, public_key);
1888        public_keys.key_ids.insert(2, public_key2);
1889
1890        let mut key_ids = HashSet::new();
1891        key_ids.insert(1);
1892        public_keys.signer_key_ids.insert(0, key_ids);
1893
1894        let mut key_ids2 = HashSet::new();
1895        key_ids2.insert(2);
1896        public_keys.signer_key_ids.insert(1, key_ids2);
1897
1898        let mut signer =
1899            Signer::<v2::Signer>::new(1, 1, 2, 2, 0, vec![1], private_key, public_keys, &mut rng)
1900                .unwrap();
1901
1902        let kex_proof = DkgPublicShares::kex_prove(0, 1, &vec![], &kex_private_key, &mut rng);
1903        let public_share = DkgPublicShares {
1904            dkg_id: 0,
1905            signer_id: 1,
1906            comms: vec![],
1907            kex_public_key,
1908            kex_proof: kex_proof.clone(),
1909        };
1910        signer.dkg_public_share(&public_share).unwrap();
1911        assert_eq!(1, signer.dkg_public_shares.len());
1912
1913        let private_share = DkgPrivateShares {
1914            dkg_id: 0,
1915            signer_id: 1,
1916            shares: vec![(1, HashMap::new())],
1917        };
1918        signer.dkg_private_shares(&private_share, &mut rng).unwrap();
1919        assert_eq!(1, signer.dkg_private_shares.len());
1920
1921        // check that a duplicate private share is ignored
1922        let dup_private_share = DkgPrivateShares {
1923            dkg_id: 0,
1924            signer_id: 1,
1925            shares: vec![(1, HashMap::new())],
1926        };
1927        signer
1928            .dkg_private_shares(&dup_private_share, &mut rng)
1929            .unwrap();
1930        assert_eq!(1, signer.dkg_private_shares.len());
1931        assert_eq!(
1932            private_share,
1933            signer.dkg_private_shares.iter().next().unwrap().1.clone()
1934        );
1935    }
1936
1937    #[test]
1938    #[cfg(feature = "with_v1")]
1939    fn can_dkg_end_v1() {
1940        can_dkg_end::<v1::Signer>();
1941    }
1942
1943    #[test]
1944    fn can_dkg_end_v2() {
1945        can_dkg_end::<v2::Signer>();
1946    }
1947
1948    fn can_dkg_end<SignerType: SignerTrait>() {
1949        let mut rng = create_rng();
1950        let private_key = Scalar::random(&mut rng);
1951        let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
1952        let mut public_keys: PublicKeys = Default::default();
1953        let mut key_ids = HashSet::new();
1954
1955        public_keys.signers.insert(0, public_key);
1956        public_keys.key_ids.insert(1, public_key);
1957
1958        key_ids.insert(1);
1959        public_keys.signer_key_ids.insert(0, key_ids);
1960
1961        let mut signer =
1962            Signer::<SignerType>::new(1, 1, 1, 1, 0, vec![1], private_key, public_keys, &mut rng)
1963                .unwrap();
1964        signer.verify_packet_sigs = false;
1965        // can_dkg_end starts out as false
1966        assert!(!signer.can_dkg_end());
1967
1968        // meet the conditions for DKG_END
1969        let dkg_begin = Message::DkgBegin(DkgBegin { dkg_id: 1 });
1970        let dkg_begin_packet = Packet {
1971            msg: dkg_begin,
1972            sig: vec![],
1973        };
1974        let dkg_public_shares = signer
1975            .process(&dkg_begin_packet, &mut rng)
1976            .expect("failed to process DkgBegin");
1977        let dkg_public_shares_packet = Packet {
1978            msg: dkg_public_shares[0].clone(),
1979            sig: vec![],
1980        };
1981        let _ = signer
1982            .process(&dkg_public_shares_packet, &mut rng)
1983            .expect("failed to process DkgPublicShares");
1984        // coordinator signals all public shares received; signer moves to DkgPublicSharesDoneAck
1985        let dkg_public_shares_done = Message::DkgPublicSharesDone(DkgPublicSharesDone {
1986            dkg_id: 1,
1987            signer_ids: vec![0],
1988        });
1989        let dkg_public_shares_done_packet = Packet {
1990            msg: dkg_public_shares_done,
1991            sig: vec![],
1992        };
1993        let _ = signer
1994            .process(&dkg_public_shares_done_packet, &mut rng)
1995            .expect("failed to process DkgPublicSharesDone");
1996        let dkg_private_begin = Message::DkgPrivateBegin(DkgPrivateBegin {
1997            dkg_id: 1,
1998            signer_ids: vec![0],
1999            key_ids: vec![],
2000        });
2001        let dkg_private_begin_packet = Packet {
2002            msg: dkg_private_begin,
2003            sig: vec![],
2004        };
2005        let dkg_private_shares = signer
2006            .process(&dkg_private_begin_packet, &mut rng)
2007            .expect("failed to process DkgPrivateBegin");
2008        let dkg_private_shares_packet = Packet {
2009            msg: dkg_private_shares[0].clone(),
2010            sig: vec![],
2011        };
2012        let _ = signer
2013            .process(&dkg_private_shares_packet, &mut rng)
2014            .expect("failed to process DkgPrivateShares");
2015        // coordinator signals all private shares received; signer moves to DkgPrivateSharesDoneAck
2016        let dkg_private_shares_done = Message::DkgPrivateSharesDone(DkgPrivateSharesDone {
2017            dkg_id: 1,
2018            signer_ids: vec![0],
2019        });
2020        let dkg_private_shares_done_packet = Packet {
2021            msg: dkg_private_shares_done,
2022            sig: vec![],
2023        };
2024        let _ = signer
2025            .process(&dkg_private_shares_done_packet, &mut rng)
2026            .expect("failed to process DkgPrivateSharesDone");
2027        let dkg_end_begin = DkgEndBegin {
2028            dkg_id: 1,
2029            signer_ids: vec![0],
2030            key_ids: vec![],
2031        };
2032        let _ = signer
2033            .dkg_end_begin(&dkg_end_begin)
2034            .expect("failed to process DkgPrivateShares");
2035
2036        // can_dkg_end should be true
2037        assert!(signer.can_dkg_end());
2038    }
2039
2040    #[test]
2041    #[cfg(feature = "with_v1")]
2042    fn dkg_ended_v1() {
2043        dkg_ended::<v1::Signer>();
2044    }
2045
2046    #[test]
2047    fn dkg_ended_v2() {
2048        dkg_ended::<v2::Signer>();
2049    }
2050
2051    fn dkg_ended<SignerType: SignerTrait>() {
2052        let mut rng = create_rng();
2053        let mut signer = Signer::<SignerType>::new(
2054            1,
2055            1,
2056            1,
2057            1,
2058            0,
2059            vec![1],
2060            Default::default(),
2061            Default::default(),
2062            &mut rng,
2063        )
2064        .unwrap();
2065
2066        let Ok(Message::DkgEnd(dkg_end)) = signer.dkg_ended(&mut rng) else {
2067            panic!("Unexpected Error");
2068        };
2069        assert!(
2070            matches!(dkg_end.status, DkgStatus::Failure(_)),
2071            "Expected DkgStatus::Failure"
2072        );
2073    }
2074}