1use blake2::digest::{Digest, FixedOutput};
3use blst::BLST_ERROR;
4
5use crate::bls_multi_signature::{
6 BlsSignature, BlsVerificationKey, BlsVerificationKeyProofOfPossession,
7};
8use crate::merkle_tree::{MerkleBatchPath, MerklePath};
9
10#[derive(Debug, thiserror::Error, Eq, PartialEq)]
12pub enum MultiSignatureError {
13 #[error("Invalid single signature")]
15 SignatureInvalid(BlsSignature),
16
17 #[error("Invalid aggregated signature")]
19 AggregateSignatureInvalid,
20
21 #[error("Invalid bytes")]
23 SerializationError,
24
25 #[error("Key with invalid PoP")]
27 KeyInvalid(Box<BlsVerificationKeyProofOfPossession>),
28
29 #[error("One signature in the batch is invalid")]
31 BatchInvalid,
32
33 #[error("Single signature is the infinity")]
35 SignatureInfinity(BlsSignature),
36
37 #[error("Verification key is the infinity")]
39 VerificationKeyInfinity(Box<BlsVerificationKey>),
40}
41
42#[derive(Debug, Clone, thiserror::Error)]
44pub enum MerkleTreeError<D: Digest + FixedOutput> {
45 #[error("Serialization of a merkle tree failed")]
47 SerializationError,
48
49 #[error("Path does not verify against root")]
51 PathInvalid(MerklePath<D>),
52
53 #[error("Batch path does not verify against root")]
55 BatchPathInvalid(MerkleBatchPath<D>),
56}
57
58#[derive(Debug, Clone, thiserror::Error)]
60pub enum StmSignatureError {
61 #[error("Received index, {0}, is higher than what the security parameter allows, {1}.")]
63 IndexBoundFailed(u64, u64),
64
65 #[error("The claimed evaluation of function phi is incorrect.")]
67 EvalInvalid([u8; 64]),
68
69 #[error("Lottery for this epoch was lost.")]
71 LotteryLost,
72
73 #[error("A provided signature is invalid")]
75 SignatureInvalid(BlsSignature),
76
77 #[error("Batch verification of STM signatures failed")]
79 BatchInvalid,
80
81 #[error("Invalid bytes")]
83 SerializationError,
84}
85
86impl From<MultiSignatureError> for StmSignatureError {
87 fn from(e: MultiSignatureError) -> Self {
88 match e {
89 MultiSignatureError::SerializationError => Self::SerializationError,
90 MultiSignatureError::SignatureInvalid(e) => Self::SignatureInvalid(e),
91 MultiSignatureError::BatchInvalid => unreachable!(),
92 MultiSignatureError::KeyInvalid(_) => unreachable!(),
93 MultiSignatureError::AggregateSignatureInvalid => unreachable!(),
94 MultiSignatureError::SignatureInfinity(_) => unreachable!(),
95 MultiSignatureError::VerificationKeyInfinity(_) => unreachable!(),
96 }
97 }
98}
99
100impl<D: Digest + FixedOutput> From<MerkleTreeError<D>> for StmSignatureError {
101 fn from(e: MerkleTreeError<D>) -> Self {
102 match e {
103 MerkleTreeError::SerializationError => Self::SerializationError,
104 _ => unreachable!(),
105 }
106 }
107}
108
109#[derive(Debug, Clone, thiserror::Error)]
111pub enum AggregationError {
112 #[error("Not enough signatures. Got only {0} out of {1}.")]
114 NotEnoughSignatures(u64, u64),
115
116 #[error("Invalid usize conversion")]
118 UsizeConversionInvalid,
119}
120
121#[derive(Debug, Clone, thiserror::Error)]
123pub enum CoreVerifierError {
124 #[error("No Quorum was found. Expected {0} signatures but got {1}")]
126 NoQuorum(u64, u64),
127
128 #[error("Indices are not unique.")]
130 IndexNotUnique,
131
132 #[error("Aggregate signature is invalid")]
134 AggregateSignatureInvalid,
135
136 #[error("Individual signature is invalid: {0}")]
138 IndividualSignatureInvalid(#[source] StmSignatureError),
139}
140
141impl From<AggregationError> for CoreVerifierError {
142 fn from(e: AggregationError) -> Self {
143 match e {
144 AggregationError::NotEnoughSignatures(e, _e) => Self::NoQuorum(e, e),
145 AggregationError::UsizeConversionInvalid => unreachable!(),
146 }
147 }
148}
149
150impl From<MultiSignatureError> for CoreVerifierError {
151 fn from(e: MultiSignatureError) -> Self {
152 match e {
153 MultiSignatureError::AggregateSignatureInvalid => Self::AggregateSignatureInvalid,
154 MultiSignatureError::BatchInvalid => unreachable!(),
155 MultiSignatureError::SerializationError => unreachable!(),
156 MultiSignatureError::KeyInvalid(_) => unreachable!(),
157 MultiSignatureError::SignatureInvalid(_e) => unreachable!(),
158 MultiSignatureError::SignatureInfinity(_) => unreachable!(),
159 MultiSignatureError::VerificationKeyInfinity(_) => unreachable!(),
160 }
161 }
162}
163
164impl From<StmSignatureError> for CoreVerifierError {
165 fn from(e: StmSignatureError) -> Self {
166 CoreVerifierError::IndividualSignatureInvalid(e)
167 }
168}
169
170#[derive(Debug, Clone, thiserror::Error)]
172pub enum StmAggregateSignatureError<D: Digest + FixedOutput> {
173 #[error("Aggregated key does not correspond to the expected key.")]
175 IvkInvalid(Box<BlsVerificationKey>),
176
177 #[error("Invalid bytes")]
179 SerializationError,
180
181 #[error("Batch path does not verify against root")]
183 PathInvalid(MerkleBatchPath<D>),
184
185 #[error("Batch verification of STM aggregate signatures failed")]
187 BatchInvalid,
188
189 #[error("Core verification error: {0}")]
191 CoreVerificationError(#[source] CoreVerifierError),
192}
193
194impl<D: Digest + FixedOutput> From<MerkleTreeError<D>> for StmAggregateSignatureError<D> {
195 fn from(e: MerkleTreeError<D>) -> Self {
196 match e {
197 MerkleTreeError::BatchPathInvalid(e) => Self::PathInvalid(e),
198 MerkleTreeError::SerializationError => Self::SerializationError,
199 MerkleTreeError::PathInvalid(_e) => unreachable!(),
200 }
201 }
202}
203
204impl<D: Digest + FixedOutput> From<MultiSignatureError> for StmAggregateSignatureError<D> {
205 fn from(e: MultiSignatureError) -> Self {
206 match e {
207 MultiSignatureError::AggregateSignatureInvalid => {
208 Self::from(CoreVerifierError::from(e))
209 }
210 MultiSignatureError::BatchInvalid => Self::BatchInvalid,
211 MultiSignatureError::SerializationError => unreachable!(),
212 MultiSignatureError::KeyInvalid(_) => unreachable!(),
213 MultiSignatureError::SignatureInvalid(_) => {
214 Self::CoreVerificationError(CoreVerifierError::from(e))
215 }
216 MultiSignatureError::SignatureInfinity(_) => {
217 Self::CoreVerificationError(CoreVerifierError::from(e))
218 }
219 MultiSignatureError::VerificationKeyInfinity(_) => {
220 Self::CoreVerificationError(CoreVerifierError::from(e))
221 }
222 }
223 }
224}
225
226impl<D: Digest + FixedOutput> From<CoreVerifierError> for StmAggregateSignatureError<D> {
227 fn from(e: CoreVerifierError) -> Self {
228 Self::CoreVerificationError(e)
229 }
230}
231
232impl<D: Digest + FixedOutput> From<StmSignatureError> for StmAggregateSignatureError<D> {
233 fn from(e: StmSignatureError) -> Self {
234 match e {
235 StmSignatureError::SerializationError => Self::SerializationError,
236 _ => unreachable!(),
237 }
238 }
239}
240
241#[derive(Debug, Clone, thiserror::Error, PartialEq, Eq)]
243pub enum RegisterError {
244 #[error("This key has already been registered.")]
246 KeyRegistered(Box<BlsVerificationKey>),
247
248 #[error("Verification key is the infinity")]
250 VerificationKeyInfinity(Box<BlsVerificationKey>),
251
252 #[error("The verification of correctness of the supplied key is invalid.")]
254 KeyInvalid(Box<BlsVerificationKeyProofOfPossession>),
255
256 #[error("Serialization error")]
258 SerializationError,
259
260 #[error("Initializer not registered. Cannot participate as a signer.")]
262 UnregisteredInitializer,
263}
264
265impl From<MultiSignatureError> for RegisterError {
266 fn from(e: MultiSignatureError) -> Self {
267 match e {
268 MultiSignatureError::SerializationError => Self::SerializationError,
269 MultiSignatureError::KeyInvalid(e) => Self::KeyInvalid(e),
270 MultiSignatureError::VerificationKeyInfinity(e) => Self::VerificationKeyInfinity(e),
271 _ => unreachable!(),
272 }
273 }
274}
275
276pub(crate) fn blst_err_to_mithril(
279 e: BLST_ERROR,
280 sig: Option<BlsSignature>,
281 key: Option<BlsVerificationKey>,
282) -> Result<(), MultiSignatureError> {
283 match e {
284 BLST_ERROR::BLST_SUCCESS => Ok(()),
285 BLST_ERROR::BLST_PK_IS_INFINITY => {
286 if let Some(s) = sig {
287 return Err(MultiSignatureError::SignatureInfinity(s));
288 }
289 if let Some(vk) = key {
290 return Err(MultiSignatureError::VerificationKeyInfinity(Box::new(vk)));
291 }
292 Err(MultiSignatureError::SerializationError)
293 }
294 BLST_ERROR::BLST_VERIFY_FAIL => {
295 if let Some(s) = sig {
296 Err(MultiSignatureError::SignatureInvalid(s))
297 } else {
298 Err(MultiSignatureError::AggregateSignatureInvalid)
299 }
300 }
301 _ => Err(MultiSignatureError::SerializationError),
302 }
303}