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

commonware_cryptography/bls12381/
scheme.rs
