From 71f70a12351592de4e5a1864ac856aff3c408180 Mon Sep 17 00:00:00 2001 From: Joe Clapis Date: Mon, 28 Jul 2025 15:34:44 -0400 Subject: [PATCH 1/2] Moved from [u8; 32] to B256 everywhere --- crates/common/src/commit/request.rs | 4 +- crates/common/src/pbs/types/beacon_block.rs | 6 +- .../common/src/pbs/types/execution_payload.rs | 2 +- crates/common/src/pbs/types/get_header.rs | 4 +- crates/common/src/signature.rs | 95 ++++++++---------- crates/common/src/signer/schemes/bls.rs | 14 +-- crates/common/src/signer/schemes/ecdsa.rs | 44 +++++---- crates/common/src/signer/store.rs | 8 +- crates/common/src/types.rs | 36 +++---- crates/common/src/utils.rs | 2 +- crates/pbs/src/mev_boost/get_header.rs | 4 +- crates/signer/src/manager/dirk.rs | 25 +++-- crates/signer/src/manager/local.rs | 98 ++++++++----------- examples/da_commit/src/main.rs | 6 +- tests/src/mock_relay.rs | 4 +- tests/tests/payloads.rs | 18 ++-- tests/tests/pbs_get_header.rs | 6 +- tests/tests/pbs_get_status.rs | 4 +- tests/tests/pbs_mux.rs | 2 +- tests/tests/pbs_post_blinded_blocks.rs | 4 +- 20 files changed, 182 insertions(+), 204 deletions(-) diff --git a/crates/common/src/commit/request.rs b/crates/common/src/commit/request.rs index d9286868..c5f71387 100644 --- a/crates/common/src/commit/request.rs +++ b/crates/common/src/commit/request.rs @@ -5,7 +5,7 @@ use std::{ use alloy::{ hex, - primitives::{Address, B256}, + primitives::{aliases::B32, Address, B256}, rpc::types::beacon::BlsSignature, }; use derive_more::derive::From; @@ -58,7 +58,7 @@ impl SignedProxyDelegation { &self.message, &self.signature, None, - COMMIT_BOOST_DOMAIN, + &B32::from(COMMIT_BOOST_DOMAIN), ) } } diff --git a/crates/common/src/pbs/types/beacon_block.rs b/crates/common/src/pbs/types/beacon_block.rs index f377123a..485876e9 100644 --- a/crates/common/src/pbs/types/beacon_block.rs +++ b/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::(&data); + let block = test_encode_decode::(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::(&data_json); + let block_json = test_encode_decode::(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::(&data_json); + let block_json = test_encode_decode::(data_json); let data_ssz = include_bytes!("testdata/execution-payload-electra.ssz"); let data_ssz = alloy::primitives::hex::decode(data_ssz).unwrap(); diff --git a/crates/common/src/pbs/types/execution_payload.rs b/crates/common/src/pbs/types/execution_payload.rs index f851e8da..fcf4cdda 100644 --- a/crates/common/src/pbs/types/execution_payload.rs +++ b/crates/common/src/pbs/types/execution_payload.rs @@ -129,7 +129,7 @@ mod tests { "excess_blob_gas": "95158272" }"#; - let parsed = test_encode_decode::>(&data); + let parsed = test_encode_decode::>(data); assert_eq!( parsed.parent_hash, diff --git a/crates/common/src/pbs/types/get_header.rs b/crates/common/src/pbs/types/get_header.rs index 69437f45..c5e40a21 100644 --- a/crates/common/src/pbs/types/get_header.rs +++ b/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()) } diff --git a/crates/common/src/signature.rs b/crates/common/src/signature.rs index 19fade8f..d7ab8d2f 100644 --- a/crates/common/src/signature.rs +++ b/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,33 +17,36 @@ pub fn sign_message(secret_key: &BlsSecretKey, msg: &[u8]) -> BlsSignature { BlsSignature::from_slice(&signature) } -pub fn compute_signing_root(signing_data: &T) -> [u8; 32] { - signing_data.tree_hash_root().0 +pub fn compute_signing_root(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, + data: *object_root, + module_signing_id: *id, }), signing_domain: domain, }), - None => compute_signing_root(&types::SigningData { object_root, signing_domain: domain }), + None => compute_signing_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], @@ -51,7 +54,7 @@ pub fn compute_domain(chain: Chain, domain_mask: [u8; 4]) -> [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 }; @@ -59,7 +62,7 @@ pub fn compute_domain(chain: Chain, domain_mask: [u8; 4]) -> [u8; 32] { domain[4..].copy_from_slice(&fork_data_root[..28]); - domain + B256::from(domain) } pub fn verify_signed_message( @@ -68,15 +71,15 @@ pub fn verify_signed_message( 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_signing_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_signing_root(object_root), signing_domain: domain, }; let signing_root = compute_signing_root(&signing_data); - sign_message(secret_key, &signing_root) + 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,10 +131,10 @@ 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 object_root = msg.tree_hash_root(); + let domain = compute_domain(chain, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_root = compute_signing_root(&types::SigningData { object_root: compute_signing_root(&types::PropCommitSigningInfo { data: object_root, @@ -139,7 +142,7 @@ pub fn verify_proposer_commitment_signature_bls( }), 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,10 +152,10 @@ 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 object_root = msg.tree_hash_root(); + let domain = compute_domain(chain, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_root = compute_signing_root(&types::SigningData { object_root: compute_signing_root(&types::PropCommitSigningInfo { data: object_root, @@ -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()); } } diff --git a/crates/common/src/signer/schemes/bls.rs b/crates/common/src/signer/schemes/bls.rs index f3a511e7..15367f36 100644 --- a/crates/common/src/signer/schemes/bls.rs +++ b/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 } } diff --git a/crates/common/src/signer/schemes/ecdsa.rs b/crates/common/src/signer/schemes/ecdsa.rs index 73bf7272..e5b25663 100644 --- a/crates/common/src/signer/schemes/ecdsa.rs +++ b/crates/common/src/signer/schemes/ecdsa.rs @@ -1,7 +1,7 @@ use std::{ops::Deref, str::FromStr}; use alloy::{ - primitives::{Address, PrimitiveSignature}, + primitives::{aliases::B32, Address, PrimitiveSignature, B256}, signers::{local::PrivateKeySigner, SignerSync}, }; use eyre::ensure; @@ -86,27 +86,29 @@ impl EcdsaSigner { 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>, ) -> Result { match self { EcdsaSigner::Local(sk) => { - let domain = compute_domain(chain, COMMIT_BOOST_DOMAIN); + let domain = compute_domain(chain, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_root = match module_signing_id { Some(id) => { let signing_data = types::SigningData { object_root: compute_signing_root(&types::PropCommitSigningInfo { - data: object_root, - module_signing_id: id, + data: *object_root, + module_signing_id: *id, }), signing_domain: domain, }; - compute_signing_root(&signing_data).into() + compute_signing_root(&signing_data) } None => { - let signing_data = - types::SigningData { object_root, signing_domain: domain }; - compute_signing_root(&signing_data).into() + let signing_data = types::SigningData { + object_root: *object_root, + signing_domain: domain, + }; + compute_signing_root(&signing_data) } }; sk.sign_hash_sync(&signing_root).map(EcdsaSignature::from) @@ -117,18 +119,18 @@ impl EcdsaSigner { &self, chain: Chain, msg: &impl TreeHash, - module_signing_id: Option<[u8; 32]>, + module_signing_id: Option<&B256>, ) -> Result { - self.sign(chain, msg.tree_hash_root().0, module_signing_id).await + self.sign(chain, &msg.tree_hash_root(), module_signing_id).await } } pub fn verify_ecdsa_signature( address: &Address, - msg: &[u8; 32], + msg: &B256, signature: &EcdsaSignature, ) -> eyre::Result<()> { - let recovered = signature.recover_address_from_prehash(msg.into())?; + let recovered = signature.recover_address_from_prehash(msg)?; ensure!(recovered == *address, "invalid signature"); Ok(()) } @@ -145,10 +147,10 @@ mod test { let pk = bytes!("88bcd6672d95bcba0d52a3146494ed4d37675af4ed2206905eb161aa99a6c0d1"); let signer = EcdsaSigner::new_from_bytes(&pk).unwrap(); - let object_root = [1; 32]; - let signature = signer.sign(Chain::Holesky, object_root, None).await.unwrap(); + let object_root = B256::from([1; 32]); + let signature = signer.sign(Chain::Holesky, &object_root, None).await.unwrap(); - let domain = compute_domain(Chain::Holesky, COMMIT_BOOST_DOMAIN); + let domain = compute_domain(Chain::Holesky, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_data = types::SigningData { object_root, signing_domain: domain }; let msg = compute_signing_root(&signing_data); @@ -164,12 +166,12 @@ mod test { let pk = bytes!("88bcd6672d95bcba0d52a3146494ed4d37675af4ed2206905eb161aa99a6c0d1"); let signer = EcdsaSigner::new_from_bytes(&pk).unwrap(); - let object_root = [1; 32]; - let module_signing_id = [2; 32]; + let object_root = B256::from([1; 32]); + let module_signing_id = B256::from([2; 32]); let signature = - signer.sign(Chain::Hoodi, object_root, Some(module_signing_id)).await.unwrap(); + signer.sign(Chain::Hoodi, &object_root, Some(&module_signing_id)).await.unwrap(); - let domain = compute_domain(Chain::Hoodi, COMMIT_BOOST_DOMAIN); + let domain = compute_domain(Chain::Hoodi, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_data = types::SigningData { object_root: compute_signing_root(&types::PropCommitSigningInfo { data: object_root, diff --git a/crates/common/src/signer/store.rs b/crates/common/src/signer/store.rs index 9e251dd9..834f4bd8 100644 --- a/crates/common/src/signer/store.rs +++ b/crates/common/src/signer/store.rs @@ -533,7 +533,7 @@ mod test { proxy: proxy_signer.pubkey(), }; let signature = - consensus_signer.sign(Chain::Mainnet, message.tree_hash_root().0, None).await; + consensus_signer.sign(Chain::Mainnet, &message.tree_hash_root(), None).await; let delegation = SignedProxyDelegationBls { signature, message }; let proxy_signer = BlsProxySigner { signer: proxy_signer, delegation }; @@ -543,12 +543,12 @@ mod test { .join(consensus_signer.pubkey().to_string()) .join("TEST_MODULE") .join("bls") - .join(format!("{}.json", proxy_signer.pubkey().to_string())); + .join(format!("{}.json", proxy_signer.pubkey())); let sig_path = keys_path .join(consensus_signer.pubkey().to_string()) .join("TEST_MODULE") .join("bls") - .join(format!("{}.sig", proxy_signer.pubkey().to_string())); + .join(format!("{}.sig", proxy_signer.pubkey())); let pass_path = secrets_path .join(consensus_signer.pubkey().to_string()) .join("TEST_MODULE") @@ -647,7 +647,7 @@ mod test { proxy: proxy_signer.pubkey(), }; let signature = - consensus_signer.sign(Chain::Mainnet, message.tree_hash_root().0, None).await; + consensus_signer.sign(Chain::Mainnet, &message.tree_hash_root(), None).await; let delegation = SignedProxyDelegationBls { signature, message }; let proxy_signer = BlsProxySigner { signer: proxy_signer, delegation }; diff --git a/crates/common/src/types.rs b/crates/common/src/types.rs index a9c8ebfd..11009e24 100644 --- a/crates/common/src/types.rs +++ b/crates/common/src/types.rs @@ -1,6 +1,6 @@ use std::path::PathBuf; -use alloy::primitives::{hex, Bytes}; +use alloy::primitives::{aliases::B32, hex, Bytes, B256}; use derive_more::{Deref, Display, From, Into}; use eyre::{bail, Context}; use serde::{Deserialize, Serialize}; @@ -79,14 +79,14 @@ impl Chain { } } - pub fn builder_domain(&self) -> [u8; 32] { + pub fn builder_domain(&self) -> B256 { match self { Chain::Mainnet => KnownChain::Mainnet.builder_domain(), Chain::Holesky => KnownChain::Holesky.builder_domain(), Chain::Sepolia => KnownChain::Sepolia.builder_domain(), Chain::Helder => KnownChain::Helder.builder_domain(), Chain::Hoodi => KnownChain::Hoodi.builder_domain(), - Chain::Custom { .. } => compute_domain(*self, APPLICATION_BUILDER_DOMAIN), + Chain::Custom { .. } => compute_domain(*self, &B32::from(APPLICATION_BUILDER_DOMAIN)), } } @@ -150,28 +150,28 @@ impl KnownChain { } } - pub fn builder_domain(&self) -> [u8; 32] { + pub fn builder_domain(&self) -> B256 { match self { - KnownChain::Mainnet => [ + KnownChain::Mainnet => B256::from([ 0, 0, 0, 1, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169, - ], - KnownChain::Holesky => [ + ]), + KnownChain::Holesky => B256::from([ 0, 0, 0, 1, 91, 131, 162, 55, 89, 197, 96, 178, 208, 198, 69, 118, 225, 220, 252, 52, 234, 148, 196, 152, 143, 62, 13, 159, 119, 240, 83, 135, - ], - KnownChain::Sepolia => [ + ]), + KnownChain::Sepolia => B256::from([ 0, 0, 0, 1, 211, 1, 7, 120, 205, 8, 238, 81, 75, 8, 254, 103, 182, 197, 3, 181, 16, 152, 122, 76, 228, 63, 66, 48, 109, 151, 198, 124, - ], - KnownChain::Helder => [ + ]), + KnownChain::Helder => B256::from([ 0, 0, 0, 1, 148, 196, 26, 244, 132, 255, 247, 150, 73, 105, 224, 189, 217, 34, 248, 45, 255, 15, 75, 232, 122, 96, 208, 102, 76, 201, 209, 255, - ], - KnownChain::Hoodi => [ + ]), + KnownChain::Hoodi => B256::from([ 0, 0, 0, 1, 113, 145, 3, 81, 30, 250, 79, 19, 98, 255, 42, 80, 153, 108, 204, 243, 41, 204, 132, 203, 65, 12, 94, 92, 125, 53, 29, 3, - ], + ]), } } @@ -287,8 +287,8 @@ impl<'de> Deserialize<'de> for Chain { /// Structure for signatures used in Beacon chain operations #[derive(Default, Debug, TreeHash)] pub struct SigningData { - pub object_root: [u8; 32], - pub signing_domain: [u8; 32], + pub object_root: B256, + pub signing_domain: B256, } /// Structure for signatures used for proposer commitments in Commit Boost. @@ -296,8 +296,8 @@ pub struct SigningData { /// SigningData for signatures. #[derive(Default, Debug, TreeHash)] pub struct PropCommitSigningInfo { - pub data: [u8; 32], - pub module_signing_id: [u8; 32], + pub data: B256, + pub module_signing_id: B256, } /// Returns seconds_per_slot and genesis_fork_version from a spec, such as diff --git a/crates/common/src/utils.rs b/crates/common/src/utils.rs index ccaf8888..6d39465c 100644 --- a/crates/common/src/utils.rs +++ b/crates/common/src/utils.rs @@ -457,7 +457,7 @@ mod test { let jwt = create_jwt(&ModuleId("DA_COMMIT".to_string()), "secret").unwrap(); let module_id = decode_jwt(jwt.clone()).unwrap(); assert_eq!(module_id, ModuleId("DA_COMMIT".to_string())); - let response = validate_jwt(jwt, "secret".as_ref()); + let response = validate_jwt(jwt, "secret"); assert!(response.is_ok()); // Check expired JWT diff --git a/crates/pbs/src/mev_boost/get_header.rs b/crates/pbs/src/mev_boost/get_header.rs index ec2716d7..aa6ed6fd 100644 --- a/crates/pbs/src/mev_boost/get_header.rs +++ b/crates/pbs/src/mev_boost/get_header.rs @@ -4,7 +4,7 @@ use std::{ }; use alloy::{ - primitives::{utils::format_ether, B256, U256}, + primitives::{aliases::B32, utils::format_ether, B256, U256}, providers::Provider, rpc::types::{beacon::BlsPublicKey, Block}, }; @@ -474,7 +474,7 @@ fn validate_signature( &message, signature, None, - APPLICATION_BUILDER_DOMAIN, + &B32::from(APPLICATION_BUILDER_DOMAIN), ) .map_err(ValidationError::Sigverify)?; diff --git a/crates/signer/src/manager/dirk.rs b/crates/signer/src/manager/dirk.rs index 08c73def..c6b1cc25 100644 --- a/crates/signer/src/manager/dirk.rs +++ b/crates/signer/src/manager/dirk.rs @@ -1,6 +1,10 @@ use std::{collections::HashMap, io::Write, path::PathBuf}; -use alloy::{hex, primitives::B256, rpc::types::beacon::constants::BLS_SIGNATURE_BYTES_LEN}; +use alloy::{ + hex, + primitives::{aliases::B32, B256}, + rpc::types::beacon::constants::BLS_SIGNATURE_BYTES_LEN, +}; use blsful::inner_types::{Field, G2Affine, G2Projective, Group, Scalar}; use cb_common::{ commit::request::{ConsensusProxyMap, ProxyDelegation, SignedProxyDelegation}, @@ -192,7 +196,7 @@ impl DirkManager { pub async fn request_consensus_signature( &self, pubkey: &BlsPublicKey, - object_root: &[u8; 32], + object_root: &B256, module_signing_id: Option<&B256>, ) -> Result { match self.consensus_accounts.get(pubkey) { @@ -210,7 +214,7 @@ impl DirkManager { pub async fn request_proxy_signature( &self, pubkey: &BlsPublicKey, - object_root: &[u8; 32], + object_root: &B256, module_signing_id: Option<&B256>, ) -> Result { match self.proxy_accounts.get(pubkey) { @@ -228,15 +232,15 @@ impl DirkManager { async fn request_simple_signature( &self, account: &SimpleAccount, - object_root: &[u8; 32], + object_root: &B256, module_signing_id: Option<&B256>, ) -> Result { - let domain = compute_domain(self.chain, COMMIT_BOOST_DOMAIN); + let domain = compute_domain(self.chain, &B32::from(COMMIT_BOOST_DOMAIN)); let data = match module_signing_id { Some(id) => compute_signing_root(&types::PropCommitSigningInfo { data: *object_root, - module_signing_id: id.0, + module_signing_id: *id, }) .to_vec(), None => object_root.to_vec(), @@ -268,7 +272,7 @@ impl DirkManager { async fn request_distributed_signature( &self, account: &DistributedAccount, - object_root: &[u8; 32], + object_root: &B256, module_signing_id: Option<&B256>, ) -> Result { let mut partials = Vec::with_capacity(account.participants.len()); @@ -277,7 +281,7 @@ impl DirkManager { let data = match module_signing_id { Some(id) => compute_signing_root(&types::PropCommitSigningInfo { data: *object_root, - module_signing_id: id.0, + module_signing_id: *id, }) .to_vec(), None => object_root.to_vec(), @@ -289,7 +293,8 @@ impl DirkManager { SignerClient::new(channel.clone()) .sign(SignRequest { data: data_copy, - domain: compute_domain(self.chain, COMMIT_BOOST_DOMAIN).to_vec(), + domain: compute_domain(self.chain, &B32::from(COMMIT_BOOST_DOMAIN)) + .to_vec(), id: Some(sign_request::Id::Account(account.name.clone())), }) .map(|res| (res, *id)) @@ -359,7 +364,7 @@ impl DirkManager { let message = ProxyDelegation { delegator: consensus, proxy: proxy_account.inner.public_key() }; let delegation_signature = - self.request_consensus_signature(&consensus, &message.tree_hash_root().0, None).await?; + self.request_consensus_signature(&consensus, &message.tree_hash_root(), None).await?; let delegation = SignedProxyDelegation { message, signature: delegation_signature }; diff --git a/crates/signer/src/manager/local.rs b/crates/signer/src/manager/local.rs index a242a754..c120c05a 100644 --- a/crates/signer/src/manager/local.rs +++ b/crates/signer/src/manager/local.rs @@ -98,7 +98,7 @@ impl LocalSigningManager { let proxy_pubkey = signer.pubkey(); let message = ProxyDelegationBls { delegator, proxy: proxy_pubkey }; - let signature = self.sign_consensus(&delegator, &message.tree_hash_root().0, None).await?; + let signature = self.sign_consensus(&delegator, &message.tree_hash_root(), None).await?; let delegation = SignedProxyDelegationBls { signature, message }; let proxy_signer = BlsProxySigner { signer, delegation }; @@ -117,7 +117,7 @@ impl LocalSigningManager { let proxy_address = signer.address(); let message = ProxyDelegationEcdsa { delegator, proxy: proxy_address }; - let signature = self.sign_consensus(&delegator, &message.tree_hash_root().0, None).await?; + let signature = self.sign_consensus(&delegator, &message.tree_hash_root(), None).await?; let delegation = SignedProxyDelegationEcdsa { signature, message }; let proxy_signer = EcdsaProxySigner { signer, delegation }; @@ -132,7 +132,7 @@ impl LocalSigningManager { pub async fn sign_consensus( &self, pubkey: &BlsPublicKey, - object_root: &[u8; 32], + object_root: &B256, module_signing_id: Option<&B256>, ) -> Result { let signer = self @@ -140,8 +140,8 @@ impl LocalSigningManager { .get(pubkey) .ok_or(SignerModuleError::UnknownConsensusSigner(pubkey.to_vec()))?; let signature = match module_signing_id { - Some(id) => signer.sign(self.chain, *object_root, Some(id.0)).await, - None => signer.sign(self.chain, *object_root, None).await, + Some(id) => signer.sign(self.chain, object_root, Some(id)).await, + None => signer.sign(self.chain, object_root, None).await, }; Ok(signature) @@ -150,7 +150,7 @@ impl LocalSigningManager { pub async fn sign_proxy_bls( &self, pubkey: &BlsPublicKey, - object_root: &[u8; 32], + object_root: &B256, module_signing_id: Option<&B256>, ) -> Result { let bls_proxy = self @@ -159,8 +159,8 @@ impl LocalSigningManager { .get(pubkey) .ok_or(SignerModuleError::UnknownProxySigner(pubkey.to_vec()))?; let signature = match module_signing_id { - Some(id) => bls_proxy.sign(self.chain, *object_root, Some(id.0)).await, - None => bls_proxy.sign(self.chain, *object_root, None).await, + Some(id) => bls_proxy.sign(self.chain, object_root, Some(id)).await, + None => bls_proxy.sign(self.chain, object_root, None).await, }; Ok(signature) } @@ -168,7 +168,7 @@ impl LocalSigningManager { pub async fn sign_proxy_ecdsa( &self, address: &Address, - object_root: &[u8; 32], + object_root: &B256, module_signing_id: Option<&B256>, ) -> Result { let ecdsa_proxy = self @@ -177,8 +177,8 @@ impl LocalSigningManager { .get(address) .ok_or(SignerModuleError::UnknownProxySigner(address.to_vec()))?; let signature = match module_signing_id { - Some(id) => ecdsa_proxy.sign(self.chain, *object_root, Some(id.0)).await?, - None => ecdsa_proxy.sign(self.chain, *object_root, None).await?, + Some(id) => ecdsa_proxy.sign(self.chain, object_root, Some(id)).await?, + None => ecdsa_proxy.sign(self.chain, object_root, None).await?, }; Ok(signature) } @@ -303,6 +303,7 @@ mod tests { } mod test_bls { + use alloy::primitives::aliases::B32; use cb_common::{ constants::COMMIT_BOOST_DOMAIN, signature::compute_domain, signer::verify_bls_signature, types, @@ -318,31 +319,29 @@ mod tests { let module_signing_id = B256::random(); let sig = signing_manager - .sign_consensus( - &consensus_pk.try_into().unwrap(), - &data_root, - Some(&module_signing_id), - ) + .sign_consensus(&consensus_pk, &data_root, Some(&module_signing_id)) .await .unwrap(); // Verify signature - let domain = compute_domain(CHAIN, COMMIT_BOOST_DOMAIN); + let domain = compute_domain(CHAIN, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_root = compute_signing_root(&types::SigningData { object_root: compute_signing_root(&types::PropCommitSigningInfo { - data: data_root.tree_hash_root().0, - module_signing_id: module_signing_id.0, + data: data_root.tree_hash_root(), + module_signing_id, }), signing_domain: domain, }); - let validation_result = verify_bls_signature(&consensus_pk, &signing_root, &sig); + let validation_result = + verify_bls_signature(&consensus_pk, signing_root.as_slice(), &sig); assert!(validation_result.is_ok(), "Keypair must produce valid signatures of messages.") } } mod test_proxy_bls { + use alloy::primitives::aliases::B32; use cb_common::{ constants::COMMIT_BOOST_DOMAIN, signature::compute_domain, signer::verify_bls_signature, types, @@ -354,10 +353,8 @@ mod tests { async fn test_proxy_key_is_valid_proxy_for_consensus_key() { let (mut signing_manager, consensus_pk) = init_signing_manager(); - let signed_delegation = signing_manager - .create_proxy_bls(MODULE_ID.clone(), consensus_pk.clone()) - .await - .unwrap(); + let signed_delegation = + signing_manager.create_proxy_bls(MODULE_ID.clone(), consensus_pk).await.unwrap(); let validation_result = signed_delegation.validate(CHAIN); @@ -377,10 +374,8 @@ mod tests { async fn test_tampered_proxy_key_is_invalid() { let (mut signing_manager, consensus_pk) = init_signing_manager(); - let mut signed_delegation = signing_manager - .create_proxy_bls(MODULE_ID.clone(), consensus_pk.clone()) - .await - .unwrap(); + let mut signed_delegation = + signing_manager.create_proxy_bls(MODULE_ID.clone(), consensus_pk).await.unwrap(); let m = &mut signed_delegation.signature.0[0]; (*m, _) = m.overflowing_add(1); @@ -394,31 +389,29 @@ mod tests { async fn test_proxy_key_signs_message() { let (mut signing_manager, consensus_pk) = init_signing_manager(); - let signed_delegation = signing_manager - .create_proxy_bls(MODULE_ID.clone(), consensus_pk.clone()) - .await - .unwrap(); + let signed_delegation = + signing_manager.create_proxy_bls(MODULE_ID.clone(), consensus_pk).await.unwrap(); let proxy_pk = signed_delegation.message.proxy; let data_root = B256::random(); let module_signing_id = B256::random(); let sig = signing_manager - .sign_proxy_bls(&proxy_pk.try_into().unwrap(), &data_root, Some(&module_signing_id)) + .sign_proxy_bls(&proxy_pk, &data_root, Some(&module_signing_id)) .await .unwrap(); // Verify signature - let domain = compute_domain(CHAIN, COMMIT_BOOST_DOMAIN); + let domain = compute_domain(CHAIN, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_root = compute_signing_root(&types::SigningData { object_root: compute_signing_root(&types::PropCommitSigningInfo { - data: data_root.tree_hash_root().0, - module_signing_id: module_signing_id.0, + data: data_root.tree_hash_root(), + module_signing_id, }), signing_domain: domain, }); - let validation_result = verify_bls_signature(&proxy_pk, &signing_root, &sig); + let validation_result = verify_bls_signature(&proxy_pk, signing_root.as_slice(), &sig); assert!( validation_result.is_ok(), @@ -428,6 +421,7 @@ mod tests { } mod test_proxy_ecdsa { + use alloy::primitives::aliases::B32; use cb_common::{ constants::COMMIT_BOOST_DOMAIN, signature::compute_domain, signer::verify_ecdsa_signature, types, @@ -439,10 +433,8 @@ mod tests { async fn test_proxy_key_is_valid_proxy_for_consensus_key() { let (mut signing_manager, consensus_pk) = init_signing_manager(); - let signed_delegation = signing_manager - .create_proxy_ecdsa(MODULE_ID.clone(), consensus_pk.clone()) - .await - .unwrap(); + let signed_delegation = + signing_manager.create_proxy_ecdsa(MODULE_ID.clone(), consensus_pk).await.unwrap(); let validation_result = signed_delegation.validate(CHAIN); @@ -462,10 +454,8 @@ mod tests { async fn test_tampered_proxy_key_is_invalid() { let (mut signing_manager, consensus_pk) = init_signing_manager(); - let mut signed_delegation = signing_manager - .create_proxy_ecdsa(MODULE_ID.clone(), consensus_pk.clone()) - .await - .unwrap(); + let mut signed_delegation = + signing_manager.create_proxy_ecdsa(MODULE_ID.clone(), consensus_pk).await.unwrap(); let m = &mut signed_delegation.signature.0[0]; (*m, _) = m.overflowing_add(1); @@ -479,30 +469,24 @@ mod tests { async fn test_proxy_key_signs_message() { let (mut signing_manager, consensus_pk) = init_signing_manager(); - let signed_delegation = signing_manager - .create_proxy_ecdsa(MODULE_ID.clone(), consensus_pk.clone()) - .await - .unwrap(); + let signed_delegation = + signing_manager.create_proxy_ecdsa(MODULE_ID.clone(), consensus_pk).await.unwrap(); let proxy_pk = signed_delegation.message.proxy; let data_root = B256::random(); let module_signing_id = B256::random(); let sig = signing_manager - .sign_proxy_ecdsa( - &proxy_pk.try_into().unwrap(), - &data_root, - Some(&module_signing_id), - ) + .sign_proxy_ecdsa(&proxy_pk, &data_root, Some(&module_signing_id)) .await .unwrap(); // Verify signature - let domain = compute_domain(CHAIN, COMMIT_BOOST_DOMAIN); + let domain = compute_domain(CHAIN, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_root = compute_signing_root(&types::SigningData { object_root: compute_signing_root(&types::PropCommitSigningInfo { - data: data_root.tree_hash_root().0, - module_signing_id: module_signing_id.0, + data: data_root.tree_hash_root(), + module_signing_id, }), signing_domain: domain, }); diff --git a/examples/da_commit/src/main.rs b/examples/da_commit/src/main.rs index 2f8845c8..c73b2191 100644 --- a/examples/da_commit/src/main.rs +++ b/examples/da_commit/src/main.rs @@ -99,7 +99,7 @@ impl DaCommitService { &pubkey, &datagram, &signature, - DA_COMMIT_SIGNING_ID, + &DA_COMMIT_SIGNING_ID, ) { Ok(_) => info!("Signature verified successfully"), Err(err) => error!(%err, "Signature verification failed"), @@ -115,7 +115,7 @@ impl DaCommitService { &proxy_bls, &datagram, &proxy_signature_bls, - DA_COMMIT_SIGNING_ID, + &DA_COMMIT_SIGNING_ID, ) { Ok(_) => info!("Signature verified successfully"), Err(err) => error!(%err, "Signature verification failed"), @@ -135,7 +135,7 @@ impl DaCommitService { &proxy_ecdsa, &datagram, &proxy_signature_ecdsa, - DA_COMMIT_SIGNING_ID, + &DA_COMMIT_SIGNING_ID, ) { Ok(_) => info!("Signature verified successfully"), Err(err) => error!(%err, "Signature verification failed"), diff --git a/tests/src/mock_relay.rs b/tests/src/mock_relay.rs index a91a70c6..45c095b3 100644 --- a/tests/src/mock_relay.rs +++ b/tests/src/mock_relay.rs @@ -117,8 +117,8 @@ async fn handle_get_header( response.message.pubkey = blst_pubkey_to_alloy(&state.signer.sk_to_pk()); response.message.header.timestamp = timestamp_of_slot_start_sec(0, state.chain); - let object_root = response.message.tree_hash_root().0; - response.signature = sign_builder_root(state.chain, &state.signer, object_root); + let object_root = response.message.tree_hash_root(); + response.signature = sign_builder_root(state.chain, &state.signer, &object_root); let response = GetHeaderResponse::Electra(response); (StatusCode::OK, Json(response)).into_response() diff --git a/tests/tests/payloads.rs b/tests/tests/payloads.rs index a1bd5b52..c43df7ef 100644 --- a/tests/tests/payloads.rs +++ b/tests/tests/payloads.rs @@ -9,19 +9,19 @@ use serde_json::Value; #[test] fn test_registrations() { let data = include_str!("../data/registration_holesky.json"); - test_encode_decode::>(&data); + test_encode_decode::>(data); } #[test] fn test_signed_blinded_block() { let data = include_str!("../data/signed_blinded_block_holesky.json"); - test_encode_decode::(&data); + test_encode_decode::(data); } #[test] fn test_submit_block_response() { let data = include_str!("../data/submit_block_response_holesky.json"); - test_encode_decode::(&data); + test_encode_decode::(data); } // Unhappy path tests @@ -32,10 +32,8 @@ fn test_missing_registration_field(field_name: &str) -> String { // Remove specified field from the first validator's message if let Value::Array(arr) = &mut values { if let Some(first_validator) = arr.get_mut(0) { - if let Some(message) = first_validator.get_mut("message") { - if let Value::Object(msg_obj) = message { - msg_obj.remove(field_name); - } + if let Some(Value::Object(msg_obj)) = first_validator.get_mut("message") { + msg_obj.remove(field_name); } } } @@ -66,10 +64,8 @@ fn test_missing_signed_blinded_block_field(field_name: &str) -> String { let mut values: Value = serde_json::from_str(data).unwrap(); // Remove specified field from the message - if let Some(message) = values.get_mut("message") { - if let Value::Object(msg_obj) = message { - msg_obj.remove(field_name); - } + if let Some(Value::Object(msg_obj)) = values.get_mut("message") { + msg_obj.remove(field_name); } // This should fail since the field is required diff --git a/tests/tests/pbs_get_header.rs b/tests/tests/pbs_get_header.rs index 10a68c02..088fedb2 100644 --- a/tests/tests/pbs_get_header.rs +++ b/tests/tests/pbs_get_header.rs @@ -58,7 +58,7 @@ async fn test_get_header() -> Result<()> { assert_eq!(res.message.header.timestamp, timestamp_of_slot_start_sec(0, chain)); assert_eq!( res.signature, - sign_builder_root(chain, &mock_state.signer, res.message.tree_hash_root().0) + sign_builder_root(chain, &mock_state.signer, &res.message.tree_hash_root()) ); Ok(()) } @@ -67,7 +67,7 @@ async fn test_get_header() -> Result<()> { async fn test_get_header_returns_204_if_relay_down() -> Result<()> { setup_test_env(); let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()); let chain = Chain::Holesky; let pbs_port = 3300; @@ -101,7 +101,7 @@ async fn test_get_header_returns_204_if_relay_down() -> Result<()> { async fn test_get_header_returns_400_if_request_is_invalid() -> Result<()> { setup_test_env(); let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()); let chain = Chain::Holesky; let pbs_port = 3400; diff --git a/tests/tests/pbs_get_status.rs b/tests/tests/pbs_get_status.rs index 7112a46b..629bea69 100644 --- a/tests/tests/pbs_get_status.rs +++ b/tests/tests/pbs_get_status.rs @@ -19,7 +19,7 @@ use tracing::info; async fn test_get_status() -> Result<()> { setup_test_env(); let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()); let chain = Chain::Holesky; let pbs_port = 3500; @@ -55,7 +55,7 @@ async fn test_get_status() -> Result<()> { async fn test_get_status_returns_502_if_relay_down() -> Result<()> { setup_test_env(); let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()); let chain = Chain::Holesky; let pbs_port = 3600; diff --git a/tests/tests/pbs_mux.rs b/tests/tests/pbs_mux.rs index 624217d3..f5645e54 100644 --- a/tests/tests/pbs_mux.rs +++ b/tests/tests/pbs_mux.rs @@ -20,7 +20,7 @@ use tracing::info; async fn test_mux() -> Result<()> { setup_test_env(); let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()); let chain = Chain::Holesky; let pbs_port = 3700; diff --git a/tests/tests/pbs_post_blinded_blocks.rs b/tests/tests/pbs_post_blinded_blocks.rs index 03c268ba..1119a1d6 100644 --- a/tests/tests/pbs_post_blinded_blocks.rs +++ b/tests/tests/pbs_post_blinded_blocks.rs @@ -20,7 +20,7 @@ use tracing::info; async fn test_submit_block() -> Result<()> { setup_test_env(); let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()); let chain = Chain::Holesky; let pbs_port = 3800; @@ -54,7 +54,7 @@ async fn test_submit_block() -> Result<()> { async fn test_submit_block_too_large() -> Result<()> { setup_test_env(); let signer = random_secret(); - let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()).into(); + let pubkey: BlsPublicKey = blst_pubkey_to_alloy(&signer.sk_to_pk()); let chain = Chain::Holesky; let pbs_port = 3900; From 114c3a5ea9d8cf6cc61f7beb46d28ced25327f53 Mon Sep 17 00:00:00 2001 From: Joe Clapis Date: Mon, 28 Jul 2025 15:56:19 -0400 Subject: [PATCH 2/2] Renamed compute_signing_root to compute_tree_hash_root --- crates/common/src/signature.rs | 22 +++++++++++----------- crates/common/src/signer/schemes/ecdsa.rs | 14 +++++++------- crates/signer/src/manager/dirk.rs | 6 +++--- crates/signer/src/manager/local.rs | 14 +++++++------- 4 files changed, 28 insertions(+), 28 deletions(-) diff --git a/crates/common/src/signature.rs b/crates/common/src/signature.rs index d7ab8d2f..fbb6021d 100644 --- a/crates/common/src/signature.rs +++ b/crates/common/src/signature.rs @@ -17,7 +17,7 @@ pub fn sign_message(secret_key: &BlsSecretKey, msg: &[u8]) -> BlsSignature { BlsSignature::from_slice(&signature) } -pub fn compute_signing_root(signing_data: &T) -> B256 { +pub fn compute_tree_hash_root(signing_data: &T) -> B256 { signing_data.tree_hash_root() } @@ -29,14 +29,14 @@ pub fn compute_prop_commit_signing_root( ) -> 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 { + 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 { + None => compute_tree_hash_root(&types::SigningData { object_root: *object_root, signing_domain: domain, }), @@ -75,7 +75,7 @@ pub fn verify_signed_message( ) -> Result<(), BlstErrorWrapper> { let signing_root = compute_prop_commit_signing_root( chain, - &compute_signing_root(msg), + &compute_tree_hash_root(msg), module_signing_id, domain_mask, ); @@ -98,10 +98,10 @@ pub fn sign_builder_root( ) -> 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); + let signing_root = compute_tree_hash_root(&signing_data); sign_message(secret_key, signing_root.as_slice()) } @@ -135,8 +135,8 @@ pub fn verify_proposer_commitment_signature_bls( ) -> Result<(), BlstErrorWrapper> { let object_root = msg.tree_hash_root(); let domain = compute_domain(chain, &B32::from(COMMIT_BOOST_DOMAIN)); - let signing_root = compute_signing_root(&types::SigningData { - object_root: compute_signing_root(&types::PropCommitSigningInfo { + 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, }), @@ -156,8 +156,8 @@ pub fn verify_proposer_commitment_signature_ecdsa( ) -> Result<(), eyre::Report> { let object_root = msg.tree_hash_root(); let domain = compute_domain(chain, &B32::from(COMMIT_BOOST_DOMAIN)); - let signing_root = compute_signing_root(&types::SigningData { - object_root: compute_signing_root(&types::PropCommitSigningInfo { + 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, }), diff --git a/crates/common/src/signer/schemes/ecdsa.rs b/crates/common/src/signer/schemes/ecdsa.rs index e5b25663..53911141 100644 --- a/crates/common/src/signer/schemes/ecdsa.rs +++ b/crates/common/src/signer/schemes/ecdsa.rs @@ -9,7 +9,7 @@ use tree_hash::TreeHash; use crate::{ constants::COMMIT_BOOST_DOMAIN, - signature::{compute_domain, compute_signing_root}, + signature::{compute_domain, compute_tree_hash_root}, types::{self, Chain}, }; @@ -95,20 +95,20 @@ impl EcdsaSigner { let signing_root = match module_signing_id { Some(id) => { let signing_data = types::SigningData { - object_root: compute_signing_root(&types::PropCommitSigningInfo { + object_root: compute_tree_hash_root(&types::PropCommitSigningInfo { data: *object_root, module_signing_id: *id, }), signing_domain: domain, }; - compute_signing_root(&signing_data) + compute_tree_hash_root(&signing_data) } None => { let signing_data = types::SigningData { object_root: *object_root, signing_domain: domain, }; - compute_signing_root(&signing_data) + compute_tree_hash_root(&signing_data) } }; sk.sign_hash_sync(&signing_root).map(EcdsaSignature::from) @@ -152,7 +152,7 @@ mod test { let domain = compute_domain(Chain::Holesky, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_data = types::SigningData { object_root, signing_domain: domain }; - let msg = compute_signing_root(&signing_data); + let msg = compute_tree_hash_root(&signing_data); assert_eq!(msg, hex!("219ca7a673b2cbbf67bec6c9f60f78bd051336d57b68d1540190f30667e86725")); @@ -173,13 +173,13 @@ mod test { let domain = compute_domain(Chain::Hoodi, &B32::from(COMMIT_BOOST_DOMAIN)); let signing_data = types::SigningData { - object_root: compute_signing_root(&types::PropCommitSigningInfo { + object_root: compute_tree_hash_root(&types::PropCommitSigningInfo { data: object_root, module_signing_id, }), signing_domain: domain, }; - let msg = compute_signing_root(&signing_data); + let msg = compute_tree_hash_root(&signing_data); assert_eq!(msg, hex!("8cd49ccf2f9b0297796ff96ce5f7c5d26e20a59d0032ee2ad6249dcd9682b808")); diff --git a/crates/signer/src/manager/dirk.rs b/crates/signer/src/manager/dirk.rs index c6b1cc25..e1ebac11 100644 --- a/crates/signer/src/manager/dirk.rs +++ b/crates/signer/src/manager/dirk.rs @@ -10,7 +10,7 @@ use cb_common::{ commit::request::{ConsensusProxyMap, ProxyDelegation, SignedProxyDelegation}, config::{DirkConfig, DirkHostConfig}, constants::COMMIT_BOOST_DOMAIN, - signature::{compute_domain, compute_signing_root}, + signature::{compute_domain, compute_tree_hash_root}, signer::{BlsPublicKey, BlsSignature, ProxyStore}, types::{self, Chain, ModuleId}, }; @@ -238,7 +238,7 @@ impl DirkManager { let domain = compute_domain(self.chain, &B32::from(COMMIT_BOOST_DOMAIN)); let data = match module_signing_id { - Some(id) => compute_signing_root(&types::PropCommitSigningInfo { + Some(id) => compute_tree_hash_root(&types::PropCommitSigningInfo { data: *object_root, module_signing_id: *id, }) @@ -279,7 +279,7 @@ impl DirkManager { let mut requests = Vec::with_capacity(account.participants.len()); let data = match module_signing_id { - Some(id) => compute_signing_root(&types::PropCommitSigningInfo { + Some(id) => compute_tree_hash_root(&types::PropCommitSigningInfo { data: *object_root, module_signing_id: *id, }) diff --git a/crates/signer/src/manager/local.rs b/crates/signer/src/manager/local.rs index c120c05a..48ec757c 100644 --- a/crates/signer/src/manager/local.rs +++ b/crates/signer/src/manager/local.rs @@ -280,7 +280,7 @@ impl LocalSigningManager { #[cfg(test)] mod tests { use alloy::primitives::B256; - use cb_common::signature::compute_signing_root; + use cb_common::signature::compute_tree_hash_root; use lazy_static::lazy_static; use super::*; @@ -325,8 +325,8 @@ mod tests { // Verify signature let domain = compute_domain(CHAIN, &B32::from(COMMIT_BOOST_DOMAIN)); - let signing_root = compute_signing_root(&types::SigningData { - object_root: compute_signing_root(&types::PropCommitSigningInfo { + let signing_root = compute_tree_hash_root(&types::SigningData { + object_root: compute_tree_hash_root(&types::PropCommitSigningInfo { data: data_root.tree_hash_root(), module_signing_id, }), @@ -403,8 +403,8 @@ mod tests { // Verify signature let domain = compute_domain(CHAIN, &B32::from(COMMIT_BOOST_DOMAIN)); - let signing_root = compute_signing_root(&types::SigningData { - object_root: compute_signing_root(&types::PropCommitSigningInfo { + let signing_root = compute_tree_hash_root(&types::SigningData { + object_root: compute_tree_hash_root(&types::PropCommitSigningInfo { data: data_root.tree_hash_root(), module_signing_id, }), @@ -483,8 +483,8 @@ mod tests { // Verify signature let domain = compute_domain(CHAIN, &B32::from(COMMIT_BOOST_DOMAIN)); - let signing_root = compute_signing_root(&types::SigningData { - object_root: compute_signing_root(&types::PropCommitSigningInfo { + let signing_root = compute_tree_hash_root(&types::SigningData { + object_root: compute_tree_hash_root(&types::PropCommitSigningInfo { data: data_root.tree_hash_root(), module_signing_id, }),