Skip to main content

wsts/state_machine/coordinator/
frost.rs

1use hashbrown::{HashMap, HashSet};
2use std::collections::BTreeMap;
3use tracing::{debug, info, warn};
4
5use crate::{
6    common::{PolyCommitment, PublicNonce, Signature, SignatureShare},
7    compute,
8    curve::{ecdsa, point::Point},
9    net::{
10        DkgBegin, DkgEnd, DkgEndBegin, DkgPrivateBegin, DkgPrivateShares, DkgPrivateSharesDone,
11        DkgPublicShares, DkgPublicSharesDone, DkgStatus, Message, NonceRequest, NonceResponse,
12        Packet, Signable, SignatureShareRequest, SignatureType,
13    },
14    state_machine::{
15        coordinator::{
16            Config, Coordinator as CoordinatorTrait, Error, SavedState, SignRoundInfo, State,
17        },
18        DkgError, OperationResult, SignError, StateMachine,
19    },
20    taproot::SchnorrProof,
21    traits::Aggregator as AggregatorTrait,
22};
23
24/// The coordinator for the FROST algorithm
25#[derive(Clone, Debug, PartialEq)]
26pub struct Coordinator<Aggregator: AggregatorTrait> {
27    /// common config fields
28    config: Config,
29    /// current DKG round ID
30    pub current_dkg_id: u64,
31    /// current signing round ID
32    current_sign_id: u64,
33    /// current signing iteration ID
34    current_sign_iter_id: u64,
35    dkg_public_shares: BTreeMap<u32, DkgPublicShares>,
36    dkg_private_shares: BTreeMap<u32, DkgPrivateShares>,
37    dkg_end_messages: BTreeMap<u32, DkgEnd>,
38    party_polynomials: HashMap<u32, PolyCommitment>,
39    public_nonces: BTreeMap<u32, NonceResponse>,
40    signature_shares: BTreeMap<u32, Vec<SignatureShare>>,
41    /// aggregate public key
42    pub aggregate_public_key: Option<Point>,
43    signature: Option<Signature>,
44    schnorr_proof: Option<SchnorrProof>,
45    /// which signers we're currently waiting on
46    pub ids_to_await: HashSet<u32>,
47    /// the bytes that we're signing
48    pub message: Vec<u8>,
49    /// current state of the state machine
50    pub state: State,
51    /// Aggregator object
52    aggregator: Aggregator,
53    /// coordinator public key
54    pub coordinator_public_key: Option<ecdsa::PublicKey>,
55}
56
57impl<Aggregator: AggregatorTrait> Coordinator<Aggregator> {
58    /// Process the message inside the passed packet
59    pub fn process_message(
60        &mut self,
61        packet: &Packet,
62    ) -> Result<(Option<Packet>, Option<OperationResult>), Error> {
63        if self.config.verify_packet_sigs {
64            let Some(coordinator_public_key) = self.coordinator_public_key else {
65                return Err(Error::MissingCoordinatorPublicKey);
66            };
67            if !packet.verify(&self.config.public_keys, &coordinator_public_key) {
68                return Err(Error::InvalidPacketSignature);
69            }
70        }
71        loop {
72            match self.state.clone() {
73                State::Idle => {
74                    // Did we receive a coordinator message?
75                    if let Message::DkgBegin(dkg_begin) = &packet.msg {
76                        if self.current_dkg_id == dkg_begin.dkg_id {
77                            // We have already processed this DKG round
78                            return Ok((None, None));
79                        }
80                        // use dkg_id from DkgBegin
81                        let packet = self.start_dkg_round(Some(dkg_begin.dkg_id))?;
82                        return Ok((Some(packet), None));
83                    } else if let Message::NonceRequest(nonce_request) = &packet.msg {
84                        if self.current_sign_id == nonce_request.sign_id {
85                            // We have already processed this sign round
86                            return Ok((None, None));
87                        }
88                        self.current_sign_iter_id = nonce_request.sign_iter_id;
89                        // use sign_id from NonceRequest
90                        let packet = self.start_signing_round(
91                            nonce_request.message.as_slice(),
92                            nonce_request.signature_type,
93                            Some(nonce_request.sign_id),
94                        )?;
95                        return Ok((Some(packet), None));
96                    }
97                    return Ok((None, None));
98                }
99                State::DkgPublicDistribute => {
100                    let packet = self.start_public_shares()?;
101                    return Ok((Some(packet), None));
102                }
103                State::DkgPublicGather => {
104                    self.gather_public_shares(packet)?;
105                    if self.state == State::DkgPublicGather {
106                        // We need more data
107                        return Ok((None, None));
108                    }
109                }
110                State::DkgPublicSharesDoneDistribute => {
111                    let packet = self.send_public_shares_done()?;
112                    return Ok((Some(packet), None));
113                }
114                State::DkgPublicSharesDoneGather => {
115                    self.gather_public_shares_done_ack(packet)?;
116                    if self.state == State::DkgPublicSharesDoneGather {
117                        // We need more data
118                        return Ok((None, None));
119                    }
120                }
121                State::DkgPrivateDistribute => {
122                    let packet = self.start_private_shares()?;
123                    return Ok((Some(packet), None));
124                }
125                State::DkgPrivateGather => {
126                    self.gather_private_shares(packet)?;
127                    if self.state == State::DkgPrivateGather {
128                        // We need more data
129                        return Ok((None, None));
130                    }
131                }
132                State::DkgPrivateSharesDoneDistribute => {
133                    let packet = self.send_private_shares_done()?;
134                    return Ok((Some(packet), None));
135                }
136                State::DkgPrivateSharesDoneGather => {
137                    self.gather_private_shares_done_ack(packet)?;
138                    if self.state == State::DkgPrivateSharesDoneGather {
139                        // We need more data
140                        return Ok((None, None));
141                    }
142                }
143                State::DkgEndDistribute => {
144                    let packet = self.start_dkg_end()?;
145                    return Ok((Some(packet), None));
146                }
147                State::DkgEndGather => {
148                    if let Err(error) = self.gather_dkg_end(packet) {
149                        if let Error::DkgFailure {
150                            reported_failures,
151                            malicious_signers,
152                        } = error
153                        {
154                            return Ok((
155                                None,
156                                Some(OperationResult::DkgError(DkgError::DkgEndFailure {
157                                    reported_failures,
158                                    malicious_signers,
159                                })),
160                            ));
161                        } else {
162                            return Err(error);
163                        }
164                    }
165                    if self.state == State::DkgEndGather {
166                        // We need more data
167                        return Ok((None, None));
168                    } else if self.state == State::Idle {
169                        // We are done with the DKG round! Return the operation result
170                        return Ok((
171                            None,
172                            Some(OperationResult::Dkg(
173                                self.aggregate_public_key
174                                    .ok_or(Error::MissingAggregatePublicKey)?,
175                            )),
176                        ));
177                    }
178                }
179                State::NonceRequest(signature_type) => {
180                    let packet = self.request_nonces(signature_type)?;
181                    return Ok((Some(packet), None));
182                }
183                State::NonceGather(signature_type) => {
184                    self.gather_nonces(packet, signature_type)?;
185                    if self.state == State::NonceGather(signature_type) {
186                        // We need more data
187                        return Ok((None, None));
188                    }
189                }
190                State::SigShareRequest(signature_type) => {
191                    let packet = self.request_sig_shares(signature_type)?;
192                    return Ok((Some(packet), None));
193                }
194                State::SigShareGather(signature_type) => {
195                    if let Err(e) = self.gather_sig_shares(packet, signature_type) {
196                        return Ok((
197                            None,
198                            Some(OperationResult::SignError(SignError::Coordinator(e))),
199                        ));
200                    }
201                    if self.state == State::SigShareGather(signature_type) {
202                        // We need more data
203                        return Ok((None, None));
204                    } else if self.state == State::Idle {
205                        // We are done with the DKG round! Return the operation result
206                        if let SignatureType::Taproot(_) = signature_type {
207                            let schnorr_proof = self
208                                .schnorr_proof
209                                .as_ref()
210                                .ok_or(Error::MissingSchnorrProof)?;
211                            return Ok((
212                                None,
213                                Some(OperationResult::SignTaproot(SchnorrProof {
214                                    r: schnorr_proof.r,
215                                    s: schnorr_proof.s,
216                                })),
217                            ));
218                        } else if let SignatureType::Schnorr = signature_type {
219                            let schnorr_proof = self
220                                .schnorr_proof
221                                .as_ref()
222                                .ok_or(Error::MissingSchnorrProof)?;
223                            return Ok((
224                                None,
225                                Some(OperationResult::SignSchnorr(SchnorrProof {
226                                    r: schnorr_proof.r,
227                                    s: schnorr_proof.s,
228                                })),
229                            ));
230                        } else {
231                            let signature =
232                                self.signature.as_ref().ok_or(Error::MissingSignature)?;
233                            return Ok((
234                                None,
235                                Some(OperationResult::Sign(Signature {
236                                    R: signature.R,
237                                    z: signature.z,
238                                })),
239                            ));
240                        }
241                    }
242                }
243            }
244        }
245    }
246
247    /// Ask signers to send DKG public shares
248    pub fn start_public_shares(&mut self) -> Result<Packet, Error> {
249        self.dkg_public_shares.clear();
250        self.party_polynomials.clear();
251        self.ids_to_await = (0..self.config.num_signers).collect();
252        info!(
253            dkg_id = %self.current_dkg_id,
254            "Starting Public Share Distribution"
255        );
256        let dkg_begin = DkgBegin {
257            dkg_id: self.current_dkg_id,
258        };
259
260        let dkg_begin_packet = Packet {
261            sig: dkg_begin
262                .sign(&self.config.message_private_key)
263                .expect("Failed to sign DkgBegin"),
264            msg: Message::DkgBegin(dkg_begin),
265        };
266        self.move_to(State::DkgPublicGather)?;
267        Ok(dkg_begin_packet)
268    }
269
270    /// Ask signers to send DKG private shares
271    pub fn start_private_shares(&mut self) -> Result<Packet, Error> {
272        self.ids_to_await = (0..self.config.num_signers).collect();
273        info!(
274            dkg_id = %self.current_dkg_id,
275            "Starting Private Share Distribution"
276        );
277        let dkg_begin = DkgPrivateBegin {
278            dkg_id: self.current_dkg_id,
279            key_ids: (1..self.config.num_keys + 1).collect(),
280            signer_ids: (0..self.config.num_signers).collect(),
281        };
282        let dkg_private_begin_msg = Packet {
283            sig: dkg_begin
284                .sign(&self.config.message_private_key)
285                .expect("Failed to sign DkgPrivateBegin"),
286            msg: Message::DkgPrivateBegin(dkg_begin),
287        };
288        self.move_to(State::DkgPrivateGather)?;
289        Ok(dkg_private_begin_msg)
290    }
291
292    /// Ask signers to compute secrets and send DKG end
293    pub fn start_dkg_end(&mut self) -> Result<Packet, Error> {
294        self.ids_to_await = (0..self.config.num_signers).collect();
295        info!(
296            dkg_id = %self.current_dkg_id,
297            "Starting DKG End Distribution"
298        );
299        let dkg_begin = DkgEndBegin {
300            dkg_id: self.current_dkg_id,
301            key_ids: (0..self.config.num_keys).collect(),
302            signer_ids: (0..self.config.num_signers).collect(),
303        };
304        let dkg_end_begin_msg = Packet {
305            sig: dkg_begin.sign(&self.config.message_private_key).expect(""),
306            msg: Message::DkgEndBegin(dkg_begin),
307        };
308        self.move_to(State::DkgEndGather)?;
309        Ok(dkg_end_begin_msg)
310    }
311
312    fn gather_public_shares(&mut self, packet: &Packet) -> Result<(), Error> {
313        if let Message::DkgPublicShares(dkg_public_shares) = &packet.msg {
314            if dkg_public_shares.dkg_id != self.current_dkg_id {
315                return Err(Error::BadDkgId(
316                    dkg_public_shares.dkg_id,
317                    self.current_dkg_id,
318                ));
319            }
320
321            // check that the signer_id exists in the config
322            let signer_public_keys = &self.config.public_keys.signers;
323            if !signer_public_keys.contains_key(&dkg_public_shares.signer_id) {
324                warn!(signer_id = %dkg_public_shares.signer_id, "No public key in config");
325                return Ok(());
326            };
327
328            let have_shares = self
329                .dkg_public_shares
330                .contains_key(&dkg_public_shares.signer_id);
331
332            if have_shares {
333                info!(signer_id = %dkg_public_shares.signer_id, "received duplicate DkgPublicShares");
334                return Ok(());
335            }
336
337            self.ids_to_await.remove(&dkg_public_shares.signer_id);
338
339            self.dkg_public_shares
340                .insert(dkg_public_shares.signer_id, dkg_public_shares.clone());
341            for (party_id, comm) in &dkg_public_shares.comms {
342                self.party_polynomials.insert(*party_id, comm.clone());
343            }
344
345            debug!(
346                dkg_id = %dkg_public_shares.dkg_id,
347                signer_id = %dkg_public_shares.signer_id,
348                "DkgPublicShares received"
349            );
350        }
351
352        if self.ids_to_await.is_empty() {
353            self.move_to(State::DkgPublicSharesDoneDistribute)?;
354        }
355        Ok(())
356    }
357
358    /// Notify signers that all public shares have been received
359    pub fn send_public_shares_done(&mut self) -> Result<Packet, Error> {
360        let signer_ids: Vec<u32> = self.dkg_public_shares.keys().cloned().collect();
361        self.ids_to_await = signer_ids.iter().cloned().collect();
362        info!(dkg_id = %self.current_dkg_id, "Sending DkgPublicSharesDone");
363        let msg = DkgPublicSharesDone {
364            dkg_id: self.current_dkg_id,
365            signer_ids,
366        };
367        let packet = Packet {
368            sig: msg
369                .sign(&self.config.message_private_key)
370                .expect("Failed to sign DkgPublicSharesDone"),
371            msg: Message::DkgPublicSharesDone(msg),
372        };
373        self.move_to(State::DkgPublicSharesDoneGather)?;
374        Ok(packet)
375    }
376
377    fn gather_public_shares_done_ack(&mut self, packet: &Packet) -> Result<(), Error> {
378        if let Message::DkgPublicSharesDoneAck(ack) = &packet.msg {
379            if ack.dkg_id != self.current_dkg_id {
380                return Err(Error::BadDkgId(ack.dkg_id, self.current_dkg_id));
381            }
382            if !self.config.public_keys.signers.contains_key(&ack.signer_id) {
383                warn!(signer_id = %ack.signer_id, "No public key in config");
384                return Ok(());
385            }
386            self.ids_to_await.remove(&ack.signer_id);
387            debug!(
388                dkg_id = %ack.dkg_id,
389                signer_id = %ack.signer_id,
390                "DkgPublicSharesDoneAck received"
391            );
392        }
393        if self.ids_to_await.is_empty() {
394            self.move_to(State::DkgPrivateDistribute)?;
395        }
396        Ok(())
397    }
398
399    fn gather_private_shares(&mut self, packet: &Packet) -> Result<(), Error> {
400        if let Message::DkgPrivateShares(dkg_private_shares) = &packet.msg {
401            if dkg_private_shares.dkg_id != self.current_dkg_id {
402                return Err(Error::BadDkgId(
403                    dkg_private_shares.dkg_id,
404                    self.current_dkg_id,
405                ));
406            }
407
408            // check that the signer_id exists in the config
409            let signer_public_keys = &self.config.public_keys.signers;
410            if !signer_public_keys.contains_key(&dkg_private_shares.signer_id) {
411                warn!(signer_id = %dkg_private_shares.signer_id, "No public key in config");
412                return Ok(());
413            };
414
415            let has_received_shares = self
416                .dkg_private_shares
417                .contains_key(&dkg_private_shares.signer_id);
418            if has_received_shares {
419                info!(signer_id = %dkg_private_shares.signer_id, "received duplicate DkgPrivateShares");
420                return Ok(());
421            }
422
423            self.ids_to_await.remove(&dkg_private_shares.signer_id);
424
425            self.dkg_private_shares
426                .insert(dkg_private_shares.signer_id, dkg_private_shares.clone());
427            info!(
428                dkg_id = %dkg_private_shares.dkg_id,
429                signer_id = %dkg_private_shares.signer_id,
430                "DkgPrivateShares received"
431            );
432        }
433
434        if self.ids_to_await.is_empty() {
435            self.move_to(State::DkgPrivateSharesDoneDistribute)?;
436        }
437        Ok(())
438    }
439
440    /// Notify signers that all private shares have been received
441    pub fn send_private_shares_done(&mut self) -> Result<Packet, Error> {
442        let signer_ids: Vec<u32> = self.dkg_private_shares.keys().cloned().collect();
443        self.ids_to_await = signer_ids.iter().cloned().collect();
444        info!(dkg_id = %self.current_dkg_id, "Sending DkgPrivateSharesDone");
445        let msg = DkgPrivateSharesDone {
446            dkg_id: self.current_dkg_id,
447            signer_ids,
448        };
449        let packet = Packet {
450            sig: msg
451                .sign(&self.config.message_private_key)
452                .expect("Failed to sign DkgPrivateSharesDone"),
453            msg: Message::DkgPrivateSharesDone(msg),
454        };
455        self.move_to(State::DkgPrivateSharesDoneGather)?;
456        Ok(packet)
457    }
458
459    fn gather_private_shares_done_ack(&mut self, packet: &Packet) -> Result<(), Error> {
460        if let Message::DkgPrivateSharesDoneAck(ack) = &packet.msg {
461            if ack.dkg_id != self.current_dkg_id {
462                return Err(Error::BadDkgId(ack.dkg_id, self.current_dkg_id));
463            }
464            if !self.config.public_keys.signers.contains_key(&ack.signer_id) {
465                warn!(signer_id = %ack.signer_id, "No public key in config");
466                return Ok(());
467            }
468            self.ids_to_await.remove(&ack.signer_id);
469            debug!(
470                dkg_id = %ack.dkg_id,
471                signer_id = %ack.signer_id,
472                "DkgPrivateSharesDoneAck received"
473            );
474        }
475        if self.ids_to_await.is_empty() {
476            self.move_to(State::DkgEndDistribute)?;
477        }
478        Ok(())
479    }
480
481    fn gather_dkg_end(&mut self, packet: &Packet) -> Result<(), Error> {
482        debug!(
483            dkg_id = %self.current_dkg_id,
484            waiting = ?self.ids_to_await,
485            "Waiting for Dkg End from signers"
486        );
487        if let Message::DkgEnd(dkg_end) = &packet.msg {
488            if dkg_end.dkg_id != self.current_dkg_id {
489                return Err(Error::BadDkgId(dkg_end.dkg_id, self.current_dkg_id));
490            }
491            if self.ids_to_await.contains(&dkg_end.signer_id) {
492                self.ids_to_await.remove(&dkg_end.signer_id);
493                self.dkg_end_messages
494                    .insert(dkg_end.signer_id, dkg_end.clone());
495                debug!(
496                    dkg_id = %dkg_end.dkg_id,
497                    signer_id = %dkg_end.signer_id,
498                    waiting = ?self.ids_to_await,
499                    "DkgEnd received"
500                );
501            }
502        }
503
504        if self.ids_to_await.is_empty() {
505            let mut reported_failures = HashMap::new();
506
507            for (signer_id, dkg_end) in &self.dkg_end_messages {
508                if let DkgStatus::Failure(dkg_failure) = &dkg_end.status {
509                    warn!(%signer_id, ?dkg_failure, "DkgEnd failure");
510                    reported_failures.insert(*signer_id, dkg_failure.clone());
511                }
512            }
513
514            if reported_failures.is_empty() {
515                self.dkg_end_gathered()?;
516            } else {
517                return Err(Error::DkgFailure {
518                    reported_failures,
519                    malicious_signers: Default::default(),
520                });
521            }
522        }
523        Ok(())
524    }
525
526    fn dkg_end_gathered(&mut self) -> Result<(), Error> {
527        // Cache the polynomials used in DKG for the aggregator
528        for signer_id in self.dkg_private_shares.keys() {
529            let Some(dkg_public_shares) = self.dkg_public_shares.get(signer_id) else {
530                warn!(%signer_id, "no DkgPublicShares");
531                return Err(Error::BadStateChange(format!("Should not have transitioned to DkgEndGather since we were missing DkgPublicShares from signer {signer_id}")));
532            };
533            for (party_id, comm) in &dkg_public_shares.comms {
534                self.party_polynomials.insert(*party_id, comm.clone());
535            }
536        }
537
538        // Calculate the aggregate public key
539        let key = self
540            .party_polynomials
541            .iter()
542            .fold(Point::default(), |s, (_, comm)| s + comm.poly[0]);
543
544        info!(
545            %key,
546            "Aggregate public key"
547        );
548        self.aggregate_public_key = Some(key);
549        self.move_to(State::Idle)
550    }
551
552    fn request_nonces(&mut self, signature_type: SignatureType) -> Result<Packet, Error> {
553        self.public_nonces.clear();
554        info!(
555            sign_id = %self.current_sign_id,
556            sign_iter_id = %self.current_sign_iter_id,
557            "Requesting Nonces"
558        );
559        let nonce_request = NonceRequest {
560            dkg_id: self.current_dkg_id,
561            sign_id: self.current_sign_id,
562            sign_iter_id: self.current_sign_iter_id,
563            message: self.message.clone(),
564            signature_type,
565        };
566        let nonce_request_msg = Packet {
567            sig: nonce_request
568                .sign(&self.config.message_private_key)
569                .expect(""),
570            msg: Message::NonceRequest(nonce_request),
571        };
572        self.ids_to_await = (0..self.config.num_signers).collect();
573        self.move_to(State::NonceGather(signature_type))?;
574        Ok(nonce_request_msg)
575    }
576
577    fn gather_nonces(
578        &mut self,
579        packet: &Packet,
580        signature_type: SignatureType,
581    ) -> Result<(), Error> {
582        if let Message::NonceResponse(nonce_response) = &packet.msg {
583            if nonce_response.dkg_id != self.current_dkg_id {
584                return Err(Error::BadDkgId(nonce_response.dkg_id, self.current_dkg_id));
585            }
586            if nonce_response.sign_id != self.current_sign_id {
587                return Err(Error::BadSignId(
588                    nonce_response.sign_id,
589                    self.current_sign_id,
590                ));
591            }
592            if nonce_response.sign_iter_id != self.current_sign_iter_id {
593                return Err(Error::BadSignIterId(
594                    nonce_response.sign_iter_id,
595                    self.current_sign_iter_id,
596                ));
597            }
598
599            // check that the signer_id exists in the config
600            let signer_public_keys = &self.config.public_keys.signers;
601            if !signer_public_keys.contains_key(&nonce_response.signer_id) {
602                warn!(signer_id = %nonce_response.signer_id, "No public key in config");
603                return Ok(());
604            };
605
606            // check that the signer participated in the current DKG round
607            if !self
608                .dkg_end_messages
609                .contains_key(&nonce_response.signer_id)
610            {
611                warn!(signer_id = %nonce_response.signer_id, "NonceResponse rejected: signer not a DKG participant");
612                return Ok(());
613            }
614
615            // check that the key_ids match the config
616            let Some(signer_key_ids) = self
617                .config
618                .public_keys
619                .signer_key_ids
620                .get(&nonce_response.signer_id)
621            else {
622                warn!(signer_id = %nonce_response.signer_id, "No keys IDs configured");
623                return Ok(());
624            };
625
626            let nonce_response_key_ids = nonce_response
627                .key_ids
628                .iter()
629                .cloned()
630                .collect::<HashSet<u32>>();
631            if *signer_key_ids != nonce_response_key_ids {
632                warn!(signer_id = %nonce_response.signer_id, "Nonce response key_ids didn't match config");
633                return Ok(());
634            }
635
636            for nonce in &nonce_response.nonces {
637                if !nonce.is_valid() {
638                    warn!(
639                        sign_id = %nonce_response.sign_id,
640                        sign_iter_id = %nonce_response.sign_iter_id,
641                        signer_id = %nonce_response.signer_id,
642                        "Received invalid nonce in NonceResponse"
643                    );
644                    return Ok(());
645                }
646            }
647
648            let have_nonces = self.public_nonces.contains_key(&nonce_response.signer_id);
649
650            if have_nonces {
651                info!(signer_id = %nonce_response.signer_id, "Received duplicate NonceResponse");
652                return Ok(());
653            }
654
655            self.public_nonces
656                .insert(nonce_response.signer_id, nonce_response.clone());
657            self.ids_to_await.remove(&nonce_response.signer_id);
658            debug!(
659                sign_id = %nonce_response.sign_id,
660                sign_iter_id = %nonce_response.sign_iter_id,
661                signer_id = %nonce_response.signer_id,
662                waiting = ?self.ids_to_await,
663                "NonceResponse received"
664            );
665        }
666        let recv_key_ids = self
667            .public_nonces
668            .values()
669            .flat_map(|nr| nr.key_ids.iter().copied())
670            .collect::<HashSet<u32>>();
671        if recv_key_ids.len() >= self.config.sign_threshold as usize {
672            let aggregate_nonce = self.compute_aggregate_nonce()?;
673            info!(
674                %aggregate_nonce,
675                "Aggregate nonce"
676            );
677
678            // Lock in the set of signers that will participate in the signing round.
679            self.ids_to_await = self.public_nonces.keys().copied().collect();
680            self.move_to(State::SigShareRequest(signature_type))?;
681        }
682        Ok(())
683    }
684
685    fn request_sig_shares(&mut self, signature_type: SignatureType) -> Result<Packet, Error> {
686        self.signature_shares.clear();
687        info!(
688            sign_id = %self.current_sign_id,
689            "Requesting Signature Shares"
690        );
691        let nonce_responses = self
692            .public_nonces
693            .values()
694            .cloned()
695            .collect::<Vec<NonceResponse>>();
696        let sig_share_request = SignatureShareRequest {
697            dkg_id: self.current_dkg_id,
698            sign_id: self.current_sign_id,
699            sign_iter_id: self.current_sign_iter_id,
700            nonce_responses,
701            message: self.message.clone(),
702            signature_type,
703        };
704        let sig_share_request_msg = Packet {
705            sig: sig_share_request
706                .sign(&self.config.message_private_key)
707                .expect(""),
708            msg: Message::SignatureShareRequest(sig_share_request),
709        };
710        self.ids_to_await = self.public_nonces.keys().copied().collect();
711        self.move_to(State::SigShareGather(signature_type))?;
712
713        Ok(sig_share_request_msg)
714    }
715
716    fn gather_sig_shares(
717        &mut self,
718        packet: &Packet,
719        signature_type: SignatureType,
720    ) -> Result<(), Error> {
721        if let Message::SignatureShareResponse(sig_share_response) = &packet.msg {
722            if sig_share_response.dkg_id != self.current_dkg_id {
723                return Err(Error::BadDkgId(
724                    sig_share_response.dkg_id,
725                    self.current_dkg_id,
726                ));
727            }
728            if sig_share_response.sign_id != self.current_sign_id {
729                return Err(Error::BadSignId(
730                    sig_share_response.sign_id,
731                    self.current_sign_id,
732                ));
733            }
734
735            // check that the signer_id exists in the config
736            let signer_public_keys = &self.config.public_keys.signers;
737            if !signer_public_keys.contains_key(&sig_share_response.signer_id) {
738                warn!(signer_id = %sig_share_response.signer_id, "No public key in config");
739                return Ok(());
740            };
741
742            // check that the signer participated in the current DKG round
743            if !self
744                .dkg_end_messages
745                .contains_key(&sig_share_response.signer_id)
746            {
747                warn!(signer_id = %sig_share_response.signer_id, "SignatureShareResponse rejected: signer not a DKG participant");
748                return Ok(());
749            }
750
751            // check that the key_ids match the config
752            let Some(signer_key_ids) = self
753                .config
754                .public_keys
755                .signer_key_ids
756                .get(&sig_share_response.signer_id)
757            else {
758                warn!(signer_id = %sig_share_response.signer_id, "No keys IDs configured");
759                return Ok(());
760            };
761
762            let mut sig_share_response_key_ids = HashSet::new();
763            for sig_share in &sig_share_response.signature_shares {
764                for key_id in &sig_share.key_ids {
765                    sig_share_response_key_ids.insert(*key_id);
766                }
767            }
768
769            if *signer_key_ids != sig_share_response_key_ids {
770                warn!(signer_id = %sig_share_response.signer_id, "SignatureShareResponse key_ids didn't match config");
771                return Ok(());
772            }
773
774            let have_shares = self
775                .signature_shares
776                .contains_key(&sig_share_response.signer_id);
777
778            if have_shares {
779                info!(signer_id = %sig_share_response.signer_id, "received duplicate SignatureShareResponse");
780                return Ok(());
781            }
782
783            self.signature_shares.insert(
784                sig_share_response.signer_id,
785                sig_share_response.signature_shares.clone(),
786            );
787            self.ids_to_await.remove(&sig_share_response.signer_id);
788            debug!(
789                sign_id = %sig_share_response.sign_id,
790                signer_id = %sig_share_response.signer_id,
791                waiting = ?self.ids_to_await,
792                "SignatureShareResponse received"
793            );
794        }
795        if self.ids_to_await.is_empty() {
796            // Calculate the aggregate signature using the signers that participated.
797            let nonce_responses = self
798                .public_nonces
799                .values()
800                .cloned()
801                .collect::<Vec<NonceResponse>>();
802
803            let nonces = nonce_responses
804                .iter()
805                .flat_map(|nr| nr.nonces.clone())
806                .collect::<Vec<PublicNonce>>();
807
808            let key_ids = nonce_responses
809                .iter()
810                .flat_map(|nr| nr.key_ids.clone())
811                .collect::<Vec<u32>>();
812
813            let shares = &self
814                .public_nonces
815                .keys()
816                .flat_map(|i| self.signature_shares[i].clone())
817                .collect::<Vec<SignatureShare>>();
818
819            debug!(
820                nonces_len = %nonces.len(),
821                shares_len = %shares.len(),
822                "aggregator.sign"
823            );
824
825            self.aggregator.init(&self.party_polynomials)?;
826
827            if let SignatureType::Taproot(merkle_root) = signature_type {
828                let schnorr_proof = self.aggregator.sign_taproot(
829                    &self.message,
830                    &nonces,
831                    shares,
832                    &key_ids,
833                    merkle_root,
834                )?;
835                debug!(
836                    r = %schnorr_proof.r,
837                    s = %schnorr_proof.s,
838                    "SchnorrProof"
839                );
840                self.schnorr_proof = Some(schnorr_proof);
841            } else if let SignatureType::Schnorr = signature_type {
842                let schnorr_proof =
843                    self.aggregator
844                        .sign_schnorr(&self.message, &nonces, shares, &key_ids)?;
845                debug!(
846                    r = %schnorr_proof.r,
847                    s = %schnorr_proof.s,
848                    "SchnorrProof"
849                );
850                self.schnorr_proof = Some(schnorr_proof);
851            } else {
852                let signature = self
853                    .aggregator
854                    .sign(&self.message, &nonces, shares, &key_ids)?;
855                debug!(
856                    R = %signature.R,
857                    z = %signature.z,
858                    "Signature"
859                );
860                self.signature = Some(signature);
861            }
862
863            self.move_to(State::Idle)?;
864        }
865        Ok(())
866    }
867
868    #[allow(non_snake_case)]
869    fn compute_aggregate_nonce(&self) -> Result<Point, Error> {
870        // XXX this needs to be key_ids for v1 and signer_ids for v2
871        let party_ids = self
872            .public_nonces
873            .values()
874            .flat_map(|pn| pn.key_ids.clone())
875            .collect::<Vec<u32>>();
876        let nonces = self
877            .public_nonces
878            .values()
879            .flat_map(|pn| pn.nonces.clone())
880            .collect::<Vec<PublicNonce>>();
881        let Some(group_key) = self.aggregate_public_key else {
882            return Err(Error::MissingAggregatePublicKey);
883        };
884        let (_, aggregate_nonce) =
885            compute::intermediate(&self.message, group_key, &party_ids, &nonces);
886
887        Ok(aggregate_nonce)
888    }
889}
890
891impl<Aggregator: AggregatorTrait> StateMachine<State, Error> for Coordinator<Aggregator> {
892    fn move_to(&mut self, state: State) -> Result<(), Error> {
893        self.can_move_to(&state)?;
894        self.state = state;
895        Ok(())
896    }
897
898    fn can_move_to(&self, state: &State) -> Result<(), Error> {
899        let prev_state = &self.state;
900        let accepted = match state {
901            State::Idle => true,
902            State::DkgPublicDistribute => prev_state == &State::Idle,
903            State::DkgPublicGather => {
904                prev_state == &State::DkgPublicDistribute || prev_state == &State::DkgPublicGather
905            }
906            State::DkgPublicSharesDoneDistribute => prev_state == &State::DkgPublicGather,
907            State::DkgPublicSharesDoneGather => {
908                prev_state == &State::DkgPublicSharesDoneDistribute
909                    || prev_state == &State::DkgPublicSharesDoneGather
910            }
911            State::DkgPrivateDistribute => prev_state == &State::DkgPublicSharesDoneGather,
912            State::DkgPrivateGather => {
913                prev_state == &State::DkgPrivateDistribute || prev_state == &State::DkgPrivateGather
914            }
915            State::DkgPrivateSharesDoneDistribute => prev_state == &State::DkgPrivateGather,
916            State::DkgPrivateSharesDoneGather => {
917                prev_state == &State::DkgPrivateSharesDoneDistribute
918                    || prev_state == &State::DkgPrivateSharesDoneGather
919            }
920            State::DkgEndDistribute => prev_state == &State::DkgPrivateSharesDoneGather,
921            State::DkgEndGather => prev_state == &State::DkgEndDistribute,
922            State::NonceRequest(_) => {
923                prev_state == &State::Idle || prev_state == &State::DkgEndGather
924            }
925            State::NonceGather(signature_type) => {
926                prev_state == &State::NonceRequest(*signature_type)
927                    || prev_state == &State::NonceGather(*signature_type)
928            }
929            State::SigShareRequest(signature_type) => {
930                prev_state == &State::NonceGather(*signature_type)
931            }
932            State::SigShareGather(signature_type) => {
933                prev_state == &State::SigShareRequest(*signature_type)
934                    || prev_state == &State::SigShareGather(*signature_type)
935            }
936        };
937        if accepted {
938            debug!("state change from {prev_state:?} to {state:?}");
939            Ok(())
940        } else {
941            Err(Error::BadStateChange(format!(
942                "{prev_state:?} to {state:?}"
943            )))
944        }
945    }
946}
947
948impl<Aggregator: AggregatorTrait> CoordinatorTrait for Coordinator<Aggregator> {
949    /// Create a new coordinator
950    fn new(config: Config) -> Self {
951        Self {
952            aggregator: Aggregator::new(config.num_keys, config.threshold),
953            config,
954            current_dkg_id: 0,
955            current_sign_id: 0,
956            current_sign_iter_id: 0,
957            dkg_public_shares: Default::default(),
958            dkg_private_shares: Default::default(),
959            dkg_end_messages: Default::default(),
960            party_polynomials: Default::default(),
961            public_nonces: Default::default(),
962            signature_shares: Default::default(),
963            aggregate_public_key: None,
964            signature: None,
965            schnorr_proof: None,
966            message: Default::default(),
967            ids_to_await: Default::default(),
968            state: State::Idle,
969            coordinator_public_key: None,
970        }
971    }
972
973    fn load(state: &SavedState) -> Self {
974        Self {
975            aggregator: Aggregator::new(state.config.num_keys, state.config.threshold),
976            config: state.config.clone(),
977            current_dkg_id: state.current_dkg_id,
978            current_sign_id: state.current_sign_id,
979            current_sign_iter_id: state.current_sign_iter_id,
980            dkg_public_shares: state.dkg_public_shares.clone(),
981            dkg_private_shares: state.dkg_private_shares.clone(),
982            dkg_end_messages: state.dkg_end_messages.clone(),
983            party_polynomials: state.party_polynomials.clone(),
984            public_nonces: state.message_nonces[&Vec::new()].public_nonces.clone(),
985            signature_shares: state.signature_shares.clone(),
986            aggregate_public_key: state.aggregate_public_key,
987            signature: state.signature.clone(),
988            schnorr_proof: state.schnorr_proof.clone(),
989            message: state.message.clone(),
990            ids_to_await: state.dkg_wait_signer_ids.clone(),
991            state: state.state.clone(),
992            coordinator_public_key: state.coordinator_public_key,
993        }
994    }
995
996    fn save(&self) -> SavedState {
997        let round_info = SignRoundInfo {
998            public_nonces: self.public_nonces.clone(),
999            nonce_recv_key_ids: Default::default(),
1000            sign_recv_key_ids: Default::default(),
1001            sign_wait_signer_ids: Default::default(),
1002        };
1003        let mut message_nonces = BTreeMap::new();
1004
1005        message_nonces.insert(Vec::new(), round_info);
1006
1007        SavedState {
1008            config: self.config.clone(),
1009            current_dkg_id: self.current_dkg_id,
1010            current_sign_id: self.current_sign_id,
1011            current_sign_iter_id: self.current_sign_iter_id,
1012            dkg_public_shares: self.dkg_public_shares.clone(),
1013            dkg_private_shares: self.dkg_private_shares.clone(),
1014            dkg_end_messages: self.dkg_end_messages.clone(),
1015            party_polynomials: self.party_polynomials.clone(),
1016            message_nonces,
1017            signature_shares: self.signature_shares.clone(),
1018            aggregate_public_key: self.aggregate_public_key,
1019            signature: self.signature.clone(),
1020            schnorr_proof: self.schnorr_proof.clone(),
1021            message: self.message.clone(),
1022            dkg_wait_signer_ids: self.ids_to_await.clone(),
1023            state: self.state.clone(),
1024            dkg_public_start: Default::default(),
1025            dkg_private_start: Default::default(),
1026            dkg_end_start: Default::default(),
1027            nonce_start: Default::default(),
1028            sign_start: Default::default(),
1029            malicious_signer_ids: Default::default(),
1030            malicious_dkg_signer_ids: Default::default(),
1031            coordinator_public_key: self.coordinator_public_key,
1032        }
1033    }
1034
1035    /// Retrieve the config
1036    fn get_config(&self) -> Config {
1037        self.config.clone()
1038    }
1039
1040    fn set_coordinator_public_key(&mut self, key: Option<ecdsa::PublicKey>) {
1041        self.coordinator_public_key = key;
1042    }
1043
1044    /// Set the aggregate key and polynomial commitments used to form that key.
1045    ///  Check if the polynomial commitments match the key
1046    fn set_key_and_party_polynomials(
1047        &mut self,
1048        aggregate_key: Point,
1049        party_polynomials: Vec<(u32, PolyCommitment)>,
1050    ) -> Result<(), Error> {
1051        let computed_key = party_polynomials
1052            .iter()
1053            .fold(Point::default(), |s, (_, comm)| s + comm.poly[0]);
1054        if computed_key != aggregate_key {
1055            return Err(Error::AggregateKeyPolynomialMismatch(
1056                computed_key,
1057                aggregate_key,
1058            ));
1059        }
1060        let party_polynomials_len = party_polynomials.len();
1061        let party_polynomials = HashMap::from_iter(party_polynomials);
1062        if party_polynomials.len() != party_polynomials_len {
1063            return Err(Error::DuplicatePartyId);
1064        }
1065        self.aggregate_public_key = Some(aggregate_key);
1066        self.party_polynomials = party_polynomials;
1067        Ok(())
1068    }
1069
1070    /// Process the message inside the passed packet
1071    fn process(
1072        &mut self,
1073        packet: &Packet,
1074    ) -> Result<(Option<Packet>, Option<OperationResult>), Error> {
1075        self.process_message(packet)
1076    }
1077
1078    /// Retrieve the aggregate public key
1079    fn get_aggregate_public_key(&self) -> Option<Point> {
1080        self.aggregate_public_key
1081    }
1082
1083    /// Set the aggregate public key
1084    fn set_aggregate_public_key(&mut self, aggregate_public_key: Option<Point>) {
1085        self.aggregate_public_key = aggregate_public_key;
1086    }
1087
1088    /// Retrieve the current message bytes being signed
1089    fn get_message(&self) -> Vec<u8> {
1090        self.message.clone()
1091    }
1092
1093    /// Retrive the current state
1094    fn get_state(&self) -> State {
1095        self.state.clone()
1096    }
1097
1098    /// Start a DKG round
1099    fn start_dkg_round(&mut self, dkg_id: Option<u64>) -> Result<Packet, Error> {
1100        if let Some(id) = dkg_id {
1101            self.current_dkg_id = id;
1102        } else {
1103            self.current_dkg_id = self.current_dkg_id.wrapping_add(1);
1104        }
1105        info!("Starting DKG round {}", self.current_dkg_id);
1106        self.move_to(State::DkgPublicDistribute)?;
1107        self.start_public_shares()
1108    }
1109
1110    /// Start a signing round
1111    fn start_signing_round(
1112        &mut self,
1113        message: &[u8],
1114        signature_type: SignatureType,
1115        sign_id: Option<u64>,
1116    ) -> Result<Packet, Error> {
1117        // We cannot sign if we haven't first set DKG (either manually or via DKG round).
1118        if self.aggregate_public_key.is_none() {
1119            return Err(Error::MissingAggregatePublicKey);
1120        }
1121        self.message = message.to_vec();
1122        if let Some(id) = sign_id {
1123            self.current_sign_id = id;
1124        } else {
1125            self.current_sign_id = self.current_sign_id.wrapping_add(1);
1126        }
1127        info!("Starting signing round {}", self.current_sign_id);
1128        self.move_to(State::NonceRequest(signature_type))?;
1129        self.request_nonces(signature_type)
1130    }
1131
1132    // Reset internal state
1133    fn reset(&mut self) {
1134        self.state = State::Idle;
1135        self.dkg_public_shares.clear();
1136        self.party_polynomials.clear();
1137        self.public_nonces.clear();
1138        self.signature_shares.clear();
1139        self.ids_to_await = (0..self.config.num_signers).collect();
1140    }
1141}
1142
1143#[cfg(test)]
1144/// Test module for coordinator functionality
1145pub mod test {
1146    use super::*;
1147    #[cfg(feature = "with_v1")]
1148    use crate::v1;
1149    use crate::{
1150        curve::scalar::Scalar,
1151        net::{DkgBegin, Message, NonceRequest, Packet, SignatureShareResponse, SignatureType},
1152        schnorr::{self, ID},
1153        state_machine::{
1154            coordinator::{
1155                frost::Coordinator as FrostCoordinator,
1156                test::{
1157                    bad_signature_share_request, btc_sign_verify, check_signature_shares,
1158                    coordinator_state_machine, empty_private_shares, empty_public_shares,
1159                    equal_after_save_load, feedback_messages, invalid_nonce, new_coordinator,
1160                    run_dkg, run_dkg_sign, setup, start_dkg_round, start_signing_round,
1161                    verify_packet_sigs,
1162                },
1163                Config, Coordinator as CoordinatorTrait, State,
1164            },
1165            OperationResult,
1166        },
1167        traits::{Aggregator as AggregatorTrait, Signer as SignerTrait},
1168        util::create_rng,
1169        v2,
1170    };
1171
1172    #[test]
1173    #[cfg(feature = "with_v1")]
1174    fn new_coordinator_v1() {
1175        new_coordinator::<FrostCoordinator<v1::Aggregator>>();
1176    }
1177
1178    #[test]
1179    fn new_coordinator_v2() {
1180        new_coordinator::<FrostCoordinator<v2::Aggregator>>();
1181    }
1182
1183    #[test]
1184    #[cfg(feature = "with_v1")]
1185    fn equal_after_save_load_v1() {
1186        equal_after_save_load::<FrostCoordinator<v1::Aggregator>, v1::Signer>(2, 2);
1187    }
1188
1189    #[test]
1190    fn equal_after_save_load_v2() {
1191        equal_after_save_load::<FrostCoordinator<v2::Aggregator>, v2::Signer>(2, 2);
1192    }
1193
1194    #[test]
1195    #[cfg(feature = "with_v1")]
1196    fn coordinator_state_machine_v1() {
1197        coordinator_state_machine::<FrostCoordinator<v1::Aggregator>>();
1198    }
1199
1200    #[test]
1201    fn coordinator_state_machine_v2() {
1202        coordinator_state_machine::<FrostCoordinator<v2::Aggregator>>();
1203    }
1204
1205    #[test]
1206    #[cfg(feature = "with_v1")]
1207    fn start_dkg_round_v1() {
1208        start_dkg_round::<FrostCoordinator<v1::Aggregator>>(None);
1209        start_dkg_round::<FrostCoordinator<v1::Aggregator>>(Some(12345u64));
1210    }
1211
1212    #[test]
1213    fn start_dkg_round_v2() {
1214        start_dkg_round::<FrostCoordinator<v2::Aggregator>>(None);
1215        start_dkg_round::<FrostCoordinator<v2::Aggregator>>(Some(12345u64));
1216    }
1217
1218    #[test]
1219    #[cfg(feature = "with_v1")]
1220    fn start_signing_round_v1() {
1221        start_signing_round::<FrostCoordinator<v1::Aggregator>>(None);
1222        start_signing_round::<FrostCoordinator<v1::Aggregator>>(Some(12345u64));
1223    }
1224
1225    #[test]
1226    fn start_signing_round_v2() {
1227        start_signing_round::<FrostCoordinator<v2::Aggregator>>(None);
1228        start_signing_round::<FrostCoordinator<v2::Aggregator>>(Some(12345u64));
1229    }
1230
1231    #[test]
1232    #[cfg(feature = "with_v1")]
1233    fn start_public_shares_v1() {
1234        start_public_shares::<v1::Aggregator>();
1235    }
1236
1237    #[test]
1238    fn start_public_shares_v2() {
1239        start_public_shares::<v2::Aggregator>();
1240    }
1241
1242    fn start_public_shares<Aggregator: AggregatorTrait>() {
1243        let mut rng = create_rng();
1244        let config = Config::new(10, 40, 28, Scalar::random(&mut rng));
1245        let mut coordinator = FrostCoordinator::<Aggregator>::new(config);
1246
1247        coordinator.state = State::DkgPublicDistribute; // Must be in this state before calling start public shares
1248
1249        let result = coordinator.start_public_shares().unwrap();
1250
1251        assert!(matches!(result.msg, Message::DkgBegin(_)));
1252        assert_eq!(coordinator.get_state(), State::DkgPublicGather);
1253        assert_eq!(coordinator.current_dkg_id, 0);
1254    }
1255
1256    #[test]
1257    #[cfg(feature = "with_v1")]
1258    fn start_private_shares_v1() {
1259        start_private_shares::<v1::Aggregator>();
1260    }
1261
1262    #[test]
1263    fn start_private_shares_v2() {
1264        start_private_shares::<v2::Aggregator>();
1265    }
1266
1267    fn start_private_shares<Aggregator: AggregatorTrait>() {
1268        let mut rng = create_rng();
1269        let config = Config::new(10, 40, 28, Scalar::random(&mut rng));
1270        let mut coordinator = FrostCoordinator::<Aggregator>::new(config);
1271
1272        coordinator.state = State::DkgPrivateDistribute; // Must be in this state before calling start private shares
1273
1274        let message = coordinator.start_private_shares().unwrap();
1275        assert!(matches!(message.msg, Message::DkgPrivateBegin(_)));
1276        assert_eq!(coordinator.get_state(), State::DkgPrivateGather);
1277        assert_eq!(coordinator.current_dkg_id, 0);
1278    }
1279
1280    #[test]
1281    #[cfg(feature = "with_v1")]
1282    fn dkg_public_share_v1() {
1283        dkg_public_share::<v1::Aggregator, v1::Signer>();
1284    }
1285
1286    #[test]
1287    fn dkg_public_share_v2() {
1288        dkg_public_share::<v2::Aggregator, v2::Signer>();
1289    }
1290
1291    /// test basic insertion and detection of duplicates for DkgPublicShares
1292    fn dkg_public_share<Aggregator: AggregatorTrait, Signer: SignerTrait>() {
1293        let ctx = 0u64.to_be_bytes();
1294        let mut rng = create_rng();
1295        let (coordinators, _) = setup::<FrostCoordinator<Aggregator>, Signer>(2, 1);
1296        let mut coordinator: FrostCoordinator<Aggregator> = coordinators[0].clone();
1297
1298        coordinator.start_dkg_round(None).unwrap(); // = State::DkgPublicGather;
1299        let public_shares = DkgPublicShares {
1300            dkg_id: 1,
1301            signer_id: 0,
1302            comms: vec![(
1303                0,
1304                PolyCommitment {
1305                    id: ID::new(&Scalar::new(), &Scalar::new(), &ctx, &mut rng),
1306                    poly: vec![],
1307                },
1308            )],
1309            kex_public_key: Point::from(Scalar::random(&mut rng)),
1310            kex_proof: schnorr::Proof {
1311                R: Point::new(),
1312                s: Scalar::new(),
1313            },
1314        };
1315        let packet = Packet {
1316            msg: Message::DkgPublicShares(public_shares.clone()),
1317            sig: Default::default(),
1318        };
1319        coordinator.gather_public_shares(&packet).unwrap();
1320        assert_eq!(1, coordinator.dkg_public_shares.len());
1321
1322        // check that a duplicate public share is ignored
1323        let dup_public_shares = DkgPublicShares {
1324            dkg_id: 1,
1325            signer_id: 0,
1326            comms: vec![(
1327                0,
1328                PolyCommitment {
1329                    id: ID::new(&Scalar::new(), &Scalar::new(), &ctx, &mut rng),
1330                    poly: vec![],
1331                },
1332            )],
1333            kex_public_key: Point::from(Scalar::random(&mut rng)),
1334            kex_proof: schnorr::Proof {
1335                R: Point::new(),
1336                s: Scalar::new(),
1337            },
1338        };
1339        let dup_packet = Packet {
1340            msg: Message::DkgPublicShares(dup_public_shares.clone()),
1341            sig: Default::default(),
1342        };
1343
1344        coordinator.gather_public_shares(&dup_packet).unwrap();
1345        assert_eq!(1, coordinator.dkg_public_shares.len());
1346        assert_eq!(
1347            public_shares,
1348            coordinator
1349                .dkg_public_shares
1350                .iter()
1351                .next()
1352                .unwrap()
1353                .1
1354                .clone()
1355        );
1356    }
1357
1358    #[test]
1359    #[cfg(feature = "with_v1")]
1360    fn dkg_private_share_v1() {
1361        dkg_private_share::<v1::Aggregator, v1::Signer>();
1362    }
1363
1364    #[test]
1365    fn dkg_private_share_v2() {
1366        dkg_private_share::<v2::Aggregator, v2::Signer>();
1367    }
1368
1369    /// test basic insertion and detection of duplicates for DkgPrivateShares
1370    fn dkg_private_share<Aggregator: AggregatorTrait, Signer: SignerTrait>() {
1371        let (coordinators, _) = setup::<FrostCoordinator<Aggregator>, Signer>(2, 1);
1372        let mut coordinator: FrostCoordinator<Aggregator> = coordinators[0].clone();
1373
1374        coordinator.state = State::DkgPrivateGather;
1375
1376        let private_share = DkgPrivateShares {
1377            dkg_id: 0,
1378            signer_id: 0,
1379            shares: vec![(1, HashMap::new())],
1380        };
1381        let packet = Packet {
1382            msg: Message::DkgPrivateShares(private_share.clone()),
1383            sig: Default::default(),
1384        };
1385        coordinator.gather_private_shares(&packet).unwrap();
1386        assert_eq!(1, coordinator.dkg_private_shares.len());
1387
1388        // check that a duplicate private share is ignored
1389        let dup_private_share = DkgPrivateShares {
1390            dkg_id: 0,
1391            signer_id: 0,
1392            shares: vec![(1, HashMap::new())],
1393        };
1394        let packet = Packet {
1395            msg: Message::DkgPrivateShares(dup_private_share.clone()),
1396            sig: Default::default(),
1397        };
1398        coordinator.gather_private_shares(&packet).unwrap();
1399        assert_eq!(1, coordinator.dkg_private_shares.len());
1400        assert_eq!(
1401            private_share,
1402            coordinator
1403                .dkg_private_shares
1404                .iter()
1405                .next()
1406                .unwrap()
1407                .1
1408                .clone()
1409        );
1410    }
1411
1412    #[test]
1413    #[cfg(feature = "with_v1")]
1414    fn nonce_response_v1() {
1415        nonce_response::<v1::Aggregator, v1::Signer>();
1416    }
1417
1418    #[test]
1419    fn nonce_response_v2() {
1420        nonce_response::<v2::Aggregator, v2::Signer>();
1421    }
1422
1423    /// test basic insertion and detection of duplicates for NonceResponse
1424    fn nonce_response<Aggregator: AggregatorTrait, Signer: SignerTrait>() {
1425        let mut rng = create_rng();
1426        let (coordinators, _) = setup::<FrostCoordinator<Aggregator>, Signer>(2, 1);
1427        let mut coordinator: FrostCoordinator<Aggregator> = coordinators[0].clone();
1428        let signature_type = SignatureType::Frost;
1429        let message = vec![0u8];
1430        coordinator.state = State::NonceGather(signature_type);
1431        coordinator.aggregate_public_key = Some(Point::from(Scalar::random(&mut rng)));
1432        // Populate dkg_end_messages so the DKG participation check passes
1433        for signer_id in 0..coordinator.config.num_signers {
1434            coordinator.dkg_end_messages.insert(
1435                signer_id,
1436                DkgEnd {
1437                    dkg_id: 0,
1438                    signer_id,
1439                    status: DkgStatus::Success,
1440                },
1441            );
1442        }
1443
1444        let nonce_response = NonceResponse {
1445            dkg_id: 0,
1446            sign_id: 0,
1447            sign_iter_id: 0,
1448            signer_id: 0,
1449            key_ids: vec![1u32],
1450            nonces: vec![PublicNonce {
1451                D: Point::from(Scalar::random(&mut rng)),
1452                E: Point::from(Scalar::random(&mut rng)),
1453            }],
1454            message: message.clone(),
1455        };
1456        let packet = Packet {
1457            msg: Message::NonceResponse(nonce_response.clone()),
1458            sig: Default::default(),
1459        };
1460        coordinator.gather_nonces(&packet, signature_type).unwrap();
1461        assert_eq!(1, coordinator.public_nonces.len());
1462
1463        // check that a duplicate private share is ignored
1464        let dup_nonce_response = NonceResponse {
1465            dkg_id: 0,
1466            sign_id: 0,
1467            sign_iter_id: 0,
1468            signer_id: 0,
1469            key_ids: vec![1u32],
1470            nonces: vec![PublicNonce {
1471                D: Point::from(Scalar::random(&mut rng)),
1472                E: Point::from(Scalar::random(&mut rng)),
1473            }],
1474            message: message.clone(),
1475        };
1476        let packet = Packet {
1477            msg: Message::NonceResponse(dup_nonce_response.clone()),
1478            sig: Default::default(),
1479        };
1480        coordinator.gather_nonces(&packet, signature_type).unwrap();
1481        assert_eq!(1, coordinator.public_nonces.len());
1482        assert_eq!(
1483            nonce_response,
1484            coordinator.public_nonces.iter().next().unwrap().1.clone()
1485        );
1486    }
1487
1488    #[test]
1489    #[cfg(feature = "with_v1")]
1490    fn sig_share_v1() {
1491        sig_share::<v1::Aggregator, v1::Signer>();
1492    }
1493
1494    #[test]
1495    fn sig_share_v2() {
1496        sig_share::<v2::Aggregator, v2::Signer>();
1497    }
1498
1499    /// test basic insertion and detection of duplicates for SignatureShareResponse
1500    fn sig_share<Aggregator: AggregatorTrait, Signer: SignerTrait>() {
1501        let mut rng = create_rng();
1502        let (coordinators, _) = setup::<FrostCoordinator<Aggregator>, Signer>(2, 1);
1503        let mut coordinator = coordinators[0].clone();
1504        let signature_type = SignatureType::Frost;
1505
1506        coordinator.ids_to_await = (0..coordinator.config.num_signers).collect();
1507        coordinator.state = State::SigShareGather(signature_type);
1508        // Populate dkg_end_messages so the DKG participation check passes
1509        for signer_id in 0..coordinator.config.num_signers {
1510            coordinator.dkg_end_messages.insert(
1511                signer_id,
1512                DkgEnd {
1513                    dkg_id: 0,
1514                    signer_id,
1515                    status: DkgStatus::Success,
1516                },
1517            );
1518        }
1519
1520        let signature_share = SignatureShare {
1521            id: 1,
1522            z_i: Scalar::random(&mut rng),
1523            key_ids: vec![1],
1524        };
1525        let sig_share_response = SignatureShareResponse {
1526            dkg_id: 0,
1527            sign_id: 0,
1528            sign_iter_id: 0,
1529            signer_id: 0,
1530            signature_shares: vec![signature_share.clone()],
1531        };
1532        let packet = Packet {
1533            msg: Message::SignatureShareResponse(sig_share_response.clone()),
1534            sig: Default::default(),
1535        };
1536        coordinator
1537            .gather_sig_shares(&packet, signature_type)
1538            .unwrap();
1539        assert_eq!(1, coordinator.signature_shares.len());
1540
1541        // check that a duplicate private share is ignored
1542        let dup_signature_share = SignatureShare {
1543            id: 1,
1544            z_i: Scalar::random(&mut rng),
1545            key_ids: vec![1],
1546        };
1547        let dup_sig_share_response = SignatureShareResponse {
1548            dkg_id: 0,
1549            sign_id: 0,
1550            sign_iter_id: 0,
1551            signer_id: 0,
1552            signature_shares: vec![dup_signature_share.clone()],
1553        };
1554        let packet = Packet {
1555            msg: Message::SignatureShareResponse(dup_sig_share_response.clone()),
1556            sig: Default::default(),
1557        };
1558        coordinator
1559            .gather_sig_shares(&packet, signature_type)
1560            .unwrap();
1561        assert_eq!(1, coordinator.signature_shares.len());
1562        assert_eq!(
1563            vec![signature_share],
1564            coordinator
1565                .signature_shares
1566                .iter()
1567                .next()
1568                .unwrap()
1569                .1
1570                .clone()
1571        );
1572    }
1573
1574    #[test]
1575    #[cfg(feature = "with_v1")]
1576    fn run_dkg_sign_v1() {
1577        run_dkg_sign::<FrostCoordinator<v1::Aggregator>, v1::Signer>(5, 2);
1578    }
1579
1580    #[test]
1581    fn run_dkg_sign_v2() {
1582        run_dkg_sign::<FrostCoordinator<v2::Aggregator>, v2::Signer>(5, 2);
1583    }
1584
1585    #[test]
1586    #[cfg(feature = "with_v1")]
1587    fn sign_threshold_sign_v1() {
1588        sign_threshold_sign::<v1::Aggregator, v1::Signer>();
1589    }
1590
1591    #[test]
1592    fn sign_threshold_sign_v2() {
1593        sign_threshold_sign::<v2::Aggregator, v2::Signer>();
1594    }
1595
1596    fn sign_threshold_sign<Aggregator: AggregatorTrait, Signer: SignerTrait>() {
1597        let (mut coordinators, mut signers) = run_dkg::<FrostCoordinator<Aggregator>, Signer>(5, 2);
1598
1599        // Require all key_ids to participate in the signing round.
1600        for coordinator in &mut coordinators {
1601            coordinator.config.sign_threshold = coordinator.config.num_keys;
1602        }
1603
1604        let msg = "It was many and many a year ago, in a kingdom by the sea"
1605            .as_bytes()
1606            .to_vec();
1607        let signature_type = SignatureType::Frost;
1608        let message = coordinators
1609            .first_mut()
1610            .unwrap()
1611            .start_signing_round(&msg, signature_type, None)
1612            .unwrap();
1613        assert_eq!(
1614            coordinators.first().unwrap().state,
1615            State::NonceGather(signature_type)
1616        );
1617
1618        // Drive nonce gathering: every signer responds, so we should reach the threshold.
1619        let (outbound_messages, operation_results) =
1620            feedback_messages(&mut coordinators, &mut signers, &[message]);
1621        assert!(operation_results.is_empty());
1622        for coordinator in &coordinators {
1623            assert_eq!(coordinator.state, State::SigShareGather(signature_type));
1624        }
1625
1626        // All signers contributed nonces.
1627        for coordinator in &coordinators {
1628            assert_eq!(coordinator.public_nonces.len(), signers.len());
1629        }
1630
1631        assert_eq!(outbound_messages.len(), 1);
1632        assert!(
1633            matches!(outbound_messages[0].msg, Message::SignatureShareRequest(_)),
1634            "Expected SignatureShareRequest message"
1635        );
1636
1637        // Drive sig share gathering and aggregation.
1638        let (outbound_messages, operation_results) =
1639            feedback_messages(&mut coordinators, &mut signers, &outbound_messages);
1640
1641        for coordinator in &coordinators {
1642            assert_eq!(coordinator.signature_shares.len(), signers.len());
1643        }
1644
1645        assert!(outbound_messages.is_empty());
1646        assert_eq!(operation_results.len(), 1);
1647        let OperationResult::Sign(sig) = &operation_results[0] else {
1648            panic!("Expected Signature Operation result")
1649        };
1650        assert!(sig.verify(
1651            &coordinators
1652                .first()
1653                .unwrap()
1654                .aggregate_public_key
1655                .expect("No aggregate public key set!"),
1656            &msg
1657        ));
1658        for coordinator in &coordinators {
1659            assert_eq!(coordinator.state, State::Idle);
1660        }
1661    }
1662
1663    #[test]
1664    #[cfg(feature = "with_v1")]
1665    fn check_signature_shares_v1() {
1666        check_signature_shares::<FrostCoordinator<v1::Aggregator>, v1::Signer>(
1667            5,
1668            1,
1669            SignatureType::Frost,
1670            vec![1],
1671        );
1672        check_signature_shares::<FrostCoordinator<v1::Aggregator>, v1::Signer>(
1673            5,
1674            1,
1675            SignatureType::Schnorr,
1676            vec![1],
1677        );
1678        check_signature_shares::<FrostCoordinator<v1::Aggregator>, v1::Signer>(
1679            5,
1680            1,
1681            SignatureType::Taproot(None),
1682            vec![1],
1683        );
1684        check_signature_shares::<FrostCoordinator<v1::Aggregator>, v1::Signer>(
1685            5,
1686            1,
1687            SignatureType::Taproot(Some([23u8; 32])),
1688            vec![1],
1689        );
1690    }
1691
1692    #[test]
1693    fn check_signature_shares_v2() {
1694        check_signature_shares::<FrostCoordinator<v2::Aggregator>, v2::Signer>(
1695            5,
1696            2,
1697            SignatureType::Frost,
1698            vec![0],
1699        );
1700        check_signature_shares::<FrostCoordinator<v2::Aggregator>, v2::Signer>(
1701            5,
1702            2,
1703            SignatureType::Schnorr,
1704            vec![0],
1705        );
1706        check_signature_shares::<FrostCoordinator<v2::Aggregator>, v2::Signer>(
1707            5,
1708            2,
1709            SignatureType::Taproot(None),
1710            vec![0],
1711        );
1712        check_signature_shares::<FrostCoordinator<v2::Aggregator>, v2::Signer>(
1713            5,
1714            2,
1715            SignatureType::Taproot(Some([23u8; 32])),
1716            vec![0],
1717        );
1718    }
1719
1720    #[test]
1721    #[cfg(feature = "with_v1")]
1722    fn bad_signature_share_request_v1() {
1723        bad_signature_share_request::<FrostCoordinator<v1::Aggregator>, v1::Signer>(5, 2);
1724    }
1725
1726    #[test]
1727    fn bad_signature_share_request_v2() {
1728        bad_signature_share_request::<FrostCoordinator<v2::Aggregator>, v2::Signer>(5, 2);
1729    }
1730
1731    #[test]
1732    #[cfg(feature = "with_v1")]
1733    fn invalid_nonce_v1() {
1734        invalid_nonce::<FrostCoordinator<v1::Aggregator>, v1::Signer>(5, 2);
1735    }
1736
1737    #[test]
1738    fn invalid_nonce_v2() {
1739        invalid_nonce::<FrostCoordinator<v2::Aggregator>, v2::Signer>(5, 2);
1740    }
1741
1742    #[test]
1743    fn process_inbound_messages_v2() {
1744        run_dkg_sign::<FrostCoordinator<v2::Aggregator>, v2::Signer>(5, 2);
1745    }
1746
1747    #[test]
1748    #[cfg(feature = "with_v1")]
1749    fn old_round_ids_are_ignored_v1() {
1750        old_round_ids_are_ignored::<v1::Aggregator>();
1751    }
1752
1753    #[test]
1754    fn old_round_ids_are_ignored_v2() {
1755        old_round_ids_are_ignored::<v2::Aggregator>();
1756    }
1757
1758    fn old_round_ids_are_ignored<Aggregator: AggregatorTrait>() {
1759        let mut rng = create_rng();
1760        let mut config = Config::new(10, 40, 28, Scalar::random(&mut rng));
1761        config.verify_packet_sigs = false;
1762        let mut coordinator = FrostCoordinator::<Aggregator>::new(config);
1763        let id: u64 = 10;
1764        let old_id = id;
1765        coordinator.current_dkg_id = id;
1766        coordinator.current_sign_id = id;
1767        // Attempt to start an old DKG round
1768        let (packet, result) = coordinator
1769            .process(&Packet {
1770                sig: vec![],
1771                msg: Message::DkgBegin(DkgBegin { dkg_id: old_id }),
1772            })
1773            .unwrap();
1774        assert!(packet.is_none());
1775        assert!(result.is_none());
1776        assert_eq!(coordinator.state, State::Idle);
1777        assert_eq!(coordinator.current_dkg_id, id);
1778
1779        // Attempt to start the same DKG round
1780        let (packet, result) = coordinator
1781            .process(&Packet {
1782                sig: vec![],
1783                msg: Message::DkgBegin(DkgBegin { dkg_id: id }),
1784            })
1785            .unwrap();
1786        assert!(packet.is_none());
1787        assert!(result.is_none());
1788        assert_eq!(coordinator.state, State::Idle);
1789        assert_eq!(coordinator.current_dkg_id, id);
1790
1791        // Attempt to start an old Sign round
1792        let (packet, result) = coordinator
1793            .process(&Packet {
1794                sig: vec![],
1795                msg: Message::NonceRequest(NonceRequest {
1796                    dkg_id: id,
1797                    sign_id: old_id,
1798                    message: vec![],
1799                    sign_iter_id: id,
1800                    signature_type: SignatureType::Frost,
1801                }),
1802            })
1803            .unwrap();
1804        assert!(packet.is_none());
1805        assert!(result.is_none());
1806        assert_eq!(coordinator.state, State::Idle);
1807        assert_eq!(coordinator.current_sign_id, id);
1808
1809        // Attempt to start the same Sign round
1810        let (packet, result) = coordinator
1811            .process(&Packet {
1812                sig: vec![],
1813                msg: Message::NonceRequest(NonceRequest {
1814                    dkg_id: id,
1815                    sign_id: id,
1816                    message: vec![],
1817                    sign_iter_id: id,
1818                    signature_type: SignatureType::Frost,
1819                }),
1820            })
1821            .unwrap();
1822        assert!(packet.is_none());
1823        assert!(result.is_none());
1824        assert_eq!(coordinator.state, State::Idle);
1825        assert_eq!(coordinator.current_sign_id, id);
1826    }
1827
1828    #[test]
1829    #[cfg(feature = "with_v1")]
1830    fn empty_public_shares_v1() {
1831        empty_public_shares::<FrostCoordinator<v1::Aggregator>, v1::Signer>(5, 2);
1832    }
1833
1834    #[test]
1835    fn empty_public_shares_v2() {
1836        empty_public_shares::<FrostCoordinator<v2::Aggregator>, v2::Signer>(5, 2);
1837    }
1838
1839    #[test]
1840    #[cfg(feature = "with_v1")]
1841    fn empty_private_shares_v1() {
1842        empty_private_shares::<FrostCoordinator<v1::Aggregator>, v1::Signer>(5, 2);
1843    }
1844
1845    #[test]
1846    fn empty_private_shares_v2() {
1847        empty_private_shares::<FrostCoordinator<v2::Aggregator>, v2::Signer>(5, 2);
1848    }
1849
1850    #[test]
1851    #[cfg(feature = "with_v1")]
1852    fn verify_packet_sigs_v1() {
1853        verify_packet_sigs::<FrostCoordinator<v1::Aggregator>, v1::Signer>();
1854    }
1855
1856    #[test]
1857    fn verify_packet_sigs_v2() {
1858        verify_packet_sigs::<FrostCoordinator<v2::Aggregator>, v2::Signer>();
1859    }
1860
1861    #[test]
1862    #[cfg(feature = "with_v1")]
1863    fn btc_sign_verify_v1() {
1864        btc_sign_verify::<FrostCoordinator<v1::Aggregator>, v1::Signer>(5, 2);
1865    }
1866
1867    #[test]
1868    fn btc_sign_verify_v2() {
1869        btc_sign_verify::<FrostCoordinator<v2::Aggregator>, v2::Signer>(5, 2);
1870    }
1871}