unify bls

Author: ltitanb

Cargo.lock

@@ -24,7 +24,6 @@ axum-extra = { version = "0.10.0", features = ["typed-header"] }
 base64 = "0.22.1"
 bimap = { version = "0.6.3", features = ["serde"] }
 blsful = "2.5"
-blst = "0.3.11"
 cb-cli = { path = "crates/cli" }
 cb-common = { path = "crates/common" }
 cb-metrics = { path = "crates/metrics" }
@@ -37,7 +36,6 @@ ctr = "0.9.2"
 derive_more = { version = "2.0.1", features = ["deref", "display", "from", "into"] }
 docker-compose-types = "0.16.0"
 docker-image = "0.2.1"
-eth2_keystore = { git = "https://github.com/sigp/lighthouse", tag = "v7.0.1" }
 ethereum_serde_utils = "0.7.0"
 ethereum_ssz = "0.8"
 ethereum_ssz_derive = "0.8"
@@ -47,6 +45,8 @@ headers = "0.4.0"
 indexmap = "2.2.6"
 jsonwebtoken = { version = "9.3.1", default-features = false }
 lazy_static = "1.5.0"
+lh_eth2_keystore = { package = "eth2_keystore", git = "https://github.com/sigp/lighthouse", tag = "v7.1.0" }
+lh_types = { package = "types", git = "https://github.com/sigp/lighthouse", tag = "v7.1.0" }
 parking_lot = "0.12.3"
 pbkdf2 = "0.12.2"
 prometheus = "0.13.4"

Cargo.toml

@@ -1,12 +1,10 @@
 use std::time::{Duration, Instant};
 
-use alloy::{primitives::B256, rpc::types::beacon::BlsPublicKey};
+use alloy::{hex, primitives::B256};
 use cb_common::{
     config::RelayConfig,
-    pbs::{GetHeaderResponse, RelayClient, RelayEntry},
-    signer::BlsSecretKey,
+    pbs::{BlsPublicKey, BlsSecretKey, GetHeaderResponse, RelayClient, RelayEntry},
     types::Chain,
-    utils::blst_pubkey_to_alloy,
 };
 use cb_tests::mock_relay::{start_mock_relay_service, MockRelayState};
 use comfy_table::Table;
@@ -19,7 +17,7 @@ fn get_random_hash() -> B256 {
     B256::from(rand::random::<[u8; 32]>())
 }
 fn get_random_pubkey() -> BlsPublicKey {
-    BlsPublicKey::ZERO
+    BlsPublicKey::deserialize(&hex!("0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")).unwrap()
 }
 
 #[tokio::main]
@@ -47,7 +45,7 @@ async fn main() {
         for slot in 0..config.benchmark.n_slots {
             let parent_hash = get_random_hash();
             let validator_pubkey = get_random_pubkey();
-            let url = mock_validator.get_header_url(slot, parent_hash, validator_pubkey).unwrap();
+            let url = mock_validator.get_header_url(slot, &parent_hash, &validator_pubkey).unwrap();
 
             for _ in 0..config.benchmark.headers_per_slot {
                 let url = url.clone();
@@ -138,8 +136,8 @@ const MOCK_RELAY_SECRET: [u8; 32] = [
     152, 98, 59, 240, 181, 131, 47, 1, 180, 255, 245,
 ];
 async fn start_mock_relay(chain: Chain, relay_config: RelayConfig) {
-    let signer = BlsSecretKey::key_gen(&MOCK_RELAY_SECRET, &[]).unwrap();
-    let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk());
+    let signer = BlsSecretKey::deserialize(&MOCK_RELAY_SECRET).unwrap();
+    let pubkey: BlsPublicKey = signer.public_key();
 
     assert_eq!(relay_config.entry.pubkey, pubkey, "Expected relay pubkey to be 0xb060572f535ba5615b874ebfef757fbe6825352ad257e31d724e57fe25a067a13cfddd0f00cb17bf3a3d2e901a380c17");
 
@@ -152,7 +150,7 @@ async fn start_mock_relay(chain: Chain, relay_config: RelayConfig) {
 }
 
 fn get_mock_validator(bench: BenchConfig) -> RelayClient {
-    let entry = RelayEntry { id: bench.id, pubkey: BlsPublicKey::default(), url: bench.url };
+    let entry = RelayEntry { id: bench.id, pubkey: get_random_pubkey(), url: bench.url };
     let config = RelayConfig {
         entry,
         id: None,

benches/pbs/src/main.rs

@@ -9,8 +9,8 @@ pub mod prelude {
             load_builder_module_config, load_commit_module_config, load_pbs_config,
             load_pbs_custom_config, LogsSettings, StartCommitModuleConfig, PBS_MODULE_NAME,
         },
-        pbs::{BuilderEvent, BuilderEventClient, OnBuilderApiEvent},
-        signer::{BlsPublicKey, BlsSignature, EcdsaSignature},
+        pbs::{BlsPublicKey, BlsSignature, BuilderEvent, BuilderEventClient, OnBuilderApiEvent},
+        signer::EcdsaSignature,
         types::Chain,
         utils::{initialize_tracing_log, utcnow_ms, utcnow_ns, utcnow_sec, utcnow_us},
     };

bin/src/lib.rs

@@ -12,17 +12,17 @@ async-trait.workspace = true
 axum.workspace = true
 base64.workspace = true
 bimap.workspace = true
-blst.workspace = true
 cipher.workspace = true
 ctr.workspace = true
 derive_more.workspace = true
 docker-image.workspace = true
-eth2_keystore.workspace = true
 ethereum_serde_utils.workspace = true
 ethereum_ssz.workspace = true
 ethereum_ssz_derive.workspace = true
 eyre.workspace = true
 jsonwebtoken.workspace = true
+lh_eth2_keystore.workspace = true
+lh_types.workspace = true
 pbkdf2.workspace = true
 rand.workspace = true
 rayon.workspace = true

crates/common/Cargo.toml

@@ -1,6 +1,6 @@
 use std::time::{Duration, Instant};
 
-use alloy::{primitives::Address, rpc::types::beacon::BlsSignature};
+use alloy::primitives::Address;
 use eyre::WrapErr;
 use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION};
 use serde::Deserialize;
@@ -16,7 +16,8 @@ use super::{
 };
 use crate::{
     constants::SIGNER_JWT_EXPIRATION,
-    signer::{BlsPublicKey, EcdsaSignature},
+    pbs::{BlsPublicKey, BlsSignature},
+    signer::EcdsaSignature,
     types::{Jwt, ModuleId},
     utils::create_jwt,
     DEFAULT_REQUEST_TIMEOUT,

crates/common/src/commit/client.rs

@@ -6,26 +6,37 @@ use std::{
 use alloy::{
     hex,
     primitives::{Address, B256},
-    rpc::types::beacon::BlsSignature,
 };
 use derive_more::derive::From;
 use serde::{Deserialize, Serialize};
 use tree_hash::TreeHash;
 use tree_hash_derive::TreeHash;
 
 use crate::{
-    constants::COMMIT_BOOST_DOMAIN, error::BlstErrorWrapper, signature::verify_signed_message,
-    signer::BlsPublicKey, types::Chain,
+    constants::COMMIT_BOOST_DOMAIN,
+    pbs::{BlsPublicKey, BlsSignature},
+    signature::verify_signed_message,
+    types::Chain,
 };
 
-pub trait ProxyId: AsRef<[u8]> + Debug + Clone + Copy + TreeHash + Display {}
+pub trait ProxyId: Debug + Clone + TreeHash + Display {
+    fn to_bytes(&self) -> Vec<u8>;
+}
 
-impl ProxyId for Address {}
+impl ProxyId for Address {
+    fn to_bytes(&self) -> Vec<u8> {
+        self.0.as_slice().to_vec()
+    }
+}
 
-impl ProxyId for BlsPublicKey {}
+impl ProxyId for BlsPublicKey {
+    fn to_bytes(&self) -> Vec<u8> {
+        self.serialize().to_vec()
+    }
+}
 
 // GENERIC PROXY DELEGATION
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, TreeHash)]
+#[derive(Debug, Clone, Serialize, Deserialize, TreeHash)]
 pub struct ProxyDelegation<T: ProxyId> {
     pub delegator: BlsPublicKey,
     pub proxy: T,
@@ -40,7 +51,7 @@ impl<T: ProxyId> fmt::Display for ProxyDelegation<T> {
     }
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SignedProxyDelegation<T: ProxyId> {
     pub message: ProxyDelegation<T>,
     /// Signature of message with the delegator keypair
@@ -51,7 +62,7 @@ pub type SignedProxyDelegationBls = SignedProxyDelegation<BlsPublicKey>;
 pub type SignedProxyDelegationEcdsa = SignedProxyDelegation<Address>;
 
 impl<T: ProxyId> SignedProxyDelegation<T> {
-    pub fn validate(&self, chain: Chain) -> Result<(), BlstErrorWrapper> {
+    pub fn validate(&self, chain: Chain) -> bool {
         verify_signed_message(
             chain,
             &self.message.delegator,

crates/common/src/commit/request.rs

@@ -7,7 +7,6 @@ use std::{
 use alloy::{
     primitives::{address, Address, U256},
     providers::ProviderBuilder,
-    rpc::types::beacon::BlsPublicKey,
     sol,
 };
 use eyre::{bail, ensure, Context};
@@ -16,7 +15,11 @@ use tracing::{debug, info};
 use url::Url;
 
 use super::{load_optional_env_var, PbsConfig, RelayConfig, MUX_PATH_ENV};
-use crate::{config::remove_duplicate_keys, pbs::RelayClient, types::Chain};
+use crate::{
+    config::remove_duplicate_keys,
+    pbs::{BlsPublicKey, RelayClient},
+    types::Chain,
+};
 
 #[derive(Debug, Deserialize, Serialize)]
 pub struct PbsMuxes {
@@ -93,8 +96,8 @@ impl PbsMuxes {
             let config = Arc::new(config);
 
             let runtime_config = RuntimeMuxConfig { id: mux.id, config, relays: relay_clients };
-            for pubkey in mux.validator_pubkeys.iter() {
-                configs.insert(*pubkey, runtime_config.clone());
+            for pubkey in mux.validator_pubkeys.into_iter() {
+                configs.insert(pubkey, runtime_config.clone());
             }
         }
 
@@ -254,7 +257,7 @@ async fn fetch_lido_registry_keys(
     debug!("fetching {total_keys} total keys");
 
     const CALL_BATCH_SIZE: u64 = 250u64;
-    const BLS_PK_LEN: usize = BlsPublicKey::len_bytes();
+    const BLS_PK_LEN: usize = 48;
 
     let mut keys = vec![];
     let mut offset = 0;
@@ -275,7 +278,10 @@ async fn fetch_lido_registry_keys(
         );
 
         for chunk in pubkeys.chunks(BLS_PK_LEN) {
-            keys.push(BlsPublicKey::try_from(chunk)?);
+            keys.push(
+                BlsPublicKey::deserialize(chunk)
+                    .map_err(|_| eyre::eyre!("invalid BLS public key"))?,
+            );
         }
 
         offset += limit;
@@ -319,10 +325,13 @@ async fn fetch_ssv_pubkeys(
             .json::<SSVResponse>()
             .await?;
 
-        pubkeys.extend(response.validators.iter().map(|v| v.pubkey).collect::<Vec<BlsPublicKey>>());
+        let fetched = response.validators.len();
+        pubkeys.extend(
+            response.validators.into_iter().map(|v| v.pubkey).collect::<Vec<BlsPublicKey>>(),
+        );
         page += 1;
 
-        if response.validators.len() < MAX_PER_PAGE {
+        if fetched < MAX_PER_PAGE {
             ensure!(
                 pubkeys.len() == response.pagination.total,
                 "expected {} keys, got {}",
@@ -383,8 +392,11 @@ mod tests {
             .pubkeys;
 
         let mut vec = vec![];
-        for chunk in pubkeys.chunks(BlsPublicKey::len_bytes()) {
-            vec.push(BlsPublicKey::try_from(chunk)?);
+        for chunk in pubkeys.chunks(48) {
+            vec.push(
+                BlsPublicKey::deserialize(chunk)
+                    .map_err(|_| eyre::eyre!("invalid BLS public key"))?,
+            );
         }
 
         assert_eq!(vec.len(), LIMIT);

crates/common/src/config/mux.rs

@@ -9,7 +9,6 @@ use std::{
 use alloy::{
     primitives::{utils::format_ether, U256},
     providers::{Provider, ProviderBuilder},
-    rpc::types::beacon::BlsPublicKey,
 };
 use eyre::{ensure, Result};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
@@ -26,8 +25,8 @@ use crate::{
         SIGNER_URL_ENV,
     },
     pbs::{
-        BuilderEventPublisher, DefaultTimeout, RelayClient, RelayEntry, DEFAULT_PBS_PORT,
-        LATE_IN_SLOT_TIME_MS, REGISTER_VALIDATOR_RETRY_LIMIT,
+        BlsPublicKey, BuilderEventPublisher, DefaultTimeout, RelayClient, RelayEntry,
+        DEFAULT_PBS_PORT, LATE_IN_SLOT_TIME_MS, REGISTER_VALIDATOR_RETRY_LIMIT,
     },
     types::{Chain, Jwt, ModuleId},
     utils::{

crates/common/src/config/pbs.rs

@@ -1,11 +1,10 @@
 use std::{collections::HashMap, path::Path};
 
-use alloy::rpc::types::beacon::BlsPublicKey;
 use eyre::{bail, Context, Result};
 use serde::de::DeserializeOwned;
 
 use super::JWTS_ENV;
-use crate::types::ModuleId;
+use crate::{pbs::BlsPublicKey, types::ModuleId};
 
 pub fn load_env_var(env: &str) -> Result<String> {
     std::env::var(env).wrap_err(format!("{env} is not set"))
@@ -37,7 +36,7 @@ pub fn remove_duplicate_keys(keys: Vec<BlsPublicKey>) -> Vec<BlsPublicKey> {
     let mut key_set = std::collections::HashSet::new();
 
     for key in keys {
-        if key_set.insert(key) {
+        if key_set.insert(key.clone()) {
             unique_keys.push(key);
         }
     }
@@ -75,9 +74,9 @@ mod tests {
 
     #[test]
     fn test_remove_duplicate_keys() {
-        let key1 = BlsPublicKey::from([1; 48]);
-        let key2 = BlsPublicKey::from([2; 48]);
-        let keys = vec![key1, key2, key1];
+        let key1 = BlsPublicKey::deserialize(&[1; 48]).unwrap();
+        let key2 = BlsPublicKey::deserialize(&[2; 48]).unwrap();
+        let keys = vec![key1.clone(), key2.clone(), key1.clone()];
 
         let unique_keys = remove_duplicate_keys(keys);
         assert_eq!(unique_keys.len(), 2);