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

commonware_cryptography/bls12381/
scheme.rs
