commonware_cryptography/bls12381/
scheme.rs

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

commonware_cryptography/bls12381/
scheme.rs
