commonware_cryptography/bls12381/
scheme.rs

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

commonware_cryptography/bls12381/
scheme.rs
