Move from [u8; 32] to B256 everywhere

crates/common/src/commit/request.rs

@@ -6,7 +6,7 @@ use std::{
 
 use alloy::{
     hex,
-    primitives::{Address, B256},
+    primitives::{aliases::B32, Address, B256},
     rpc::types::beacon::BlsSignature,
 };
 use derive_more::derive::From;
@@ -63,7 +63,7 @@ impl<T: ProxyId> SignedProxyDelegation<T> {
             &self.message,
             &self.signature,
             None,
-            COMMIT_BOOST_DOMAIN,
+            &B32::from(COMMIT_BOOST_DOMAIN),
         )
     }
 }

crates/common/src/pbs/types/beacon_block.rs

@@ -99,7 +99,7 @@ mod tests {
     // this is from mev-boost test data
     fn test_signed_blinded_block_fb_electra() {
         let data = include_str!("testdata/signed-blinded-beacon-block-electra.json");
-        let block = test_encode_decode::<SignedBlindedBeaconBlock>(&data);
+        let block = test_encode_decode::<SignedBlindedBeaconBlock>(data);
         assert!(matches!(block.message, BlindedBeaconBlock::Electra(_)));
     }
 
@@ -166,7 +166,7 @@ mod tests {
     // this is dummy data generated with https://github.com/attestantio/go-eth2-client
     fn test_signed_blinded_block_ssz() {
         let data_json = include_str!("testdata/signed-blinded-beacon-block-electra-2.json");
-        let block_json = test_encode_decode::<SignedBlindedBeaconBlock>(&data_json);
+        let block_json = test_encode_decode::<SignedBlindedBeaconBlock>(data_json);
         assert!(matches!(block_json.message, BlindedBeaconBlock::Electra(_)));
 
         let data_ssz = include_bytes!("testdata/signed-blinded-beacon-block-electra-2.ssz");
@@ -181,7 +181,7 @@ mod tests {
     // this is dummy data generated with https://github.com/attestantio/go-builder-client
     fn test_execution_payload_block_ssz() {
         let data_json = include_str!("testdata/execution-payload-electra.json");
-        let block_json = test_encode_decode::<PayloadAndBlobsElectra>(&data_json);
+        let block_json = test_encode_decode::<PayloadAndBlobsElectra>(data_json);
 
         let data_ssz = include_bytes!("testdata/execution-payload-electra.ssz");
         let data_ssz = alloy::primitives::hex::decode(data_ssz).unwrap();

crates/common/src/pbs/types/execution_payload.rs

@@ -129,7 +129,7 @@ mod tests {
             "excess_blob_gas": "95158272"
         }"#;
 
-        let parsed = test_encode_decode::<ExecutionPayloadHeader<ElectraSpec>>(&data);
+        let parsed = test_encode_decode::<ExecutionPayloadHeader<ElectraSpec>>(data);
 
         assert_eq!(
             parsed.parent_hash,

crates/common/src/pbs/types/get_header.rs

@@ -94,7 +94,7 @@ pub struct ExecutionPayloadHeaderMessageElectra {
 
 #[cfg(test)]
 mod tests {
-    use alloy::primitives::U256;
+    use alloy::primitives::{aliases::B32, U256};
 
     use super::*;
     use crate::{
@@ -177,7 +177,7 @@ mod tests {
             &parsed.message,
             &parsed.signature,
             None,
-            APPLICATION_BUILDER_DOMAIN
+            &B32::from(APPLICATION_BUILDER_DOMAIN)
         )
         .is_ok())
     }

crates/common/src/signature.rs

@@ -1,5 +1,5 @@
 use alloy::{
-    primitives::{Address, B256},
+    primitives::{aliases::B32, Address, B256},
     rpc::types::beacon::{constants::BLS_DST_SIG, BlsPublicKey, BlsSignature},
 };
 use tree_hash::TreeHash;
@@ -17,49 +17,52 @@ pub fn sign_message(secret_key: &BlsSecretKey, msg: &[u8]) -> BlsSignature {
     BlsSignature::from_slice(&signature)
 }
 
-pub fn compute_signing_root<T: TreeHash>(signing_data: &T) -> [u8; 32] {
-    signing_data.tree_hash_root().0
+pub fn compute_tree_hash_root<T: TreeHash>(signing_data: &T) -> B256 {
+    signing_data.tree_hash_root()
 }
 
 pub fn compute_prop_commit_signing_root(
     chain: Chain,
-    object_root: [u8; 32],
-    module_signing_id: Option<[u8; 32]>,
-    domain_mask: [u8; 4],
-) -> [u8; 32] {
+    object_root: &B256,
+    module_signing_id: Option<&B256>,
+    domain_mask: &B32,
+) -> B256 {
     let domain = compute_domain(chain, domain_mask);
     match module_signing_id {
-        Some(id) => compute_signing_root(&types::SigningData {
-            object_root: compute_signing_root(&types::PropCommitSigningInfo {
-                data: object_root,
-                module_signing_id: id,
+        Some(id) => compute_tree_hash_root(&types::SigningData {
+            object_root: compute_tree_hash_root(&types::PropCommitSigningInfo {
+                data: *object_root,
+                module_signing_id: *id,
             }),
             signing_domain: domain,
         }),
-        None => compute_signing_root(&types::SigningData { object_root, signing_domain: domain }),
+        None => compute_tree_hash_root(&types::SigningData {
+            object_root: *object_root,
+            signing_domain: domain,
+        }),
     }
 }
 
 // NOTE: this currently works only for builder domain signatures and
 // verifications
 // ref: https://github.com/ralexstokes/ethereum-consensus/blob/cf3c404043230559660810bc0c9d6d5a8498d819/ethereum-consensus/src/builder/mod.rs#L26-L29
-pub fn compute_domain(chain: Chain, domain_mask: [u8; 4]) -> [u8; 32] {
+pub fn compute_domain(chain: Chain, domain_mask: &B32) -> B256 {
     #[derive(Debug, TreeHash)]
     struct ForkData {
         fork_version: [u8; 4],
         genesis_validators_root: [u8; 32],
     }
 
     let mut domain = [0u8; 32];
-    domain[..4].copy_from_slice(&domain_mask);
+    domain[..4].copy_from_slice(&domain_mask.0);
 
     let fork_version = chain.genesis_fork_version();
     let fd = ForkData { fork_version, genesis_validators_root: GENESIS_VALIDATORS_ROOT };
     let fork_data_root = fd.tree_hash_root();
 
     domain[4..].copy_from_slice(&fork_data_root[..28]);
 
-    domain
+    B256::from(domain)
 }
 
 pub fn verify_signed_message<T: TreeHash>(
@@ -68,15 +71,15 @@ pub fn verify_signed_message<T: TreeHash>(
     msg: &T,
     signature: &BlsSignature,
     module_signing_id: Option<&B256>,
-    domain_mask: [u8; 4],
+    domain_mask: &B32,
 ) -> Result<(), BlstErrorWrapper> {
     let signing_root = compute_prop_commit_signing_root(
         chain,
-        compute_signing_root(msg),
-        module_signing_id.map(|id| id.0),
+        &compute_tree_hash_root(msg),
+        module_signing_id,
         domain_mask,
     );
-    verify_bls_signature(pubkey, &signing_root, signature)
+    verify_bls_signature(pubkey, signing_root.as_slice(), signature)
 }
 
 /// Signs a message with the Beacon builder domain.
@@ -85,36 +88,36 @@ pub fn sign_builder_message(
     secret_key: &BlsSecretKey,
     msg: &impl TreeHash,
 ) -> BlsSignature {
-    sign_builder_root(chain, secret_key, msg.tree_hash_root().0)
+    sign_builder_root(chain, secret_key, &msg.tree_hash_root())
 }
 
 pub fn sign_builder_root(
     chain: Chain,
     secret_key: &BlsSecretKey,
-    object_root: [u8; 32],
+    object_root: &B256,
 ) -> BlsSignature {
     let domain = chain.builder_domain();
     let signing_data = types::SigningData {
-        object_root: compute_signing_root(&object_root),
+        object_root: compute_tree_hash_root(object_root),
         signing_domain: domain,
     };
-    let signing_root = compute_signing_root(&signing_data);
-    sign_message(secret_key, &signing_root)
+    let signing_root = compute_tree_hash_root(&signing_data);
+    sign_message(secret_key, signing_root.as_slice())
 }
 
 pub fn sign_commit_boost_root(
     chain: Chain,
     secret_key: &BlsSecretKey,
-    object_root: [u8; 32],
-    module_signing_id: Option<[u8; 32]>,
+    object_root: &B256,
+    module_signing_id: Option<&B256>,
 ) -> BlsSignature {
     let signing_root = compute_prop_commit_signing_root(
         chain,
         object_root,
         module_signing_id,
-        COMMIT_BOOST_DOMAIN,
+        &B32::from(COMMIT_BOOST_DOMAIN),
     );
-    sign_message(secret_key, &signing_root)
+    sign_message(secret_key, signing_root.as_slice())
 }
 
 // ==============================
@@ -128,18 +131,18 @@ pub fn verify_proposer_commitment_signature_bls(
     pubkey: &BlsPublicKey,
     msg: &impl TreeHash,
     signature: &BlsSignature,
-    module_signing_id: B256,
+    module_signing_id: &B256,
 ) -> Result<(), BlstErrorWrapper> {
-    let object_root = msg.tree_hash_root().0;
-    let domain = compute_domain(chain, COMMIT_BOOST_DOMAIN);
-    let signing_root = compute_signing_root(&types::SigningData {
-        object_root: compute_signing_root(&types::PropCommitSigningInfo {
+    let object_root = msg.tree_hash_root();
+    let domain = compute_domain(chain, &B32::from(COMMIT_BOOST_DOMAIN));
+    let signing_root = compute_tree_hash_root(&types::SigningData {
+        object_root: compute_tree_hash_root(&types::PropCommitSigningInfo {
             data: object_root,
             module_signing_id: *module_signing_id,
         }),
         signing_domain: domain,
     });
-    verify_bls_signature(pubkey, &signing_root, signature)
+    verify_bls_signature(pubkey, signing_root.as_slice(), signature)
 }
 
 /// Verifies that a proposer commitment signature was generated by the given
@@ -149,12 +152,12 @@ pub fn verify_proposer_commitment_signature_ecdsa(
     address: &Address,
     msg: &impl TreeHash,
     signature: &EcdsaSignature,
-    module_signing_id: B256,
+    module_signing_id: &B256,
 ) -> Result<(), eyre::Report> {
-    let object_root = msg.tree_hash_root().0;
-    let domain = compute_domain(chain, COMMIT_BOOST_DOMAIN);
-    let signing_root = compute_signing_root(&types::SigningData {
-        object_root: compute_signing_root(&types::PropCommitSigningInfo {
+    let object_root = msg.tree_hash_root();
+    let domain = compute_domain(chain, &B32::from(COMMIT_BOOST_DOMAIN));
+    let signing_root = compute_tree_hash_root(&types::SigningData {
+        object_root: compute_tree_hash_root(&types::PropCommitSigningInfo {
             data: object_root,
             module_signing_id: *module_signing_id,
         }),
@@ -170,30 +173,18 @@ pub fn verify_proposer_commitment_signature_ecdsa(
 #[cfg(test)]
 mod tests {
 
+    use alloy::primitives::aliases::B32;
+
     use super::compute_domain;
     use crate::{constants::APPLICATION_BUILDER_DOMAIN, types::Chain};
 
     #[test]
     fn test_builder_domains() {
-        assert_eq!(
-            compute_domain(Chain::Mainnet, APPLICATION_BUILDER_DOMAIN),
-            Chain::Mainnet.builder_domain()
-        );
-        assert_eq!(
-            compute_domain(Chain::Holesky, APPLICATION_BUILDER_DOMAIN),
-            Chain::Holesky.builder_domain()
-        );
-        assert_eq!(
-            compute_domain(Chain::Sepolia, APPLICATION_BUILDER_DOMAIN),
-            Chain::Sepolia.builder_domain()
-        );
-        assert_eq!(
-            compute_domain(Chain::Helder, APPLICATION_BUILDER_DOMAIN),
-            Chain::Helder.builder_domain()
-        );
-        assert_eq!(
-            compute_domain(Chain::Hoodi, APPLICATION_BUILDER_DOMAIN),
-            Chain::Hoodi.builder_domain()
-        );
+        let domain = &B32::from(APPLICATION_BUILDER_DOMAIN);
+        assert_eq!(compute_domain(Chain::Mainnet, domain), Chain::Mainnet.builder_domain());
+        assert_eq!(compute_domain(Chain::Holesky, domain), Chain::Holesky.builder_domain());
+        assert_eq!(compute_domain(Chain::Sepolia, domain), Chain::Sepolia.builder_domain());
+        assert_eq!(compute_domain(Chain::Helder, domain), Chain::Helder.builder_domain());
+        assert_eq!(compute_domain(Chain::Hoodi, domain), Chain::Hoodi.builder_domain());
     }
 }

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

@@ -1,5 +1,5 @@
-use alloy::rpc::types::beacon::constants::BLS_DST_SIG;
 pub use alloy::rpc::types::beacon::BlsSignature;
+use alloy::{primitives::B256, rpc::types::beacon::constants::BLS_DST_SIG};
 use blst::BLST_ERROR;
 use tree_hash::TreeHash;
 
@@ -32,17 +32,17 @@ impl BlsSigner {
         }
     }
 
-    pub fn secret(&self) -> [u8; 32] {
+    pub fn secret(&self) -> B256 {
         match self {
-            BlsSigner::Local(secret) => secret.clone().to_bytes(),
+            BlsSigner::Local(secret) => B256::from(secret.clone().to_bytes()),
         }
     }
 
     pub async fn sign(
         &self,
         chain: Chain,
-        object_root: [u8; 32],
-        module_signing_id: Option<[u8; 32]>,
+        object_root: &B256,
+        module_signing_id: Option<&B256>,
     ) -> BlsSignature {
         match self {
             BlsSigner::Local(sk) => {
@@ -55,9 +55,9 @@ impl BlsSigner {
         &self,
         chain: Chain,
         msg: &impl TreeHash,
-        module_signing_id: Option<[u8; 32]>,
+        module_signing_id: Option<&B256>,
     ) -> BlsSignature {
-        self.sign(chain, msg.tree_hash_root().0, module_signing_id).await
+        self.sign(chain, &msg.tree_hash_root(), module_signing_id).await
     }
 }