fix clippy + some tests

Author: ltitanb

benches/pbs/src/main.rs

@@ -1,10 +1,11 @@
 use std::time::{Duration, Instant};
 
-use alloy::{hex, primitives::B256};
+use alloy::primitives::B256;
 use cb_common::{
     config::RelayConfig,
     pbs::{BlsPublicKey, BlsSecretKey, GetHeaderResponse, RelayClient, RelayEntry},
     types::Chain,
+    utils::TestRandomSeed,
 };
 use cb_tests::mock_relay::{start_mock_relay_service, MockRelayState};
 use comfy_table::Table;
@@ -16,9 +17,6 @@ mod config;
 fn get_random_hash() -> B256 {
     B256::from(rand::random::<[u8; 32]>())
 }
-fn get_random_pubkey() -> BlsPublicKey {
-    BlsPublicKey::deserialize(&hex!("0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")).unwrap()
-}
 
 #[tokio::main]
 async fn main() {
@@ -44,7 +42,7 @@ async fn main() {
         // bench
         for slot in 0..config.benchmark.n_slots {
             let parent_hash = get_random_hash();
-            let validator_pubkey = get_random_pubkey();
+            let validator_pubkey = BlsPublicKey::test_random();
             let url = mock_validator.get_header_url(slot, &parent_hash, &validator_pubkey).unwrap();
 
             for _ in 0..config.benchmark.headers_per_slot {
@@ -150,7 +148,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: get_random_pubkey(), url: bench.url };
+    let entry = RelayEntry { id: bench.id, pubkey: BlsPublicKey::test_random(), url: bench.url };
     let config = RelayConfig {
         entry,
         id: None,

crates/common/src/commit/request.rs

@@ -261,7 +261,7 @@ mod tests {
 
     #[test]
     fn test_decode_response_signature() {
-        let data = r#""0xa3ffa9241f78279f1af04644cb8c79c2d8f02bcf0e28e2f186f6dcccac0a869c2be441fda50f0dea895cfce2e53f0989a3ffa9241f78279f1af04644cb8c79c2d8f02bcf0e28e2f186f6dcccac0a869c2be441fda50f0dea895cfce2e53f0989""#;
+        let data = r#""0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000""#;
         let _: BlsSignature = serde_json::from_str(data).unwrap();
 
         let data = r#""0x985b495f49d1b96db3bba3f6c5dd1810950317c10d4c2042bd316f338cdbe74359072e209b85e56ac492092d7860063dd096ca31b4e164ef27e3f8d508e656801c""#;
@@ -294,7 +294,7 @@ mod tests {
                 "delegator": "0xa3366b54f28e4bf1461926a3c70cdb0ec432b5c92554ecaae3742d33fb33873990cbed1761c68020e6d3c14d30a22050",
                 "proxy": "0xa3366b54f28e4bf1461926a3c70cdb0ec432b5c92554ecaae3742d33fb33873990cbed1761c68020e6d3c14d30a22050"
             },
-            "signature": "0xa3ffa9241f78279f1af04644cb8c79c2d8f02bcf0e28e2f186f6dcccac0a869c2be441fda50f0dea895cfce2e53f0989a3ffa9241f78279f1af04644cb8c79c2d8f02bcf0e28e2f186f6dcccac0a869c2be441fda50f0dea895cfce2e53f0989"
+            "signature": "0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
         }"#;
 
         let _: SignedProxyDelegationBls = serde_json::from_str(data).unwrap();
@@ -304,7 +304,7 @@ mod tests {
                 "delegator": "0xa3366b54f28e4bf1461926a3c70cdb0ec432b5c92554ecaae3742d33fb33873990cbed1761c68020e6d3c14d30a22050",
                 "proxy": "0x4ca9939a8311a7cab3dde201b70157285fa81a9d"
             },
-            "signature": "0xa3ffa9241f78279f1af04644cb8c79c2d8f02bcf0e28e2f186f6dcccac0a869c2be441fda50f0dea895cfce2e53f0989a3ffa9241f78279f1af04644cb8c79c2d8f02bcf0e28e2f186f6dcccac0a869c2be441fda50f0dea895cfce2e53f0989"
+            "signature": "0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
         }"#;
 
         let _: SignedProxyDelegationEcdsa = serde_json::from_str(data).unwrap();

crates/common/src/config/utils.rs

@@ -61,6 +61,7 @@ fn decode_string_to_map(raw: &str) -> Result<HashMap<ModuleId, String>> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::utils::TestRandomSeed;
 
     #[test]
     fn test_decode_string_to_map() {
@@ -74,8 +75,8 @@ mod tests {
 
     #[test]
     fn test_remove_duplicate_keys() {
-        let key1 = BlsPublicKey::deserialize(&[1; 48]).unwrap();
-        let key2 = BlsPublicKey::deserialize(&[2; 48]).unwrap();
+        let key1 = BlsPublicKey::test_random();
+        let key2 = BlsPublicKey::test_random();
         let keys = vec![key1.clone(), key2.clone(), key1.clone()];
 
         let unique_keys = remove_duplicate_keys(keys);

crates/common/src/pbs/error.rs

@@ -55,7 +55,7 @@ pub enum ValidationError {
     EmptyBlockhash,
 
     #[error("pubkey mismatch: expected {expected} got {got}")]
-    PubkeyMismatch { expected: BlsPublicKey, got: BlsPublicKey },
+    PubkeyMismatch { expected: Box<BlsPublicKey>, got: Box<BlsPublicKey> },
 
     #[error("parent hash mismatch: expected {expected} got {got}")]
     ParentHashMismatch { expected: B256, got: B256 },

crates/common/src/signer/schemes/ecdsa.rs

@@ -91,7 +91,7 @@ impl EcdsaSigner {
         match self {
             EcdsaSigner::Local(sk) => {
                 let domain = compute_domain(chain, COMMIT_BOOST_DOMAIN);
-                let signing_root = compute_signing_root(object_root, domain).into();
+                let signing_root = compute_signing_root(object_root, domain);
                 sk.sign_hash_sync(&signing_root).map(EcdsaSignature::from)
             }
         }

crates/common/src/utils.rs

@@ -5,6 +5,7 @@ use std::{
 
 use alloy::primitives::U256;
 use axum::http::HeaderValue;
+use lh_types::test_utils::{SeedableRng, TestRandom, XorShiftRng};
 use rand::{distr::Alphanumeric, Rng};
 use reqwest::header::HeaderMap;
 use serde::{de::DeserializeOwned, Serialize};
@@ -347,6 +348,18 @@ pub async fn wait_for_signal() -> eyre::Result<()> {
     Ok(())
 }
 
+pub trait TestRandomSeed: TestRandom {
+    fn test_random() -> Self
+    where
+        Self: Sized,
+    {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        Self::random_for_test(&mut rng)
+    }
+}
+
+impl<T: TestRandom> TestRandomSeed for T {}
+
 #[cfg(test)]
 mod test {
     use super::{create_jwt, decode_jwt, validate_jwt};

crates/pbs/src/mev_boost/get_header.rs

@@ -460,14 +460,14 @@ fn validate_signature<T: TreeHash>(
 ) -> Result<(), ValidationError> {
     if expected_relay_pubkey != received_relay_pubkey {
         return Err(ValidationError::PubkeyMismatch {
-            expected: expected_relay_pubkey.clone(),
-            got: received_relay_pubkey.clone(),
+            expected: Box::new(expected_relay_pubkey.clone()),
+            got: Box::new(received_relay_pubkey.clone()),
         });
     }
 
     if !verify_signed_message(
         chain,
-        &received_relay_pubkey,
+        received_relay_pubkey,
         &message,
         signature,
         APPLICATION_BUILDER_DOMAIN,
@@ -595,7 +595,10 @@ mod tests {
 
         assert_eq!(
             validate_signature(Chain::Holesky, &wrong_pubkey, &pubkey, &message, &wrong_signature),
-            Err(ValidationError::PubkeyMismatch { expected: wrong_pubkey, got: pubkey.clone() })
+            Err(ValidationError::PubkeyMismatch {
+                expected: Box::new(wrong_pubkey),
+                got: Box::new(pubkey.clone())
+            })
         );
 
         assert!(matches!(

examples/da_commit/src/main.rs

@@ -69,7 +69,7 @@ impl DaCommitService {
         let mut data = 0;
 
         loop {
-            self.send_request(data, pubkey.clone(), proxy_bls.clone(), proxy_ecdsa.clone()).await?;
+            self.send_request(data, pubkey.clone(), proxy_bls.clone(), proxy_ecdsa).await?;
             sleep(Duration::from_secs(self.config.extra.sleep_secs)).await;
             data += 1;
         }

tests/src/mock_validator.rs

@@ -46,13 +46,13 @@ impl MockValidator {
         let url = self.comm_boost.submit_block_url().unwrap();
 
         let signed_blinded_block =
-            signed_blinded_block.unwrap_or_else(|| load_test_signed_blinded_block());
+            signed_blinded_block.unwrap_or_else(load_test_signed_blinded_block);
 
         Ok(self.comm_boost.client.post(url).json(&signed_blinded_block).send().await?)
     }
 }
 
 pub fn load_test_signed_blinded_block() -> SignedBlindedBeaconBlock {
     let data_json = include_str!("signed-blinded-beacon-block-electra-2.json");
-    serde_json::from_str(&data_json).unwrap()
+    serde_json::from_str(data_json).unwrap()
 }