commonware_cryptography/bls12381/
scheme.rs

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

commonware_cryptography/bls12381/
scheme.rs
