blsful 3.1.0

BLS signature implementation according to the IETF spec on the BLS12-381 curve.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::impls::inner_types::*;
use crate::traits::Pairing;
use serde::{Deserializer, Serializer};

/// Serialization trait for inner types
pub trait BlsSerde: Pairing {
    /// Serialize a scalar
    fn serialize_scalar<S: Serializer>(
        scalar: &<Self::PublicKey as Group>::Scalar,
        serializer: S,
    ) -> Result<S::Ok, S::Error>;
    /// Serialize a scalar share
    fn serialize_scalar_share<S: Serializer>(
        share: &Self::SecretKeyShare,
        serializer: S,
    ) -> Result<S::Ok, S::Error>;
    /// Serialize a signature
    fn serialize_signature<S: Serializer>(
        signature: &Self::Signature,
        serializer: S,
    ) -> Result<S::Ok, S::Error>;
    /// Serialize a public key
    fn serialize_public_key<S: Serializer>(
        public_key: &Self::PublicKey,
        serializer: S,
    ) -> Result<S::Ok, S::Error>;
    /// Serialize a public key share
    fn serialize_public_key_share<S: Serializer>(
        public_key_share: &Self::PublicKeyShare,
        serializer: S,
    ) -> Result<S::Ok, S::Error>;

    /// Deserialize a scalar
    fn deserialize_scalar<'de, D: Deserializer<'de>>(
        deserializer: D,
    ) -> Result<<Self::PublicKey as Group>::Scalar, D::Error>;
    /// Deserialize a scalar share
    fn deserialize_scalar_share<'de, D: Deserializer<'de>>(
        deserializer: D,
    ) -> Result<Self::SecretKeyShare, D::Error>;
    /// Deserialize a signature
    fn deserialize_signature<'de, D: Deserializer<'de>>(
        deserializer: D,
    ) -> Result<Self::Signature, D::Error>;
    /// Deserialize a public key
    fn deserialize_public_key<'de, D: Deserializer<'de>>(
        deserializer: D,
    ) -> Result<Self::PublicKey, D::Error>;
    /// Deserialize a public key share
    fn deserialize_public_key_share<'de, D: Deserializer<'de>>(
        deserializer: D,
    ) -> Result<Self::PublicKeyShare, D::Error>;
}

pub(crate) mod secret_key_share {
    use super::*;

    pub fn serialize<B: BlsSerde, S: Serializer>(
        sks: &B::SecretKeyShare,
        s: S,
    ) -> Result<S::Ok, S::Error> {
        B::serialize_scalar_share(sks, s)
    }

    pub fn deserialize<'de, B: BlsSerde, D: Deserializer<'de>>(
        d: D,
    ) -> Result<B::SecretKeyShare, D::Error> {
        B::deserialize_scalar_share(d)
    }
}

pub(crate) mod public_key_share {
    use super::*;

    pub fn serialize<B: BlsSerde, S: Serializer>(
        pks: &B::PublicKeyShare,
        s: S,
    ) -> Result<S::Ok, S::Error> {
        B::serialize_public_key_share(pks, s)
    }

    pub fn deserialize<'de, B: BlsSerde, D: Deserializer<'de>>(
        d: D,
    ) -> Result<B::PublicKeyShare, D::Error> {
        B::deserialize_public_key_share(d)
    }
}

pub(crate) mod public_key {
    use super::*;

    pub fn serialize<B: BlsSerde, S: Serializer>(
        pk: &B::PublicKey,
        s: S,
    ) -> Result<S::Ok, S::Error> {
        B::serialize_public_key(pk, s)
    }

    pub fn deserialize<'de, B: BlsSerde, D: Deserializer<'de>>(
        d: D,
    ) -> Result<B::PublicKey, D::Error> {
        B::deserialize_public_key(d)
    }
}

pub(crate) mod signature {
    use super::*;

    pub fn serialize<B: BlsSerde, S: Serializer>(
        sig: &B::Signature,
        s: S,
    ) -> Result<S::Ok, S::Error> {
        B::serialize_signature(sig, s)
    }

    pub fn deserialize<'de, B: BlsSerde, D: Deserializer<'de>>(
        d: D,
    ) -> Result<B::Signature, D::Error> {
        B::deserialize_signature(d)
    }
}

pub(crate) mod scalar {
    use super::*;

    pub fn serialize<B: BlsSerde, S: Serializer>(
        sig: &<B::PublicKey as Group>::Scalar,
        s: S,
    ) -> Result<S::Ok, S::Error> {
        B::serialize_scalar(sig, s)
    }

    pub fn deserialize<'de, B: BlsSerde, D: Deserializer<'de>>(
        d: D,
    ) -> Result<<B::PublicKey as Group>::Scalar, D::Error> {
        B::deserialize_scalar(d)
    }
}