commonware_cryptography/bls12381/
scheme.rs

1//! BLS12-381 implementation of the [crate::Verifier] and [crate::Signer] traits.
2//!
3//! This implementation uses the `blst` crate for BLS12-381 operations. This
4//! crate implements serialization according to the "ZCash BLS12-381" specification
5//! (<https://github.com/supranational/blst/tree/master?tab=readme-ov-file#serialization-format>)
6//! and hashes messages according to RFC 9380.
7//!
8//! # Example
9//! ```rust
10//! use commonware_cryptography::{bls12381, PrivateKey, PublicKey, Signature, Verifier as _, Signer as _};
11//! use commonware_math::algebra::Random;
12//! use rand::rngs::OsRng;
13//!
14//! // Generate a new private key
15//! let mut signer = bls12381::PrivateKey::random(&mut OsRng);
16//!
17//! // Create a message to sign
18//! let namespace = &b"demo"[..];
19//! let msg = b"hello, world!";
20//!
21//! // Sign the message
22//! let signature = signer.sign(namespace, msg);
23//!
24//! // Verify the signature
25//! assert!(signer.public_key().verify(namespace, msg, &signature));
26//! ```
27
28use super::primitives::{
29    group::{self, Scalar},
30    ops,
31    variant::{MinPk, Variant},
32};
33use crate::{Array, BatchVerifier, Signer as _};
34#[cfg(not(feature = "std"))]
35use alloc::borrow::Cow;
36#[cfg(not(feature = "std"))]
37use alloc::vec::Vec;
38use bytes::{Buf, BufMut};
39use commonware_codec::{
40    DecodeExt, EncodeFixed, Error as CodecError, FixedSize, Read, ReadExt, Write,
41};
42use commonware_math::algebra::Random;
43use commonware_utils::{hex, union_unique, Span};
44use core::{
45    fmt::{Debug, Display, Formatter},
46    hash::{Hash, Hasher},
47    ops::Deref,
48};
49use rand_core::CryptoRngCore;
50#[cfg(feature = "std")]
51use std::borrow::Cow;
52use zeroize::{Zeroize, ZeroizeOnDrop};
53
54const CURVE_NAME: &str = "bls12381";
55
56/// BLS12-381 private key.
57#[derive(Clone, Eq, PartialEq, Zeroize, ZeroizeOnDrop)]
58pub struct PrivateKey {
59    raw: [u8; group::PRIVATE_KEY_LENGTH],
60    key: group::Private,
61}
62
63impl Write for PrivateKey {
64    fn write(&self, buf: &mut impl BufMut) {
65        self.raw.write(buf);
66    }
67}
68
69impl Read for PrivateKey {
70    type Cfg = ();
71
72    fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, CodecError> {
73        let raw = <[u8; Self::SIZE]>::read(buf)?;
74        let key = group::Private::decode(raw.as_ref())
75            .map_err(|e| CodecError::Wrapped(CURVE_NAME, e.into()))?;
76        Ok(Self { raw, key })
77    }
78}
79
80impl FixedSize for PrivateKey {
81    const SIZE: usize = group::PRIVATE_KEY_LENGTH;
82}
83
84impl Span for PrivateKey {}
85
86impl Array for PrivateKey {}
87
88impl Hash for PrivateKey {
89    fn hash<H: Hasher>(&self, state: &mut H) {
90        self.raw.hash(state);
91    }
92}
93
94impl Ord for PrivateKey {
95    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
96        self.raw.cmp(&other.raw)
97    }
98}
99
100impl PartialOrd for PrivateKey {
101    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
102        Some(self.cmp(other))
103    }
104}
105
106impl AsRef<[u8]> for PrivateKey {
107    fn as_ref(&self) -> &[u8] {
108        &self.raw
109    }
110}
111
112impl Deref for PrivateKey {
113    type Target = [u8];
114    fn deref(&self) -> &[u8] {
115        &self.raw
116    }
117}
118
119impl From<Scalar> for PrivateKey {
120    fn from(key: Scalar) -> Self {
121        let raw = key.encode_fixed();
122        Self { raw, key }
123    }
124}
125
126impl Debug for PrivateKey {
127    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
128        write!(f, "{}", hex(&self.raw))
129    }
130}
131
132impl Display for PrivateKey {
133    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
134        write!(f, "{}", hex(&self.raw))
135    }
136}
137
138impl crate::PrivateKey for PrivateKey {}
139
140impl crate::Signer for PrivateKey {
141    type Signature = Signature;
142    type PublicKey = PublicKey;
143
144    fn public_key(&self) -> Self::PublicKey {
145        PublicKey::from(ops::compute_public::<MinPk>(&self.key))
146    }
147
148    fn sign(&self, namespace: &[u8], msg: &[u8]) -> Self::Signature {
149        self.sign_inner(Some(namespace), msg)
150    }
151}
152
153impl PrivateKey {
154    #[inline(always)]
155    fn sign_inner(&self, namespace: Option<&[u8]>, message: &[u8]) -> Signature {
156        ops::sign_message::<MinPk>(&self.key, namespace, message).into()
157    }
158}
159
160impl Random for PrivateKey {
161    fn random(mut rng: impl CryptoRngCore) -> Self {
162        let (private, _) = ops::keypair::<_, MinPk>(&mut rng);
163        let raw = private.encode_fixed();
164        Self { raw, key: private }
165    }
166}
167
168#[cfg(feature = "arbitrary")]
169impl arbitrary::Arbitrary<'_> for PrivateKey {
170    fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
171        use rand::{rngs::StdRng, SeedableRng};
172
173        let mut rand = StdRng::from_seed(u.arbitrary::<[u8; 32]>()?);
174        Ok(Self::random(&mut rand))
175    }
176}
177
178impl crate::PublicKey for PublicKey {}
179
180impl crate::Verifier for PublicKey {
181    type Signature = Signature;
182
183    fn verify(&self, namespace: &[u8], msg: &[u8], sig: &Self::Signature) -> bool {
184        self.verify_inner(Some(namespace), msg, sig)
185    }
186}
187
188impl PublicKey {
189    #[inline(always)]
190    fn verify_inner(
191        &self,
192        namespace: Option<&[u8]>,
193        message: &[u8],
194        signature: &Signature,
195    ) -> bool {
196        ops::verify_message::<MinPk>(&self.key, namespace, message, &signature.signature).is_ok()
197    }
198}
199
200/// BLS12-381 public key.
201#[derive(Clone, Eq, PartialEq)]
202pub struct PublicKey {
203    raw: [u8; <MinPk as Variant>::Public::SIZE],
204    key: <MinPk as Variant>::Public,
205}
206
207impl From<PrivateKey> for PublicKey {
208    fn from(private_key: PrivateKey) -> Self {
209        private_key.public_key()
210    }
211}
212
213impl AsRef<<MinPk as Variant>::Public> for PublicKey {
214    fn as_ref(&self) -> &<MinPk as Variant>::Public {
215        &self.key
216    }
217}
218
219impl Write for PublicKey {
220    fn write(&self, buf: &mut impl BufMut) {
221        self.raw.write(buf);
222    }
223}
224
225impl Read for PublicKey {
226    type Cfg = ();
227
228    fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, CodecError> {
229        let raw = <[u8; Self::SIZE]>::read(buf)?;
230        let key = <MinPk as Variant>::Public::decode(raw.as_ref())
231            .map_err(|e| CodecError::Wrapped(CURVE_NAME, e.into()))?;
232        Ok(Self { raw, key })
233    }
234}
235
236impl FixedSize for PublicKey {
237    const SIZE: usize = <MinPk as Variant>::Public::SIZE;
238}
239
240impl Span for PublicKey {}
241
242impl Array for PublicKey {}
243
244impl Hash for PublicKey {
245    fn hash<H: Hasher>(&self, state: &mut H) {
246        self.raw.hash(state);
247    }
248}
249
250impl Ord for PublicKey {
251    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
252        self.raw.cmp(&other.raw)
253    }
254}
255
256impl PartialOrd for PublicKey {
257    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
258        Some(self.cmp(other))
259    }
260}
261
262impl AsRef<[u8]> for PublicKey {
263    fn as_ref(&self) -> &[u8] {
264        &self.raw
265    }
266}
267
268impl Deref for PublicKey {
269    type Target = [u8];
270    fn deref(&self) -> &[u8] {
271        &self.raw
272    }
273}
274
275impl From<<MinPk as Variant>::Public> for PublicKey {
276    fn from(key: <MinPk as Variant>::Public) -> Self {
277        let raw = key.encode_fixed();
278        Self { raw, key }
279    }
280}
281
282impl Debug for PublicKey {
283    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
284        write!(f, "{}", hex(&self.raw))
285    }
286}
287
288impl Display for PublicKey {
289    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
290        write!(f, "{}", hex(&self.raw))
291    }
292}
293
294#[cfg(feature = "arbitrary")]
295impl arbitrary::Arbitrary<'_> for PublicKey {
296    fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
297        use crate::Signer;
298        use rand::{rngs::StdRng, SeedableRng};
299
300        let mut rand = StdRng::from_seed(u.arbitrary::<[u8; 32]>()?);
301        let private_key = PrivateKey::random(&mut rand);
302        Ok(private_key.public_key())
303    }
304}
305
306/// BLS12-381 signature.
307#[derive(Clone, Eq, PartialEq)]
308pub struct Signature {
309    raw: [u8; <MinPk as Variant>::Signature::SIZE],
310    signature: <MinPk as Variant>::Signature,
311}
312
313impl crate::Signature for Signature {}
314
315impl AsRef<<MinPk as Variant>::Signature> for Signature {
316    fn as_ref(&self) -> &<MinPk as Variant>::Signature {
317        &self.signature
318    }
319}
320
321impl Write for Signature {
322    fn write(&self, buf: &mut impl BufMut) {
323        self.raw.write(buf);
324    }
325}
326
327impl Read for Signature {
328    type Cfg = ();
329
330    fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, CodecError> {
331        let raw = <[u8; Self::SIZE]>::read(buf)?;
332        let signature = <MinPk as Variant>::Signature::decode(raw.as_ref())
333            .map_err(|e| CodecError::Wrapped(CURVE_NAME, e.into()))?;
334        Ok(Self { raw, signature })
335    }
336}
337
338impl FixedSize for Signature {
339    const SIZE: usize = <MinPk as Variant>::Signature::SIZE;
340}
341
342impl Span for Signature {}
343
344impl Array for Signature {}
345
346impl Hash for Signature {
347    fn hash<H: Hasher>(&self, state: &mut H) {
348        self.raw.hash(state);
349    }
350}
351
352impl Ord for Signature {
353    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
354        self.raw.cmp(&other.raw)
355    }
356}
357
358impl PartialOrd for Signature {
359    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
360        Some(self.cmp(other))
361    }
362}
363
364impl AsRef<[u8]> for Signature {
365    fn as_ref(&self) -> &[u8] {
366        &self.raw
367    }
368}
369
370impl Deref for Signature {
371    type Target = [u8];
372    fn deref(&self) -> &[u8] {
373        &self.raw
374    }
375}
376
377impl From<<MinPk as Variant>::Signature> for Signature {
378    fn from(signature: <MinPk as Variant>::Signature) -> Self {
379        let raw = signature.encode_fixed();
380        Self { raw, signature }
381    }
382}
383
384impl Debug for Signature {
385    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
386        write!(f, "{}", hex(&self.raw))
387    }
388}
389
390impl Display for Signature {
391    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
392        write!(f, "{}", hex(&self.raw))
393    }
394}
395
396#[cfg(feature = "arbitrary")]
397impl arbitrary::Arbitrary<'_> for Signature {
398    fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
399        use crate::Signer;
400        use rand::{rngs::StdRng, SeedableRng};
401
402        let mut rand = StdRng::from_seed(u.arbitrary::<[u8; 32]>()?);
403        let private_key = PrivateKey::random(&mut rand);
404        let len = u.arbitrary::<usize>()? % 256;
405        let message = u
406            .arbitrary_iter()?
407            .take(len)
408            .collect::<Result<Vec<_>, _>>()?;
409
410        Ok(private_key.sign(&[], &message))
411    }
412}
413
414/// BLS12-381 batch verifier.
415pub struct Batch {
416    publics: Vec<<MinPk as Variant>::Public>,
417    hms: Vec<<MinPk as Variant>::Signature>,
418    signatures: Vec<<MinPk as Variant>::Signature>,
419}
420
421impl Batch {
422    #[inline(always)]
423    fn add_inner(
424        &mut self,
425        namespace: Option<&[u8]>,
426        message: &[u8],
427        public_key: &PublicKey,
428        signature: &Signature,
429    ) -> bool {
430        self.publics.push(public_key.key);
431        let payload = namespace.map_or(Cow::Borrowed(message), |namespace| {
432            Cow::Owned(union_unique(namespace, message))
433        });
434        let hm = ops::hash_message::<MinPk>(MinPk::MESSAGE, &payload);
435        self.hms.push(hm);
436        self.signatures.push(signature.signature);
437        true
438    }
439}
440
441impl BatchVerifier<PublicKey> for Batch {
442    fn new() -> Self {
443        Self {
444            publics: Vec::new(),
445            hms: Vec::new(),
446            signatures: Vec::new(),
447        }
448    }
449
450    fn add(
451        &mut self,
452        namespace: &[u8],
453        message: &[u8],
454        public_key: &PublicKey,
455        signature: &Signature,
456    ) -> bool {
457        self.add_inner(Some(namespace), message, public_key, signature)
458    }
459
460    fn verify<R: CryptoRngCore>(self, rng: &mut R) -> bool {
461        MinPk::batch_verify(rng, &self.publics, &self.hms, &self.signatures).is_ok()
462    }
463}
464
465/// Test vectors sourced from https://github.com/ethereum/bls12-381-tests/releases/tag/v0.1.2.
466#[cfg(test)]
467mod tests {
468    use super::*;
469    use crate::bls12381;
470    use commonware_codec::{DecodeExt, Encode};
471    use rstest::rstest;
472
473    #[test]
474    fn test_codec_private_key() {
475        let original =
476            parse_private_key("0x263dbd792f5b1be47ed85f8938c0f29586af0d3ac7b977f21c278fe1462040e3")
477                .unwrap();
478        let encoded = original.encode();
479        assert_eq!(encoded.len(), bls12381::PrivateKey::SIZE);
480        let decoded = bls12381::PrivateKey::decode(encoded).unwrap();
481        assert_eq!(original, decoded);
482    }
483
484    #[test]
485    fn test_codec_public_key() {
486        let original =
487            parse_public_key("0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a")
488            .unwrap();
489        let encoded = original.encode();
490        assert_eq!(encoded.len(), PublicKey::SIZE);
491        let decoded = PublicKey::decode(encoded).unwrap();
492        assert_eq!(original, decoded);
493    }
494
495    #[test]
496    fn test_codec_signature() {
497        let original =
498            parse_signature("0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972503a43eb")
499            .unwrap();
500        let encoded = original.encode();
501        assert_eq!(encoded.len(), Signature::SIZE);
502        let decoded = Signature::decode(encoded).unwrap();
503        assert_eq!(original, decoded);
504    }
505
506    #[rstest]
507    #[case(vector_sign_1())]
508    #[case(vector_sign_2())]
509    #[case(vector_sign_3())]
510    #[case(vector_sign_4())]
511    #[case(vector_sign_5())]
512    #[case(vector_sign_6())]
513    #[case(vector_sign_7())]
514    #[case(vector_sign_8())]
515    #[case(vector_sign_9())]
516    fn test_sign(#[case] (private_key, message, expected): (PrivateKey, Vec<u8>, Signature)) {
517        let signature = private_key.sign_inner(None, &message);
518        assert_eq!(signature, expected);
519    }
520
521    #[test]
522    fn test_sign_10() {
523        let result =
524            parse_private_key("0x0000000000000000000000000000000000000000000000000000000000000000");
525        assert!(result.is_err());
526    }
527
528    #[rstest]
529    #[case(vector_verify_1())]
530    #[case(vector_verify_2())]
531    #[case(vector_verify_3())]
532    #[case(vector_verify_4())]
533    #[case(vector_verify_5())]
534    #[case(vector_verify_6())]
535    #[case(vector_verify_7())]
536    #[case(vector_verify_8())]
537    #[case(vector_verify_9())]
538    #[case(vector_verify_10())]
539    #[case(vector_verify_11())]
540    #[case(vector_verify_12())]
541    #[case(vector_verify_13())]
542    #[case(vector_verify_14())]
543    #[case(vector_verify_15())]
544    #[case(vector_verify_16())]
545    #[case(vector_verify_17())]
546    #[case(vector_verify_18())]
547    #[case(vector_verify_19())]
548    #[case(vector_verify_20())]
549    #[case(vector_verify_21())]
550    #[case(vector_verify_22())]
551    #[case(vector_verify_23())]
552    #[case(vector_verify_24())]
553    #[case(vector_verify_25())]
554    #[case(vector_verify_26())]
555    #[case(vector_verify_27())]
556    #[case(vector_verify_28())]
557    #[case(vector_verify_29())]
558    fn test_verify(
559        #[case] (public_key, message, signature, expected): (
560            Result<PublicKey, CodecError>,
561            Vec<u8>,
562            Result<Signature, CodecError>,
563            bool,
564        ),
565    ) {
566        let mut batch = Batch::new();
567        let expected = if !expected {
568            public_key.is_err()
569                || signature.is_err()
570                || !public_key
571                    .unwrap()
572                    .verify_inner(None, &message, &signature.unwrap())
573        } else {
574            let public_key = public_key.unwrap();
575            let signature = signature.unwrap();
576            batch.add_inner(None, &message, &public_key, &signature);
577            public_key.verify_inner(None, &message, &signature)
578        };
579        assert!(expected);
580    }
581
582    /// Parse `sign` vector from hex encoded data.
583    fn parse_sign_vector(
584        private_key: &str,
585        msg: &str,
586        signature: &str,
587    ) -> (PrivateKey, Vec<u8>, Signature) {
588        (
589            parse_private_key(private_key).unwrap(),
590            commonware_utils::from_hex_formatted(msg).unwrap(),
591            parse_signature(signature).unwrap(),
592        )
593    }
594
595    fn parse_private_key(private_key: &str) -> Result<PrivateKey, CodecError> {
596        PrivateKey::decode(
597            commonware_utils::from_hex_formatted(private_key)
598                .unwrap()
599                .as_ref(),
600        )
601    }
602    fn parse_public_key(public_key: &str) -> Result<PublicKey, CodecError> {
603        PublicKey::decode(
604            commonware_utils::from_hex_formatted(public_key)
605                .unwrap()
606                .as_ref(),
607        )
608    }
609    fn parse_signature(signature: &str) -> Result<Signature, CodecError> {
610        Signature::decode(
611            commonware_utils::from_hex_formatted(signature)
612                .unwrap()
613                .as_ref(),
614        )
615    }
616
617    // sign_case_8cd3d4d0d9a5b265
618    fn vector_sign_1() -> (PrivateKey, Vec<u8>, Signature) {
619        parse_sign_vector(
620            "0x263dbd792f5b1be47ed85f8938c0f29586af0d3ac7b977f21c278fe1462040e3",
621            "0x5656565656565656565656565656565656565656565656565656565656565656",
622            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972503a43eb"
623        )
624    }
625
626    // sign_case_11b8c7cad5238946
627    fn vector_sign_2() -> (PrivateKey, Vec<u8>, Signature) {
628        parse_sign_vector(
629            "0x47b8192d77bf871b62e87859d653922725724a5c031afeabc60bcef5ff665138",
630            "0x0000000000000000000000000000000000000000000000000000000000000000",
631            "0xb23c46be3a001c63ca711f87a005c200cc550b9429d5f4eb38d74322144f1b63926da3388979e5321012fb1a0526bcd100b5ef5fe72628ce4cd5e904aeaa3279527843fae5ca9ca675f4f51ed8f83bbf7155da9ecc9663100a885d5dc6df96d9"
632        )
633    }
634
635    // sign_case_84d45c9c7cca6b92
636    fn vector_sign_3() -> (PrivateKey, Vec<u8>, Signature) {
637        parse_sign_vector(
638            "0x328388aff0d4a5b7dc9205abd374e7e98f3cd9f3418edb4eafda5fb16473d216",
639            "0xabababababababababababababababababababababababababababababababab",
640            "0xae82747ddeefe4fd64cf9cedb9b04ae3e8a43420cd255e3c7cd06a8d88b7c7f8638543719981c5d16fa3527c468c25f0026704a6951bde891360c7e8d12ddee0559004ccdbe6046b55bae1b257ee97f7cdb955773d7cf29adf3ccbb9975e4eb9"
641        )
642    }
643
644    // sign_case_142f678a8d05fcd1
645    fn vector_sign_4() -> (PrivateKey, Vec<u8>, Signature) {
646        parse_sign_vector(
647            "0x47b8192d77bf871b62e87859d653922725724a5c031afeabc60bcef5ff665138",
648            "0x5656565656565656565656565656565656565656565656565656565656565656",
649            "0xaf1390c3c47acdb37131a51216da683c509fce0e954328a59f93aebda7e4ff974ba208d9a4a2a2389f892a9d418d618418dd7f7a6bc7aa0da999a9d3a5b815bc085e14fd001f6a1948768a3f4afefc8b8240dda329f984cb345c6363272ba4fe"
650        )
651    }
652
653    // sign_case_37286e1a6d1f6eb3
654    fn vector_sign_5() -> (PrivateKey, Vec<u8>, Signature) {
655        parse_sign_vector(
656            "0x47b8192d77bf871b62e87859d653922725724a5c031afeabc60bcef5ff665138",
657            "0xabababababababababababababababababababababababababababababababab",
658            "0x9674e2228034527f4c083206032b020310face156d4a4685e2fcaec2f6f3665aa635d90347b6ce124eb879266b1e801d185de36a0a289b85e9039662634f2eea1e02e670bc7ab849d006a70b2f93b84597558a05b879c8d445f387a5d5b653df"
659        )
660    }
661
662    // sign_case_7055381f640f2c1d
663    fn vector_sign_6() -> (PrivateKey, Vec<u8>, Signature) {
664        parse_sign_vector(
665            "0x328388aff0d4a5b7dc9205abd374e7e98f3cd9f3418edb4eafda5fb16473d216",
666            "0x0000000000000000000000000000000000000000000000000000000000000000",
667            "0x948a7cb99f76d616c2c564ce9bf4a519f1bea6b0a624a02276443c245854219fabb8d4ce061d255af5330b078d5380681751aa7053da2c98bae898edc218c75f07e24d8802a17cd1f6833b71e58f5eb5b94208b4d0bb3848cecb075ea21be115"
668        )
669    }
670
671    // sign_case_c82df61aa3ee60fb
672    fn vector_sign_7() -> (PrivateKey, Vec<u8>, Signature) {
673        parse_sign_vector(
674            "0x263dbd792f5b1be47ed85f8938c0f29586af0d3ac7b977f21c278fe1462040e3",
675            "0x0000000000000000000000000000000000000000000000000000000000000000",
676            "0xb6ed936746e01f8ecf281f020953fbf1f01debd5657c4a383940b020b26507f6076334f91e2366c96e9ab279fb5158090352ea1c5b0c9274504f4f0e7053af24802e51e4568d164fe986834f41e55c8e850ce1f98458c0cfc9ab380b55285a55"
677        )
678    }
679
680    // sign_case_d0e28d7e76eb6e9c
681    fn vector_sign_8() -> (PrivateKey, Vec<u8>, Signature) {
682        parse_sign_vector(
683            "0x263dbd792f5b1be47ed85f8938c0f29586af0d3ac7b977f21c278fe1462040e3",
684            "0x5656565656565656565656565656565656565656565656565656565656565656",
685            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972503a43eb"
686        )
687    }
688
689    // sign_case_f2ae1097e7d0e18b
690    fn vector_sign_9() -> (PrivateKey, Vec<u8>, Signature) {
691        parse_sign_vector(
692            "0x263dbd792f5b1be47ed85f8938c0f29586af0d3ac7b977f21c278fe1462040e3",
693            "0xabababababababababababababababababababababababababababababababab",
694            "0x91347bccf740d859038fcdcaf233eeceb2a436bcaaee9b2aa3bfb70efe29dfb2677562ccbea1c8e061fb9971b0753c240622fab78489ce96768259fc01360346da5b9f579e5da0d941e4c6ba18a0e64906082375394f337fa1af2b7127b0d121"
695        )
696    }
697
698    /// Parse `verify` vector from hex encoded data.
699    fn parse_verify_vector(
700        public_key: &str,
701        msg: &str,
702        signature: &str,
703    ) -> (
704        Result<PublicKey, CodecError>,
705        Vec<u8>,
706        Result<Signature, CodecError>,
707    ) {
708        (
709            parse_public_key(public_key),
710            commonware_utils::from_hex_formatted(msg).unwrap(),
711            parse_signature(signature),
712        )
713    }
714
715    // verify_infinity_pubkey_and_infinity_signature
716    fn vector_verify_1() -> (
717        Result<PublicKey, CodecError>,
718        Vec<u8>,
719        Result<Signature, CodecError>,
720        bool,
721    ) {
722        let v = parse_verify_vector(
723                "0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
724                "0x1212121212121212121212121212121212121212121212121212121212121212",
725                "0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
726            );
727        (v.0, v.1, v.2, false)
728    }
729
730    // verify_tampered_signature_case_2ea479adf8c40300
731    fn vector_verify_2() -> (
732        Result<PublicKey, CodecError>,
733        Vec<u8>,
734        Result<Signature, CodecError>,
735        bool,
736    ) {
737        let v = parse_verify_vector(
738            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
739            "0x5656565656565656565656565656565656565656565656565656565656565656",
740            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972ffffffff",
741        );
742        (v.0, v.1, v.2, false)
743    }
744
745    // verify_tampered_signature_case_2f09d443ab8a3ac2
746    fn vector_verify_3() -> (
747        Result<PublicKey, CodecError>,
748        Vec<u8>,
749        Result<Signature, CodecError>,
750        bool,
751    ) {
752        let v = parse_verify_vector(
753            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
754            "0x0000000000000000000000000000000000000000000000000000000000000000",
755            "0xb23c46be3a001c63ca711f87a005c200cc550b9429d5f4eb38d74322144f1b63926da3388979e5321012fb1a0526bcd100b5ef5fe72628ce4cd5e904aeaa3279527843fae5ca9ca675f4f51ed8f83bbf7155da9ecc9663100a885d5dffffffff",
756        );
757        (v.0, v.1, v.2, false)
758    }
759
760    // verify_tampered_signature_case_6b3b17f6962a490c
761    fn vector_verify_4() -> (
762        Result<PublicKey, CodecError>,
763        Vec<u8>,
764        Result<Signature, CodecError>,
765        bool,
766    ) {
767        let v = parse_verify_vector(
768            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
769            "0x5656565656565656565656565656565656565656565656565656565656565656",
770            "0xa4efa926610b8bd1c8330c918b7a5e9bf374e53435ef8b7ec186abf62e1b1f65aeaaeb365677ac1d1172a1f5b44b4e6d022c252c58486c0a759fbdc7de15a756acc4d343064035667a594b4c2a6f0b0b421975977f297dba63ee2f63ffffffff",
771        );
772        (v.0, v.1, v.2, false)
773    }
774
775    // verify_tampered_signature_case_6eeb7c52dfd9baf0
776    fn vector_verify_5() -> (
777        Result<PublicKey, CodecError>,
778        Vec<u8>,
779        Result<Signature, CodecError>,
780        bool,
781    ) {
782        let v = parse_verify_vector(
783            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
784            "0xabababababababababababababababababababababababababababababababab",
785            "0x9674e2228034527f4c083206032b020310face156d4a4685e2fcaec2f6f3665aa635d90347b6ce124eb879266b1e801d185de36a0a289b85e9039662634f2eea1e02e670bc7ab849d006a70b2f93b84597558a05b879c8d445f387a5ffffffff",
786        );
787        (v.0, v.1, v.2, false)
788    }
789
790    // verify_tampered_signature_case_8761a0b7e920c323
791    fn vector_verify_6() -> (
792        Result<PublicKey, CodecError>,
793        Vec<u8>,
794        Result<Signature, CodecError>,
795        bool,
796    ) {
797        let v = parse_verify_vector(
798            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
799            "0xabababababababababababababababababababababababababababababababab",
800            "0x91347bccf740d859038fcdcaf233eeceb2a436bcaaee9b2aa3bfb70efe29dfb2677562ccbea1c8e061fb9971b0753c240622fab78489ce96768259fc01360346da5b9f579e5da0d941e4c6ba18a0e64906082375394f337fa1af2b71ffffffff",
801        );
802        (v.0, v.1, v.2, false)
803    }
804
805    // verify_tampered_signature_case_195246ee3bd3b6ec
806    fn vector_verify_7() -> (
807        Result<PublicKey, CodecError>,
808        Vec<u8>,
809        Result<Signature, CodecError>,
810        bool,
811    ) {
812        let v = parse_verify_vector(
813            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
814            "0xabababababababababababababababababababababababababababababababab",
815            "0xae82747ddeefe4fd64cf9cedb9b04ae3e8a43420cd255e3c7cd06a8d88b7c7f8638543719981c5d16fa3527c468c25f0026704a6951bde891360c7e8d12ddee0559004ccdbe6046b55bae1b257ee97f7cdb955773d7cf29adf3ccbb9ffffffff",
816        );
817        (v.0, v.1, v.2, false)
818    }
819
820    // verify_tampered_signature_case_3208262581c8fc09
821    fn vector_verify_8() -> (
822        Result<PublicKey, CodecError>,
823        Vec<u8>,
824        Result<Signature, CodecError>,
825        bool,
826    ) {
827        let v = parse_verify_vector(
828            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
829            "0x5656565656565656565656565656565656565656565656565656565656565656",
830            "0xaf1390c3c47acdb37131a51216da683c509fce0e954328a59f93aebda7e4ff974ba208d9a4a2a2389f892a9d418d618418dd7f7a6bc7aa0da999a9d3a5b815bc085e14fd001f6a1948768a3f4afefc8b8240dda329f984cb345c6363ffffffff",
831        );
832        (v.0, v.1, v.2, false)
833    }
834
835    // verify_tampered_signature_case_d34885d766d5f705
836    fn vector_verify_9() -> (
837        Result<PublicKey, CodecError>,
838        Vec<u8>,
839        Result<Signature, CodecError>,
840        bool,
841    ) {
842        let v = parse_verify_vector(
843            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
844            "0x0000000000000000000000000000000000000000000000000000000000000000",
845            "0x948a7cb99f76d616c2c564ce9bf4a519f1bea6b0a624a02276443c245854219fabb8d4ce061d255af5330b078d5380681751aa7053da2c98bae898edc218c75f07e24d8802a17cd1f6833b71e58f5eb5b94208b4d0bb3848cecb075effffffff",
846        );
847        (v.0, v.1, v.2, false)
848    }
849
850    // verify_tampered_signature_case_e8a50c445c855360
851    fn vector_verify_10() -> (
852        Result<PublicKey, CodecError>,
853        Vec<u8>,
854        Result<Signature, CodecError>,
855        bool,
856    ) {
857        let v= parse_verify_vector(
858            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
859            "0x0000000000000000000000000000000000000000000000000000000000000000",
860            "0xb6ed936746e01f8ecf281f020953fbf1f01debd5657c4a383940b020b26507f6076334f91e2366c96e9ab279fb5158090352ea1c5b0c9274504f4f0e7053af24802e51e4568d164fe986834f41e55c8e850ce1f98458c0cfc9ab380bffffffff",
861        );
862        (v.0, v.1, v.2, false)
863    }
864
865    // verify_valid_case_2ea479adf8c40300
866    fn vector_verify_11() -> (
867        Result<PublicKey, CodecError>,
868        Vec<u8>,
869        Result<Signature, CodecError>,
870        bool,
871    ) {
872        let v= parse_verify_vector(
873            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
874            "0x5656565656565656565656565656565656565656565656565656565656565656",
875            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972503a43eb",
876        );
877        (v.0, v.1, v.2, true)
878    }
879
880    // verify_valid_case_2f09d443ab8a3ac2
881    fn vector_verify_12() -> (
882        Result<PublicKey, CodecError>,
883        Vec<u8>,
884        Result<Signature, CodecError>,
885        bool,
886    ) {
887        let v = parse_verify_vector(
888            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
889            "0x0000000000000000000000000000000000000000000000000000000000000000",
890            "0xb23c46be3a001c63ca711f87a005c200cc550b9429d5f4eb38d74322144f1b63926da3388979e5321012fb1a0526bcd100b5ef5fe72628ce4cd5e904aeaa3279527843fae5ca9ca675f4f51ed8f83bbf7155da9ecc9663100a885d5dc6df96d9",
891        );
892        (v.0, v.1, v.2, true)
893    }
894
895    // verify_valid_case_6b3b17f6962a490c
896    fn vector_verify_13() -> (
897        Result<PublicKey, CodecError>,
898        Vec<u8>,
899        Result<Signature, CodecError>,
900        bool,
901    ) {
902        let v = parse_verify_vector(
903            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
904            "0x5656565656565656565656565656565656565656565656565656565656565656",
905            "0xa4efa926610b8bd1c8330c918b7a5e9bf374e53435ef8b7ec186abf62e1b1f65aeaaeb365677ac1d1172a1f5b44b4e6d022c252c58486c0a759fbdc7de15a756acc4d343064035667a594b4c2a6f0b0b421975977f297dba63ee2f63ffe47bb6",
906        );
907        (v.0, v.1, v.2, true)
908    }
909
910    // verify_valid_case_6eeb7c52dfd9baf0
911    fn vector_verify_14() -> (
912        Result<PublicKey, CodecError>,
913        Vec<u8>,
914        Result<Signature, CodecError>,
915        bool,
916    ) {
917        let v = parse_verify_vector(
918            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
919            "0xabababababababababababababababababababababababababababababababab",
920            "0x9674e2228034527f4c083206032b020310face156d4a4685e2fcaec2f6f3665aa635d90347b6ce124eb879266b1e801d185de36a0a289b85e9039662634f2eea1e02e670bc7ab849d006a70b2f93b84597558a05b879c8d445f387a5d5b653df",
921        );
922        (v.0, v.1, v.2, true)
923    }
924
925    // verify_valid_case_8761a0b7e920c323
926    fn vector_verify_15() -> (
927        Result<PublicKey, CodecError>,
928        Vec<u8>,
929        Result<Signature, CodecError>,
930        bool,
931    ) {
932        let v = parse_verify_vector(
933            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
934            "0xabababababababababababababababababababababababababababababababab",
935            "0x91347bccf740d859038fcdcaf233eeceb2a436bcaaee9b2aa3bfb70efe29dfb2677562ccbea1c8e061fb9971b0753c240622fab78489ce96768259fc01360346da5b9f579e5da0d941e4c6ba18a0e64906082375394f337fa1af2b7127b0d121",
936        );
937        (v.0, v.1, v.2, true)
938    }
939
940    // verify_valid_case_195246ee3bd3b6ec
941    fn vector_verify_16() -> (
942        Result<PublicKey, CodecError>,
943        Vec<u8>,
944        Result<Signature, CodecError>,
945        bool,
946    ) {
947        let v = parse_verify_vector(
948            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
949            "0xabababababababababababababababababababababababababababababababab",
950            "0xae82747ddeefe4fd64cf9cedb9b04ae3e8a43420cd255e3c7cd06a8d88b7c7f8638543719981c5d16fa3527c468c25f0026704a6951bde891360c7e8d12ddee0559004ccdbe6046b55bae1b257ee97f7cdb955773d7cf29adf3ccbb9975e4eb9",
951        );
952        (v.0, v.1, v.2, true)
953    }
954
955    // verify_valid_case_3208262581c8fc09
956    fn vector_verify_17() -> (
957        Result<PublicKey, CodecError>,
958        Vec<u8>,
959        Result<Signature, CodecError>,
960        bool,
961    ) {
962        let v = parse_verify_vector(
963            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
964            "0x5656565656565656565656565656565656565656565656565656565656565656",
965            "0xaf1390c3c47acdb37131a51216da683c509fce0e954328a59f93aebda7e4ff974ba208d9a4a2a2389f892a9d418d618418dd7f7a6bc7aa0da999a9d3a5b815bc085e14fd001f6a1948768a3f4afefc8b8240dda329f984cb345c6363272ba4fe",
966        );
967        (v.0, v.1, v.2, true)
968    }
969
970    // verify_valid_case_d34885d766d5f705
971    fn vector_verify_18() -> (
972        Result<PublicKey, CodecError>,
973        Vec<u8>,
974        Result<Signature, CodecError>,
975        bool,
976    ) {
977        let v = parse_verify_vector(
978            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
979            "0x0000000000000000000000000000000000000000000000000000000000000000",
980            "0x948a7cb99f76d616c2c564ce9bf4a519f1bea6b0a624a02276443c245854219fabb8d4ce061d255af5330b078d5380681751aa7053da2c98bae898edc218c75f07e24d8802a17cd1f6833b71e58f5eb5b94208b4d0bb3848cecb075ea21be115",
981        );
982        (v.0, v.1, v.2, true)
983    }
984
985    // verify_valid_case_e8a50c445c855360
986    fn vector_verify_19() -> (
987        Result<PublicKey, CodecError>,
988        Vec<u8>,
989        Result<Signature, CodecError>,
990        bool,
991    ) {
992        let v = parse_verify_vector(
993            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
994            "0x0000000000000000000000000000000000000000000000000000000000000000",
995            "0xb6ed936746e01f8ecf281f020953fbf1f01debd5657c4a383940b020b26507f6076334f91e2366c96e9ab279fb5158090352ea1c5b0c9274504f4f0e7053af24802e51e4568d164fe986834f41e55c8e850ce1f98458c0cfc9ab380b55285a55",
996        );
997        (v.0, v.1, v.2, true)
998    }
999
1000    // verify_wrong_pubkey_case_2ea479adf8c40300
1001    fn vector_verify_20() -> (
1002        Result<PublicKey, CodecError>,
1003        Vec<u8>,
1004        Result<Signature, CodecError>,
1005        bool,
1006    ) {
1007        let v = parse_verify_vector(
1008            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
1009            "0x5656565656565656565656565656565656565656565656565656565656565656",
1010            "0xa4efa926610b8bd1c8330c918b7a5e9bf374e53435ef8b7ec186abf62e1b1f65aeaaeb365677ac1d1172a1f5b44b4e6d022c252c58486c0a759fbdc7de15a756acc4d343064035667a594b4c2a6f0b0b421975977f297dba63ee2f63ffe47bb6",
1011        );
1012        (v.0, v.1, v.2, false)
1013    }
1014
1015    // verify_wrong_pubkey_case_2f09d443ab8a3ac2
1016    fn vector_verify_21() -> (
1017        Result<PublicKey, CodecError>,
1018        Vec<u8>,
1019        Result<Signature, CodecError>,
1020        bool,
1021    ) {
1022        let v = parse_verify_vector(
1023            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
1024            "0x0000000000000000000000000000000000000000000000000000000000000000",
1025            "0xb6ed936746e01f8ecf281f020953fbf1f01debd5657c4a383940b020b26507f6076334f91e2366c96e9ab279fb5158090352ea1c5b0c9274504f4f0e7053af24802e51e4568d164fe986834f41e55c8e850ce1f98458c0cfc9ab380b55285a55",
1026        );
1027        (v.0, v.1, v.2, false)
1028    }
1029
1030    // verify_wrong_pubkey_case_6b3b17f6962a490c
1031    fn vector_verify_22() -> (
1032        Result<PublicKey, CodecError>,
1033        Vec<u8>,
1034        Result<Signature, CodecError>,
1035        bool,
1036    ) {
1037        let v = parse_verify_vector(
1038            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
1039            "0x5656565656565656565656565656565656565656565656565656565656565656",
1040            "0xaf1390c3c47acdb37131a51216da683c509fce0e954328a59f93aebda7e4ff974ba208d9a4a2a2389f892a9d418d618418dd7f7a6bc7aa0da999a9d3a5b815bc085e14fd001f6a1948768a3f4afefc8b8240dda329f984cb345c6363272ba4fe",
1041        );
1042        (v.0, v.1, v.2, false)
1043    }
1044
1045    // verify_wrong_pubkey_case_6eeb7c52dfd9baf0
1046    fn vector_verify_23() -> (
1047        Result<PublicKey, CodecError>,
1048        Vec<u8>,
1049        Result<Signature, CodecError>,
1050        bool,
1051    ) {
1052        let v = parse_verify_vector(
1053            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
1054            "0xabababababababababababababababababababababababababababababababab",
1055            "0x91347bccf740d859038fcdcaf233eeceb2a436bcaaee9b2aa3bfb70efe29dfb2677562ccbea1c8e061fb9971b0753c240622fab78489ce96768259fc01360346da5b9f579e5da0d941e4c6ba18a0e64906082375394f337fa1af2b7127b0d121",
1056        );
1057        (v.0, v.1, v.2, false)
1058    }
1059
1060    // verify_wrong_pubkey_case_8761a0b7e920c323
1061    fn vector_verify_24() -> (
1062        Result<PublicKey, CodecError>,
1063        Vec<u8>,
1064        Result<Signature, CodecError>,
1065        bool,
1066    ) {
1067        let v = parse_verify_vector(
1068            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
1069            "0xabababababababababababababababababababababababababababababababab",
1070            "0xae82747ddeefe4fd64cf9cedb9b04ae3e8a43420cd255e3c7cd06a8d88b7c7f8638543719981c5d16fa3527c468c25f0026704a6951bde891360c7e8d12ddee0559004ccdbe6046b55bae1b257ee97f7cdb955773d7cf29adf3ccbb9975e4eb9",
1071        );
1072        (v.0, v.1, v.2, false)
1073    }
1074
1075    // verify_wrong_pubkey_case_195246ee3bd3b6ec
1076    fn vector_verify_25() -> (
1077        Result<PublicKey, CodecError>,
1078        Vec<u8>,
1079        Result<Signature, CodecError>,
1080        bool,
1081    ) {
1082        let v = parse_verify_vector(
1083            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
1084            "0xabababababababababababababababababababababababababababababababab",
1085            "0x9674e2228034527f4c083206032b020310face156d4a4685e2fcaec2f6f3665aa635d90347b6ce124eb879266b1e801d185de36a0a289b85e9039662634f2eea1e02e670bc7ab849d006a70b2f93b84597558a05b879c8d445f387a5d5b653df",
1086        );
1087        (v.0, v.1, v.2, false)
1088    }
1089
1090    // verify_wrong_pubkey_case_3208262581c8fc09
1091    fn vector_verify_26() -> (
1092        Result<PublicKey, CodecError>,
1093        Vec<u8>,
1094        Result<Signature, CodecError>,
1095        bool,
1096    ) {
1097        let v = parse_verify_vector(
1098            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
1099            "0x5656565656565656565656565656565656565656565656565656565656565656",
1100            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972503a43eb",
1101        );
1102        (v.0, v.1, v.2, false)
1103    }
1104
1105    // verify_wrong_pubkey_case_d34885d766d5f705
1106    fn vector_verify_27() -> (
1107        Result<PublicKey, CodecError>,
1108        Vec<u8>,
1109        Result<Signature, CodecError>,
1110        bool,
1111    ) {
1112        let v = parse_verify_vector(
1113            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
1114            "0x0000000000000000000000000000000000000000000000000000000000000000",
1115            "0xb23c46be3a001c63ca711f87a005c200cc550b9429d5f4eb38d74322144f1b63926da3388979e5321012fb1a0526bcd100b5ef5fe72628ce4cd5e904aeaa3279527843fae5ca9ca675f4f51ed8f83bbf7155da9ecc9663100a885d5dc6df96d9",
1116        );
1117        (v.0, v.1, v.2, false)
1118    }
1119
1120    // verify_wrong_pubkey_case_e8a50c445c855360
1121    fn vector_verify_28() -> (
1122        Result<PublicKey, CodecError>,
1123        Vec<u8>,
1124        Result<Signature, CodecError>,
1125        bool,
1126    ) {
1127        let v = parse_verify_vector(
1128            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
1129            "0x0000000000000000000000000000000000000000000000000000000000000000",
1130            "0x948a7cb99f76d616c2c564ce9bf4a519f1bea6b0a624a02276443c245854219fabb8d4ce061d255af5330b078d5380681751aa7053da2c98bae898edc218c75f07e24d8802a17cd1f6833b71e58f5eb5b94208b4d0bb3848cecb075ea21be115",
1131        );
1132        (v.0, v.1, v.2, false)
1133    }
1134
1135    // verifycase_one_privkey_47117849458281be
1136    fn vector_verify_29() -> (
1137        Result<PublicKey, CodecError>,
1138        Vec<u8>,
1139        Result<Signature, CodecError>,
1140        bool,
1141    ) {
1142        let v= parse_verify_vector(
1143            "0x97f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb",
1144            "0x1212121212121212121212121212121212121212121212121212121212121212",
1145            "0xa42ae16f1c2a5fa69c04cb5998d2add790764ce8dd45bf25b29b4700829232052b52352dcff1cf255b3a7810ad7269601810f03b2bc8b68cf289cf295b206770605a190b6842583e47c3d1c0f73c54907bfb2a602157d46a4353a20283018763",
1146        );
1147        (v.0, v.1, v.2, true)
1148    }
1149
1150    #[cfg(feature = "arbitrary")]
1151    mod conformance {
1152        use super::*;
1153        use commonware_codec::conformance::CodecConformance;
1154
1155        commonware_conformance::conformance_tests! {
1156            CodecConformance<PublicKey>,
1157            CodecConformance<PrivateKey>,
1158            CodecConformance<Signature>,
1159        }
1160    }
1161}
commonware_cryptography/bls12381/scheme.rs

commonware_cryptography/bls12381/
scheme.rs
