wsts 14.0.2

Weighted Schnorr Threshold Signatures, based on FROST
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use aes_gcm::Error as AesGcmError;
use core::num::TryFromIntError;
use serde::{Deserialize, Serialize};
use thiserror::Error;

use crate::curve::{point::Error as PointError, scalar::Scalar};

#[derive(Error, Debug, Clone, Serialize, Deserialize, PartialEq)]
/// Errors which can happen during distributed key generation
pub enum DkgError {
    #[error("missing public shares from {0:?}")]
    /// The public shares which were missing
    MissingPublicShares(Vec<u32>),
    #[error("missing private shares for/from {0:?}")]
    /// The private shares which were missing
    MissingPrivateShares(Vec<(u32, u32)>),
    #[error("bad public shares {0:?}")]
    /// The public shares that failed to verify or were the wrong size
    BadPublicShares(Vec<u32>),
    #[error("bad private shares {0:?}")]
    /// The private shares which failed to verify
    BadPrivateShares(Vec<u32>),
    #[error("point error {0:?}")]
    /// An error during point operations
    Point(PointError),
    #[error("integer conversion error")]
    /// An error during integer conversion operations
    TryFromInt,
}

impl From<PointError> for DkgError {
    fn from(e: PointError) -> Self {
        DkgError::Point(e)
    }
}

impl From<TryFromIntError> for DkgError {
    fn from(_e: TryFromIntError) -> Self {
        Self::TryFromInt
    }
}

#[derive(Error, Debug, Clone, Serialize, Deserialize, PartialEq)]
/// Errors which can happen during signature aggregation
pub enum AggregatorError {
    #[error("bad poly commitments {0:?}")]
    /// The polynomial commitments which failed verification or were the wrong size
    BadPolyCommitments(Vec<Scalar>),
    #[error("bad nonce length (expected {0} got {1}")]
    /// The nonce length was the wrong size
    BadNonceLen(usize, usize),
    #[error("bad party keys from {0:?}")]
    /// The party public keys which failed
    BadPartyKeys(Vec<u32>),
    #[error("bad party sigs from {0:?}")]
    /// The party signatures which failed to verify
    BadPartySigs(Vec<u32>),
    #[error("bad group sig")]
    /// The aggregate group signature failed to verify
    BadGroupSig,
    #[error("integer conversion error")]
    /// An error during integer conversion operations
    TryFromInt,
}

impl From<TryFromIntError> for AggregatorError {
    fn from(_e: TryFromIntError) -> Self {
        Self::TryFromInt
    }
}

#[derive(Error, Debug, Clone, PartialEq)]
/// Errors which can happen during signature aggregation
pub enum EncryptionError {
    #[error("AES nonce was missing from the buffer")]
    /// AES nonce was missing from the buffer")]
    MissingNonce,
    #[error("AES data was missing from the buffer")]
    /// AES data was missing from the buffer")]
    MissingData,
    #[error("AES GCM error {0:?}")]
    /// Wrapped aes_gcm::Error, an opaque type
    AesGcm(AesGcmError),
}

impl From<AesGcmError> for EncryptionError {
    fn from(e: AesGcmError) -> Self {
        Self::AesGcm(e)
    }
}