commonware_cryptography/bls12381/
scheme.rs

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

commonware_cryptography/bls12381/
scheme.rs
