Support multiple BLS implementations (#1335)

## Issue Addressed

NA

## Proposed Changes

- Refactor the `bls` crate to support multiple BLS "backends" (e.g., milagro, blst, etc).
- Removes some duplicate, unused code in `common/rest_types/src/validator.rs`.
- Removes the old "upgrade legacy keypairs" functionality (these were unencrypted keys that haven't been supported for a few testnets, no one should be using them anymore).

## Additional Info

Most of the files changed are just inconsequential changes to function names.

## TODO

- [x] Optimization levels
- [x] Infinity point: https://github.com/supranational/blst/issues/11
- [x] Ensure milagro *and* blst are tested via CI
- [x] What to do with unsafe code?
- [x] Test infinity point in signature sets

crypto/bls/src/impls/blst.rs

@@ -0,0 +1,273 @@
+use crate::{
+    generic_aggregate_public_key::TAggregatePublicKey,
+    generic_aggregate_signature::TAggregateSignature,
+    generic_public_key::{GenericPublicKey, TPublicKey, PUBLIC_KEY_BYTES_LEN},
+    generic_secret_key::TSecretKey,
+    generic_signature::{TSignature, SIGNATURE_BYTES_LEN},
+    Error, Hash256, ZeroizeHash, INFINITY_PUBLIC_KEY, INFINITY_SIGNATURE,
+};
+pub use blst::min_pk as blst_core;
+use blst::{blst_scalar, BLST_ERROR};
+use rand::Rng;
+use std::iter::ExactSizeIterator;
+
+pub const DST: &[u8] = b"BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_";
+pub const RAND_BITS: usize = 64;
+
+/// Provides the externally-facing, core BLS types.
+pub mod types {
+    pub use super::blst_core::PublicKey;
+    pub use super::blst_core::SecretKey;
+    pub use super::blst_core::Signature;
+    pub use super::verify_signature_sets;
+    pub use super::BlstAggregatePublicKey as AggregatePublicKey;
+    pub use super::BlstAggregateSignature as AggregateSignature;
+    pub use super::SignatureSet;
+}
+
+pub type SignatureSet<'a> = crate::generic_signature_set::GenericSignatureSet<
+    'a,
+    blst_core::PublicKey,
+    BlstAggregatePublicKey,
+    blst_core::Signature,
+    BlstAggregateSignature,
+>;
+
+pub fn verify_signature_sets<'a>(
+    signature_sets: impl ExactSizeIterator<Item = &'a SignatureSet<'a>>,
+) -> bool {
+    let sets = signature_sets.collect::<Vec<_>>();
+
+    if sets.is_empty() {
+        return false;
+    }
+
+    let rng = &mut rand::thread_rng();
+
+    let mut rands: Vec<blst_scalar> = Vec::with_capacity(sets.len());
+    let mut msgs_refs = Vec::with_capacity(sets.len());
+    let mut sigs = Vec::with_capacity(sets.len());
+    let mut pks = Vec::with_capacity(sets.len());
+
+    for set in &sets {
+        // If this set is simply an infinity signature and infinity pubkey then skip verification.
+        // This has the effect of always declaring that this sig/pubkey combination is valid.
+        if set.signature.is_infinity
+            && set.signing_keys.len() == 1
+            && set.signing_keys.first().map_or(false, |pk| pk.is_infinity)
+        {
+            continue;
+        }
+
+        // Generate random scalars.
+        let mut vals = [0u64; 4];
+        vals[0] = rng.gen();
+        let mut rand_i = std::mem::MaybeUninit::<blst_scalar>::uninit();
+
+        // TODO: remove this `unsafe` code-block once we get a safe option from `blst`.
+        //
+        // See https://github.com/supranational/blst/issues/13
+        unsafe {
+            blst::blst_scalar_from_uint64(rand_i.as_mut_ptr(), vals.as_ptr());
+            rands.push(rand_i.assume_init());
+        }
+
+        // Grab a slice of the message, to satisfy the blst API.
+        msgs_refs.push(set.message.as_bytes());
+
+        // Convert the aggregate signature into a signature.
+        if let Some(point) = set.signature.point() {
+            sigs.push(point.0.to_signature())
+        } else {
+            // Any "empty" signature should cause a signature failure.
+            return false;
+        }
+
+        // Sanity check.
+        if set.signing_keys.is_empty() {
+            // A signature that has no signing keys is invalid.
+            return false;
+        }
+
+        // Collect all the public keys into a point, to satisfy the blst API.
+        //
+        // Note: we could potentially have the `SignatureSet` take a pubkey point instead of a
+        // `GenericPublicKey` and avoid this allocation.
+        let signing_keys = set
+            .signing_keys
+            .iter()
+            .map(|pk| pk.point())
+            .collect::<Vec<_>>();
+
+        // Aggregate all the public keys.
+        pks.push(blst_core::AggregatePublicKey::aggregate(&signing_keys).to_public_key());
+    }
+
+    // Due to an earlier check, the only case this can be empty is if all the sets consisted of
+    // infinity pubkeys/sigs. In such a case we wish to return `true`.
+    if msgs_refs.is_empty() {
+        return true;
+    }
+
+    let (sig_refs, pks_refs): (Vec<_>, Vec<_>) = sigs.iter().zip(pks.iter()).unzip();
+
+    let err = blst_core::Signature::verify_multiple_aggregate_signatures(
+        &msgs_refs, DST, &pks_refs, &sig_refs, &rands, RAND_BITS,
+    );
+
+    err == blst::BLST_ERROR::BLST_SUCCESS
+}
+
+impl TPublicKey for blst_core::PublicKey {
+    fn serialize(&self) -> [u8; PUBLIC_KEY_BYTES_LEN] {
+        self.compress()
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        Self::uncompress(&bytes).map_err(Into::into)
+    }
+}
+
+/// A wrapper that allows for `PartialEq` and `Clone` impls.
+pub struct BlstAggregatePublicKey(blst_core::AggregatePublicKey);
+
+impl Clone for BlstAggregatePublicKey {
+    fn clone(&self) -> Self {
+        Self(blst_core::AggregatePublicKey::from_public_key(
+            &self.0.to_public_key(),
+        ))
+    }
+}
+
+impl PartialEq for BlstAggregatePublicKey {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.to_public_key() == other.0.to_public_key()
+    }
+}
+
+impl TAggregatePublicKey for BlstAggregatePublicKey {
+    fn infinity() -> Self {
+        blst_core::PublicKey::from_bytes(&INFINITY_PUBLIC_KEY)
+            .map(|pk| blst_core::AggregatePublicKey::from_public_key(&pk))
+            .map(Self)
+            .expect("should decode infinity public key")
+    }
+
+    fn serialize(&self) -> [u8; PUBLIC_KEY_BYTES_LEN] {
+        self.0.to_public_key().compress()
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        blst_core::PublicKey::from_bytes(&bytes)
+            .map_err(Into::into)
+            .map(|pk| blst_core::AggregatePublicKey::from_public_key(&pk))
+            .map(Self)
+    }
+}
+
+impl TSignature<blst_core::PublicKey> for blst_core::Signature {
+    fn serialize(&self) -> [u8; SIGNATURE_BYTES_LEN] {
+        self.to_bytes()
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        Self::from_bytes(bytes).map_err(Into::into)
+    }
+
+    fn verify(&self, pubkey: &blst_core::PublicKey, msg: Hash256) -> bool {
+        self.verify(msg.as_bytes(), DST, &[], pubkey) == BLST_ERROR::BLST_SUCCESS
+    }
+}
+
+/// A wrapper that allows for `PartialEq` and `Clone` impls.
+pub struct BlstAggregateSignature(blst_core::AggregateSignature);
+
+impl Clone for BlstAggregateSignature {
+    fn clone(&self) -> Self {
+        Self(blst_core::AggregateSignature::from_signature(
+            &self.0.to_signature(),
+        ))
+    }
+}
+
+impl PartialEq for BlstAggregateSignature {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.to_signature() == other.0.to_signature()
+    }
+}
+
+impl TAggregateSignature<blst_core::PublicKey, BlstAggregatePublicKey, blst_core::Signature>
+    for BlstAggregateSignature
+{
+    fn infinity() -> Self {
+        blst_core::Signature::from_bytes(&INFINITY_SIGNATURE)
+            .map(|sig| blst_core::AggregateSignature::from_signature(&sig))
+            .map(Self)
+            .expect("should decode infinity signature")
+    }
+
+    fn add_assign(&mut self, other: &blst_core::Signature) {
+        self.0.add_signature(other)
+    }
+
+    fn add_assign_aggregate(&mut self, other: &Self) {
+        self.0.add_aggregate(&other.0)
+    }
+
+    fn serialize(&self) -> [u8; SIGNATURE_BYTES_LEN] {
+        self.0.to_signature().to_bytes()
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        blst_core::Signature::from_bytes(bytes)
+            .map_err(Into::into)
+            .map(|sig| blst_core::AggregateSignature::from_signature(&sig))
+            .map(Self)
+    }
+
+    fn fast_aggregate_verify(
+        &self,
+        msg: Hash256,
+        pubkeys: &[&GenericPublicKey<blst_core::PublicKey>],
+    ) -> bool {
+        let pubkeys = pubkeys.iter().map(|pk| pk.point()).collect::<Vec<_>>();
+        let signature = self.0.clone().to_signature();
+        signature.fast_aggregate_verify(msg.as_bytes(), DST, &pubkeys) == BLST_ERROR::BLST_SUCCESS
+    }
+
+    fn aggregate_verify(
+        &self,
+        msgs: &[Hash256],
+        pubkeys: &[&GenericPublicKey<blst_core::PublicKey>],
+    ) -> bool {
+        let pubkeys = pubkeys.iter().map(|pk| pk.point()).collect::<Vec<_>>();
+        let msgs = msgs.iter().map(|hash| hash.as_bytes()).collect::<Vec<_>>();
+        let signature = self.0.clone().to_signature();
+        signature.aggregate_verify(&msgs, DST, &pubkeys) == BLST_ERROR::BLST_SUCCESS
+    }
+}
+
+impl TSecretKey<blst_core::Signature, blst_core::PublicKey> for blst_core::SecretKey {
+    fn random() -> Self {
+        let rng = &mut rand::thread_rng();
+        let ikm: [u8; 32] = rng.gen();
+
+        Self::key_gen(&ikm, &[]).unwrap()
+    }
+
+    fn public_key(&self) -> blst_core::PublicKey {
+        self.sk_to_pk()
+    }
+
+    fn sign(&self, msg: Hash256) -> blst_core::Signature {
+        self.sign(msg.as_bytes(), DST, &[])
+    }
+
+    fn serialize(&self) -> ZeroizeHash {
+        self.to_bytes().into()
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        Self::from_bytes(&bytes).map_err(Into::into)
+    }
+}

crypto/bls/src/impls/fake_crypto.rs

@@ -0,0 +1,215 @@
+use crate::{
+    generic_aggregate_public_key::TAggregatePublicKey,
+    generic_aggregate_signature::TAggregateSignature,
+    generic_public_key::{GenericPublicKey, TPublicKey, PUBLIC_KEY_BYTES_LEN},
+    generic_secret_key::{TSecretKey, SECRET_KEY_BYTES_LEN},
+    generic_signature::{TSignature, SIGNATURE_BYTES_LEN},
+    Error, Hash256, ZeroizeHash, INFINITY_PUBLIC_KEY, INFINITY_SIGNATURE,
+};
+/// Provides the externally-facing, core BLS types.
+pub mod types {
+    pub use super::verify_signature_sets;
+    pub use super::AggregatePublicKey;
+    pub use super::AggregateSignature;
+    pub use super::PublicKey;
+    pub use super::SecretKey;
+    pub use super::Signature;
+    pub use super::SignatureSet;
+}
+
+pub type SignatureSet<'a> = crate::generic_signature_set::GenericSignatureSet<
+    'a,
+    PublicKey,
+    AggregatePublicKey,
+    Signature,
+    AggregateSignature,
+>;
+
+pub fn verify_signature_sets<'a>(
+    _signature_sets: impl ExactSizeIterator<Item = &'a SignatureSet<'a>>,
+) -> bool {
+    true
+}
+
+#[derive(Clone)]
+pub struct PublicKey([u8; PUBLIC_KEY_BYTES_LEN]);
+
+impl PublicKey {
+    fn infinity() -> Self {
+        Self(INFINITY_PUBLIC_KEY)
+    }
+}
+
+impl TPublicKey for PublicKey {
+    fn serialize(&self) -> [u8; PUBLIC_KEY_BYTES_LEN] {
+        self.0
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        let mut pubkey = Self::infinity();
+        pubkey.0[..].copy_from_slice(&bytes[0..PUBLIC_KEY_BYTES_LEN]);
+        Ok(pubkey)
+    }
+}
+
+impl Eq for PublicKey {}
+
+impl PartialEq for PublicKey {
+    fn eq(&self, other: &Self) -> bool {
+        self.0[..] == other.0[..]
+    }
+}
+
+#[derive(Clone)]
+pub struct AggregatePublicKey([u8; PUBLIC_KEY_BYTES_LEN]);
+
+impl TAggregatePublicKey for AggregatePublicKey {
+    fn infinity() -> Self {
+        Self([0; PUBLIC_KEY_BYTES_LEN])
+    }
+
+    fn serialize(&self) -> [u8; PUBLIC_KEY_BYTES_LEN] {
+        let mut bytes = [0; PUBLIC_KEY_BYTES_LEN];
+        bytes[..].copy_from_slice(&self.0);
+        bytes
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        let mut key = [0; PUBLIC_KEY_BYTES_LEN];
+
+        key[..].copy_from_slice(&bytes);
+
+        Ok(Self(key))
+    }
+}
+
+impl Eq for AggregatePublicKey {}
+
+impl PartialEq for AggregatePublicKey {
+    fn eq(&self, other: &Self) -> bool {
+        self.0[..] == other.0[..]
+    }
+}
+
+#[derive(Clone)]
+pub struct Signature([u8; SIGNATURE_BYTES_LEN]);
+
+impl Signature {
+    fn infinity() -> Self {
+        Self([0; SIGNATURE_BYTES_LEN])
+    }
+}
+
+impl TSignature<PublicKey> for Signature {
+    fn serialize(&self) -> [u8; SIGNATURE_BYTES_LEN] {
+        self.0
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        let mut signature = Self::infinity();
+        signature.0[..].copy_from_slice(&bytes[0..SIGNATURE_BYTES_LEN]);
+        Ok(signature)
+    }
+
+    fn verify(&self, _pubkey: &PublicKey, _msg: Hash256) -> bool {
+        true
+    }
+}
+
+impl PartialEq for Signature {
+    fn eq(&self, other: &Self) -> bool {
+        self.0[..] == other.0[..]
+    }
+}
+
+#[derive(Clone)]
+pub struct AggregateSignature([u8; SIGNATURE_BYTES_LEN]);
+
+impl AggregateSignature {
+    fn infinity() -> Self {
+        Self(INFINITY_SIGNATURE)
+    }
+}
+
+impl TAggregateSignature<PublicKey, AggregatePublicKey, Signature> for AggregateSignature {
+    fn infinity() -> Self {
+        Self::infinity()
+    }
+
+    fn add_assign(&mut self, _other: &Signature) {
+        // Do nothing.
+    }
+
+    fn add_assign_aggregate(&mut self, _other: &Self) {
+        // Do nothing.
+    }
+
+    fn serialize(&self) -> [u8; SIGNATURE_BYTES_LEN] {
+        let mut bytes = [0; SIGNATURE_BYTES_LEN];
+
+        bytes[..].copy_from_slice(&self.0);
+
+        bytes
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        let mut key = [0; SIGNATURE_BYTES_LEN];
+
+        key[..].copy_from_slice(&bytes);
+
+        Ok(Self(key))
+    }
+
+    fn fast_aggregate_verify(
+        &self,
+        _msg: Hash256,
+        _pubkeys: &[&GenericPublicKey<PublicKey>],
+    ) -> bool {
+        true
+    }
+
+    fn aggregate_verify(
+        &self,
+        _msgs: &[Hash256],
+        _pubkeys: &[&GenericPublicKey<PublicKey>],
+    ) -> bool {
+        true
+    }
+}
+
+impl Eq for AggregateSignature {}
+
+impl PartialEq for AggregateSignature {
+    fn eq(&self, other: &Self) -> bool {
+        self.0[..] == other.0[..]
+    }
+}
+
+#[derive(Clone)]
+pub struct SecretKey([u8; SECRET_KEY_BYTES_LEN]);
+
+impl TSecretKey<Signature, PublicKey> for SecretKey {
+    fn random() -> Self {
+        Self([0; SECRET_KEY_BYTES_LEN])
+    }
+
+    fn public_key(&self) -> PublicKey {
+        PublicKey::infinity()
+    }
+
+    fn sign(&self, _msg: Hash256) -> Signature {
+        Signature::infinity()
+    }
+
+    fn serialize(&self) -> ZeroizeHash {
+        let mut bytes = [0; SECRET_KEY_BYTES_LEN];
+        bytes[..].copy_from_slice(&self.0[..]);
+        bytes.into()
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        let mut sk = Self::random();
+        sk.0[..].copy_from_slice(&bytes[0..SECRET_KEY_BYTES_LEN]);
+        Ok(sk)
+    }
+}

crypto/bls/src/impls/milagro.rs

@@ -0,0 +1,197 @@
+use crate::{
+    generic_aggregate_public_key::TAggregatePublicKey,
+    generic_aggregate_signature::TAggregateSignature,
+    generic_public_key::{GenericPublicKey, TPublicKey, PUBLIC_KEY_BYTES_LEN},
+    generic_secret_key::{TSecretKey, SECRET_KEY_BYTES_LEN},
+    generic_signature::{TSignature, SIGNATURE_BYTES_LEN},
+    Error, Hash256, ZeroizeHash, INFINITY_PUBLIC_KEY,
+};
+pub use milagro_bls as milagro;
+use rand::thread_rng;
+use std::iter::ExactSizeIterator;
+
+/// Provides the externally-facing, core BLS types.
+pub mod types {
+    pub use super::milagro::AggregatePublicKey;
+    pub use super::milagro::AggregateSignature;
+    pub use super::milagro::PublicKey;
+    pub use super::milagro::SecretKey;
+    pub use super::milagro::Signature;
+    pub use super::verify_signature_sets;
+    pub use super::SignatureSet;
+}
+
+pub type SignatureSet<'a> = crate::generic_signature_set::GenericSignatureSet<
+    'a,
+    milagro::PublicKey,
+    milagro::AggregatePublicKey,
+    milagro::Signature,
+    milagro::AggregateSignature,
+>;
+
+pub fn verify_signature_sets<'a>(
+    signature_sets: impl ExactSizeIterator<Item = &'a SignatureSet<'a>>,
+) -> bool {
+    if signature_sets.len() == 0 {
+        return false;
+    }
+
+    signature_sets
+        .map(|signature_set| {
+            let mut aggregate = milagro::AggregatePublicKey::from_public_key(
+                signature_set.signing_keys.first().ok_or(())?.point(),
+            );
+
+            for signing_key in signature_set.signing_keys.iter().skip(1) {
+                aggregate.add(signing_key.point())
+            }
+
+            if signature_set.signature.point().is_none() {
+                return Err(());
+            }
+
+            Ok((
+                signature_set.signature.as_ref(),
+                aggregate,
+                signature_set.message,
+            ))
+        })
+        .collect::<Result<Vec<_>, ()>>()
+        .map(|aggregates| {
+            milagro::AggregateSignature::verify_multiple_aggregate_signatures(
+                &mut rand::thread_rng(),
+                aggregates.iter().map(|(signature, aggregate, message)| {
+                    (
+                        signature
+                            .point()
+                            .expect("guarded against none by previous check"),
+                        aggregate,
+                        message.as_bytes(),
+                    )
+                }),
+            )
+        })
+        .unwrap_or(false)
+}
+
+impl TPublicKey for milagro::PublicKey {
+    fn serialize(&self) -> [u8; PUBLIC_KEY_BYTES_LEN] {
+        let mut bytes = [0; PUBLIC_KEY_BYTES_LEN];
+        bytes[..].copy_from_slice(&self.as_bytes());
+        bytes
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        Self::from_bytes(&bytes).map_err(Into::into)
+    }
+}
+
+impl TAggregatePublicKey for milagro::AggregatePublicKey {
+    fn infinity() -> Self {
+        Self::from_bytes(&INFINITY_PUBLIC_KEY).expect("should decode infinity public key")
+    }
+
+    fn serialize(&self) -> [u8; PUBLIC_KEY_BYTES_LEN] {
+        let mut bytes = [0; PUBLIC_KEY_BYTES_LEN];
+        bytes[..].copy_from_slice(&self.as_bytes());
+        bytes
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        Self::from_bytes(&bytes).map_err(Into::into)
+    }
+}
+
+impl TSignature<milagro::PublicKey> for milagro::Signature {
+    fn serialize(&self) -> [u8; SIGNATURE_BYTES_LEN] {
+        let mut bytes = [0; SIGNATURE_BYTES_LEN];
+
+        bytes[..].copy_from_slice(&self.as_bytes());
+
+        bytes
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        milagro::Signature::from_bytes(&bytes).map_err(Error::MilagroError)
+    }
+
+    fn verify(&self, pubkey: &milagro::PublicKey, msg: Hash256) -> bool {
+        self.verify(msg.as_bytes(), pubkey)
+    }
+}
+
+impl TAggregateSignature<milagro::PublicKey, milagro::AggregatePublicKey, milagro::Signature>
+    for milagro::AggregateSignature
+{
+    fn infinity() -> Self {
+        milagro::AggregateSignature::new()
+    }
+
+    fn add_assign(&mut self, other: &milagro::Signature) {
+        self.add(other)
+    }
+
+    fn add_assign_aggregate(&mut self, other: &Self) {
+        self.add_aggregate(other)
+    }
+
+    fn serialize(&self) -> [u8; SIGNATURE_BYTES_LEN] {
+        let mut bytes = [0; SIGNATURE_BYTES_LEN];
+
+        bytes[..].copy_from_slice(&self.as_bytes());
+
+        bytes
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        milagro::AggregateSignature::from_bytes(&bytes).map_err(Error::MilagroError)
+    }
+
+    fn fast_aggregate_verify(
+        &self,
+        msg: Hash256,
+        pubkeys: &[&GenericPublicKey<milagro::PublicKey>],
+    ) -> bool {
+        let pubkeys = pubkeys.iter().map(|pk| pk.point()).collect::<Vec<_>>();
+        self.fast_aggregate_verify(msg.as_bytes(), &pubkeys)
+    }
+
+    fn aggregate_verify(
+        &self,
+        msgs: &[Hash256],
+        pubkeys: &[&GenericPublicKey<milagro::PublicKey>],
+    ) -> bool {
+        let pubkeys = pubkeys.iter().map(|pk| pk.point()).collect::<Vec<_>>();
+        let msgs = msgs.iter().map(|hash| hash.as_bytes()).collect::<Vec<_>>();
+        self.aggregate_verify(&msgs, &pubkeys)
+    }
+}
+
+impl TSecretKey<milagro::Signature, milagro::PublicKey> for milagro::SecretKey {
+    fn random() -> Self {
+        Self::random(&mut thread_rng())
+    }
+
+    fn public_key(&self) -> milagro::PublicKey {
+        let point = milagro::PublicKey::from_secret_key(self).point;
+        milagro::PublicKey { point }
+    }
+
+    fn sign(&self, msg: Hash256) -> milagro::Signature {
+        let point = milagro::Signature::new(msg.as_bytes(), self).point;
+        milagro::Signature { point }
+    }
+
+    fn serialize(&self) -> ZeroizeHash {
+        let mut bytes = [0; SECRET_KEY_BYTES_LEN];
+
+        // Takes the right-hand 32 bytes from the secret key.
+        bytes[..].copy_from_slice(&self.as_bytes());
+
+        bytes.into()
+    }
+
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        Self::from_bytes(&bytes).map_err(Into::into)
+    }
+}

crypto/bls/src/impls/mod.rs

@@ -0,0 +1,3 @@
+pub mod blst;
+pub mod fake_crypto;
+pub mod milagro;