chore: move signer into its own workspace module

Author: azixus

Cargo.lock

@@ -7,6 +7,7 @@ members = [
     "omnievent",
     "onlyswaps-verifier",
     "randomness-agent",
+    "signer",
     "superalloy"
 ]
 
@@ -18,6 +19,7 @@ edition = "2024"
 # workspace crates
 dcipher-agents = { path = "./dcipher-agents" }
 superalloy = { path = "./superalloy" }
+dcipher-signer = { path = "./signer" }
 
 # blockchain
 alloy = { version = "1.0", default-features = false }

Cargo.toml

@@ -7,6 +7,9 @@ edition.workspace = true
 rayon = ["dep:rayon"]
 
 [dependencies]
+# workspace crates
+dcipher-signer.workspace = true
+
 alloy = { workspace = true, features = ["default", "provider-ws"] }
 
 # crypto

dcipher-agents/Cargo.toml

@@ -73,9 +73,12 @@ mod bn254 {
     use ark_ec::pairing::PairingOutput;
     use ark_ff::{BigInteger, Field, PrimeField};
     use ark_std::Zero;
+    use dcipher_signer::{BlsSigner, BlsVerifier};
     use digest::core_api::BlockSizeUser;
     use pairing_utils::hash_to_curve::CustomPairingHashToCurve;
+    use std::convert::Infallible;
     use std::ops::Neg;
+
     /// Cipher suite for IBE w/ identity on bn254 G1.
     #[derive(Clone, Debug)]
     pub struct IbeIdentityOnBn254G1Suite<S = ()> {
@@ -152,6 +155,34 @@ mod bn254 {
         }
     }
 
+    /// Implementation of a BLS verifier [`IbeIdentityOnBn254G1Suite`].
+    impl<S> BlsVerifier for IbeIdentityOnBn254G1Suite<S> {
+        type SignatureGroup = <Self as PairingIbeCipherSuite>::IdentityGroup;
+        type PublicKeyGroup = <Self as PairingIbeCipherSuite>::PublicKeyGroup;
+
+        fn verify(
+            &self,
+            m: impl AsRef<[u8]>,
+            signature: Self::SignatureGroup,
+            public_key: Self::PublicKeyGroup,
+        ) -> bool {
+            self.verify_decryption_key(m.as_ref(), signature, public_key)
+        }
+    }
+
+    /// Implementation of a BLS signer [`IbeIdentityOnBn254G1Suite`].
+    impl<S> BlsSigner for IbeIdentityOnBn254G1Suite<S>
+    where
+        Self: BlsVerifier + PairingIbeSigner<IdentityGroup = <Self as BlsVerifier>::SignatureGroup>,
+    {
+        type Error = Infallible;
+
+        fn sign(&self, m: impl AsRef<[u8]>) -> Result<Self::SignatureGroup, Self::Error> {
+            let identity = self.h1(m.as_ref());
+            Ok(self.decryption_key(identity))
+        }
+    }
+
     /// Ciphertext for IBE w/ identity on bn254 G1.
     /// Currently, it only contains an ephemeral public key.
     pub struct IbeIdentityOnBn254G1Ciphertext {

dcipher-agents/src/ibe_helper.rs

@@ -4,7 +4,9 @@ pub mod fulfiller;
 pub mod ibe_helper;
 pub(crate) mod ser;
 pub mod signature_sender;
-pub mod signer;
+
+// Re-exports
+pub use dcipher_signer as signer;
 
 #[derive(
     Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, serde::Serialize, serde::Deserialize, Debug,

dcipher-agents/src/lib.rs

@@ -0,0 +1,40 @@
+[package]
+name = "dcipher-signer"
+version.workspace = true
+edition.workspace = true
+
+[features]
+rayon = ["dep:rayon"]
+
+[dependencies]
+# crypto
+ark-bn254 = { workspace = true }
+ark-ec = { workspace = true }
+ark-ff = { workspace = true }
+ark-std = { workspace = true }
+pairing_utils = { workspace = true }
+
+# hashes
+sha3 = { workspace = true }
+
+# async
+futures-util = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "sync"] }
+tokio-util = { workspace = true }
+
+# logs / metrics
+prometheus = { workspace = true }
+tracing = { workspace = true }
+
+# network
+libp2p = { workspace = true, features = ["tcp", "dns", "noise", "tokio", "ping", "yamux", "macros", "floodsub", "serde"] }
+
+# serde
+serde = { workspace = true, features = ["derive"] }
+serde_cbor = "0.10"
+
+# misc
+itertools = { workspace = true }
+thiserror = { workspace = true }
+lru = "0.14"
+rayon = { version = "1.10", optional = true }

signer/Cargo.toml

@@ -1,6 +1,5 @@
 //! Various traits and implementations used to sign messages.
 
-use crate::ibe_helper::{PairingIbeCipherSuite, PairingIbeSigner};
 use ark_ec::pairing::Pairing;
 use ark_ec::{AffineRepr, CurveGroup};
 use ark_ff::Zero;
@@ -92,34 +91,3 @@ impl BlsSigner for BN254SignatureOnG1Signer {
         Ok(sig.into_affine())
     }
 }
-
-/// Blanket implementation of a BLS verifier for all [`PairingIbeCipherSuite`].
-impl<CS> BlsVerifier for CS
-where
-    CS: PairingIbeCipherSuite,
-{
-    type SignatureGroup = CS::IdentityGroup;
-    type PublicKeyGroup = CS::PublicKeyGroup;
-
-    fn verify(
-        &self,
-        m: impl AsRef<[u8]>,
-        signature: Self::SignatureGroup,
-        public_key: Self::PublicKeyGroup,
-    ) -> bool {
-        self.verify_decryption_key(m.as_ref(), signature, public_key)
-    }
-}
-
-/// Blanket implementation of a BLS verifier for all [`PairingIbeSigner`].
-impl<CS> BlsSigner for CS
-where
-    CS: PairingIbeSigner,
-{
-    type Error = Infallible;
-
-    fn sign(&self, m: impl AsRef<[u8]>) -> Result<Self::SignatureGroup, Self::Error> {
-        let identity = self.h1(m.as_ref());
-        Ok(PairingIbeSigner::decryption_key(self, identity))
-    }
-}

dcipher-agents/src/signer.rs signer/src/lib.rsdcipher-agents/src/signer.rs renamed to signer/src/lib.rs

@@ -7,10 +7,9 @@ pub mod metrics;
 
 pub use aggregation::lagrange_points_interpolate_at;
 
-use crate::ser::EvmSerialize;
-use crate::signer::threshold_signer::libp2p::LibP2PNode;
-use crate::signer::threshold_signer::metrics::Metrics;
-use crate::signer::{AsynchronousSigner, BlsSigner, BlsVerifier};
+use crate::threshold_signer::libp2p::LibP2PNode;
+use crate::threshold_signer::metrics::Metrics;
+use crate::{AsynchronousSigner, BlsSigner, BlsVerifier};
 use ark_ec::{AffineRepr, CurveGroup};
 use itertools::Either;
 use lru::LruCache;
@@ -83,7 +82,7 @@ where
 impl<BLS> ThresholdSigner<BLS>
 where
     BLS: BlsSigner + Clone + Send + Sync + 'static,
-    SignatureGroup<BLS>: EvmSerialize + PointSerializeCompressed + PointDeserializeCompressed,
+    SignatureGroup<BLS>: PointSerializeCompressed + PointDeserializeCompressed,
 {
     /// Create a new threshold signer by specifying the various threshold scheme parameters.
     pub fn new(cs: BLS, n: u16, t: u16, id: u16, pks: Vec<BLS::PublicKeyGroup>) -> Self {
@@ -517,7 +516,6 @@ impl<BLS, M> AsynchronousSigner<M> for AsyncThresholdSigner<BLS>
 where
     BLS: BlsSigner + Send + Sync,
     M: AsRef<[u8]>,
-    SignatureGroup<BLS>: EvmSerialize,
     for<'a> &'a SignatureGroup<BLS>: ToOwned,
 {
     type Error = AsyncThresholdSignerError;
@@ -603,7 +601,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::ibe_helper::IbeIdentityOnBn254G1Suite;
+    use crate::BN254SignatureOnG1Signer;
     use ark_bn254::Fr;
     use ark_ff::MontFp;
     use std::time::Duration;
@@ -628,9 +626,12 @@ mod tests {
             .map(|pki| pki.into_affine())
             .collect::<Vec<_>>();
 
-        let cs1 = IbeIdentityOnBn254G1Suite::new_signer(b"TEST", 31337, sk1);
-        let cs2 = IbeIdentityOnBn254G1Suite::new_signer(b"TEST", 31337, sk2);
-        let cs3 = IbeIdentityOnBn254G1Suite::new_signer(b"TEST", 31337, sk3);
+        let cs1 =
+            BN254SignatureOnG1Signer::new(sk1, b"BN254G1_XMD:KECCAK-256_SVDW_RO_H1_".to_vec());
+        let cs2 =
+            BN254SignatureOnG1Signer::new(sk2, b"BN254G1_XMD:KECCAK-256_SVDW_RO_H1_".to_vec());
+        let cs3 =
+            BN254SignatureOnG1Signer::new(sk3, b"BN254G1_XMD:KECCAK-256_SVDW_RO_H1_".to_vec());
 
         let libp2p_sk1 = ::libp2p::identity::Keypair::generate_ed25519();
         let libp2p_sk2 = ::libp2p::identity::Keypair::generate_ed25519();

…er-agents/src/signer/threshold_signer.rs signer/src/threshold_signer.rsdcipher-agents/src/signer/threshold_signer.rs renamed to signer/src/threshold_signer.rs dcipher-agents/src/signer/threshold_signer.rs renamed to signer/src/threshold_signer.rs

@@ -0,0 +1,21 @@
+// use std::num::NonZeroUsize;
+// use std::sync::Arc;
+// use lru::LruCache;
+// use redis::aio::{ConnectionManager, ConnectionManagerConfig};
+//
+// struct RedisBackedCache<K, V> {
+//     mem_cache: Arc<tokio::sync::Mutex<LruCache<K, V>>>,
+//     redis: ConnectionManager,
+//     // Arc<std::sync::Mutex<LruCache<Vec<u8>, HashMap<u16, PartialSignature<SignatureGroup<BLS>>>>>>;
+// }
+//
+// impl<K, V> RedisBackedCache<K, V> {
+//     pub fn new(mem_cache_size: NonZeroUsize, redis_connection_manager: ConnectionManager) -> Self {
+//         let config = ConnectionManagerConfig::new()
+//             .set_push_sender()
+//         Self {
+//             mem_cache: Arc::new(tokio::sync::Mutex::new(LruCache::new(mem_cache_size))),
+//             redis
+//         }
+//     }
+// }