fix: updated devnet

bolt-boost/Cargo.toml

@@ -38,6 +38,7 @@ alloy = { version = "0.3.6", features = [
  "rpc-types-beacon",
  "rpc-types-engine",
 ] }
+alloy-rlp = "0.3.8"
 
 # commit-boost
 cb-common = { git = "https://github.com/commit-boost/commit-boost-client", tag = "v0.3.0" }

bolt-boost/src/server.rs

@@ -543,13 +543,9 @@ where
  Ok(response) => {
  let url = response.url().clone();
  let status = response.status();
- let body = response.text().await.ok();
  if status != StatusCode::OK {
- error!(
- %status,
- %url,
- "Failed to POST to relay: {body:?}"
- )
+ let body = response.text().await.ok();
+ error!(%status, %url, "Failed to POST to relay: {body:?}");
  } else {
  debug!(%url, "Successfully sent POST request to relay");
  success = true;

bolt-boost/src/types.rs

@@ -1,15 +1,17 @@
 use alloy::{
- consensus::TxEnvelope,
- eips::eip2718::{Decodable2718, Eip2718Error},
+ consensus::{TxEip4844Variant, TxEnvelope},
+ eips::eip2718::{Decodable2718, Eip2718Error, Eip2718Result},
  primitives::{Bytes, TxHash, B256},
  rpc::types::beacon::{BlsPublicKey, BlsSignature},
  signers::k256::sha2::{Digest, Sha256},
 };
+use alloy_rlp::{BufMut, Encodable};
 use axum::http::HeaderMap;
 use reqwest::Url;
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use std::ops::Deref;
+use tracing::error;
 
 use cb_common::{
  constants::COMMIT_BOOST_DOMAIN,
@@ -44,8 +46,15 @@ impl SignedConstraints {
  #[allow(unused)]
  pub fn verify_signature(&self, chain: Chain, pubkey: &BlsPublicKey) -> bool {
  let domain = compute_domain(chain, COMMIT_BOOST_DOMAIN);
- let signing_root = compute_signing_root(self.message.digest(), domain);
+ let digest = match self.message.digest() {
+ Ok(digest) => digest,
+ Err(e) => {
+ error!(err = ?e, "Failed to compute digest");
+ return false;
+ }
+ };
 
+ let signing_root = compute_signing_root(digest, domain);
  verify_bls_signature(pubkey, &signing_root, &self.signature).is_ok()
  }
 }
@@ -60,19 +69,19 @@ pub struct ConstraintsMessage {
 
 impl ConstraintsMessage {
  /// Returns the digest of this message.
- pub fn digest(&self) -> [u8; 32] {
+ pub fn digest(&self) -> Eip2718Result<[u8; 32]> {
  let mut hasher = Sha256::new();
  hasher.update(self.pubkey);
  hasher.update(self.slot.to_le_bytes());
  hasher.update((self.top as u8).to_le_bytes());
 
  for bytes in &self.transactions {
- let tx = TxEnvelope::decode_2718(&mut bytes.as_ref()).expect("valid transaction");
+ let tx = TxEnvelope::decode_2718(&mut bytes.as_ref())?;
 
  hasher.update(tx.tx_hash());
  }
 
- hasher.finalize().into()
+ Ok(hasher.finalize().into())
  }
 }
 
@@ -92,14 +101,45 @@ impl TryFrom<ConstraintsMessage> for ConstraintsWithProofData {
  .transactions
  .iter()
  .map(|tx| {
- let tx_hash = *TxEnvelope::decode_2718(&mut tx.as_ref())?.tx_hash();
+ let envelope = TxEnvelope::decode_2718(&mut tx.as_ref())?;
+ let tx_hash = *envelope.tx_hash();
 
- let tx_root =
- tree_hash::TreeHash::tree_hash_root(&Transaction::<
+ let root = match envelope {
+ // For type 3 txs, take the hash tree root of the inner tx (EIP-4844)
+ TxEnvelope::Eip4844(tx) => match tx.tx() {
+ TxEip4844Variant::TxEip4844(tx) => {
+ let mut out = Vec::new();
+ out.put_u8(0x03);
+ tx.encode(&mut out);
+
+ tree_hash::TreeHash::tree_hash_root(&Transaction::<
+ <DenebSpec as EthSpec>::MaxBytesPerTransaction,
+ >::from(
+ out
+ ))
+ }
+ TxEip4844Variant::TxEip4844WithSidecar(tx) => {
+ use alloy_rlp::Encodable;
+ let mut out = Vec::new();
+ out.put_u8(0x03);
+ tx.tx.encode(&mut out);
+
+ tree_hash::TreeHash::tree_hash_root(&Transaction::<
+ <DenebSpec as EthSpec>::MaxBytesPerTransaction,
+ >::from(
+ out
+ ))
+ }
+ },
+ // For other transaction types, take the hash tree root of the whole tx
+ _ => tree_hash::TreeHash::tree_hash_root(&Transaction::<
  <DenebSpec as EthSpec>::MaxBytesPerTransaction,
- >::from(tx.to_vec()));
+ >::from(
+ tx.to_vec()
+ )),
+ };
 
- Ok((tx_hash, tx_root))
+ Ok((tx_hash, root))
  })
  .collect::<Result<Vec<_>, Eip2718Error>>()?;
 
@@ -173,3 +213,53 @@ pub struct RequestConfig {
  pub timeout_ms: u64,
  pub headers: HeaderMap,
 }
+
+#[cfg(test)]
+mod tests {
+ use alloy::{hex::FromHex, primitives::Bytes};
+
+ use super::ConstraintsWithProofData;
+ use crate::types::SignedConstraints;
+
+ #[test]
+ fn decode_constraints_test() {
+ let raw = r#"{
+ "message": {
+ "pubkey": "0xa695ad325dfc7e1191fbc9f186f58eff42a634029731b18380ff89bf42c464a42cb8ca55b200f051f57f1e1893c68759",
+ "slot": 32,
+ "top": true,
+ "transactions": [
+ "0x02f86c870c72dd9d5e883e4d0183408f2382520894d2e2adf7177b7a8afddbc12d1634cf23ea1a71020180c001a08556dcfea479b34675db3fe08e29486fe719c2b22f6b0c1741ecbbdce4575cc6a01cd48009ccafd6b9f1290bbe2ceea268f94101d1d322c787018423ebcbc87ab4"
+ ]
+ },
+ "signature": "0xb8d50ee0d4b269db3d4658c1dac784d273a4160d769e16dce723a9684c390afe5865348416b3bf0f1a4f47098bec9024135d0d95f08bed18eb577a3d8a67f5dc78b13cc62515e280786a73fb267d35dfb7ab46a25ac29bf5bc2fa5b07b3e07a6"
+ }"#;
+
+ let mut c = serde_json::from_str::<SignedConstraints>(raw).unwrap();
+ let pd = ConstraintsWithProofData::try_from(c.message.clone()).unwrap().proof_data[0];
+
+ assert_eq!(
+ pd.0.to_string(),
+ "0x385b9f1ba5dbbe419dcbbbbf0840b76b941f3c216d383ec9deb9b1a323ee0cea".to_string()
+ );
+
+ assert_eq!(
+ pd.1.to_string(),
+ "0x02e383af0c34516ef38e13391d917d5b61b6f69e17d5234f77cb8cc3a1ae932e".to_string()
+ );
+
+ c.message.transactions[0] = Bytes::from_hex("0x03f9029c01830299f184b2d05e008507aef40a00832dc6c09468d30f47f19c07bccef4ac7fae2dc12fca3e0dc980b90204ef16e845000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001e0000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000633b68f5d8d3a86593ebb815b4663bcbe0302e31382e302d64657600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004109de8da2a97e37f2e6dc9f7d50a408f9344d7aa1a925ae53daf7fbef43491a571960d76c0cb926190a9da10df7209fb1ba93cd98b1565a3a2368749d505f90c81c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0843b9aca00e1a00141e3a338e30c49ed0501e315bcc45e4edefebed43ab1368a1505461d9cf64901a01e8511e06b17683d89eb57b9869b96b8b611f969f7f56cbc0adc2df7c88a2a07a00910deacf91bba0d74e368d285d311dc5884e7cfe219d85aea5741b2b6e3a2fe").unwrap();
+
+ let pd = ConstraintsWithProofData::try_from(c.message).unwrap().proof_data[0];
+
+ assert_eq!(
+ pd.0.to_string(),
+ "0x15bd881daa1408b33f67fa4bdeb8acfb0a2289d9b4c6f81eef9bb2bb2e52e780".to_string()
+ );
+
+ assert_eq!(
+ pd.1.to_string(),
+ "0x0a637924b9f9b28a413b01cb543bcd688850b8964f77576fc71219448f7b4ab9".to_string()
+ );
+ }
+}

bolt-kurtosis-client/src/main.rs

@@ -84,7 +84,7 @@ async fn main() -> Result<()> {
  );
 
  info!("Transaction hash: {}", tx_hash);
- info!("body: {}", serde_json::to_string(&request)?);
+ info!("body: {}", trim_zeroes(serde_json::to_string(&request)?));
 
  let client = reqwest::Client::new();
  let response = client
@@ -95,8 +95,13 @@ async fn main() -> Result<()> {
  .send()
  .await?;
 
- info!("Response: {:?}", response.text().await?);
+ let res = trim_zeroes(response.text().await?);
+ info!("Response: {:?}", res);
  }
 
  Ok(())
 }
+
+fn trim_zeroes(s: impl Into<String>) -> String {
+ s.into().replace(&"0".repeat(32), ".").replace(&".".repeat(4), "")
+}

bolt-kurtosis-client/src/utils.rs

@@ -37,7 +37,7 @@ pub fn generate_random_blob_tx() -> TransactionRequest {
  .with_value(U256::from(100))
  .with_max_fee_per_blob_gas(100u128)
  .max_fee_per_gas(NOICE_GAS_PRICE)
- .max_priority_fee_per_gas(NOICE_GAS_PRICE / 10)
+ .max_priority_fee_per_gas(NOICE_GAS_PRICE)
  .with_gas_limit(42_000u128)
  .with_blob_sidecar(sidecar)
  .with_input(random_bytes)

bolt-sidecar/src/builder/signature.rs

@@ -23,7 +23,7 @@ pub fn sign_builder_message<T: HashTreeRoot>(
  sk: &SecretKey,
  msg: &T,
 ) -> Result<Signature, MerkleizationError> {
- let domain = chain.builder_domain();
+ let domain = chain.application_builder_domain();
  let object_root = msg.hash_tree_root()?.0;
  let signing_root = compute_signing_root(object_root, domain);
 
@@ -42,7 +42,7 @@ pub fn verify_signed_builder_message<T: HashTreeRoot>(
  msg: &T,
  signature: &BlsSignature,
 ) -> Result<(), ethereum_consensus::Error> {
- let domain = chain.builder_domain();
+ let domain = chain.application_builder_domain();
  let object_root = msg.hash_tree_root()?.0;
  let signing_root = compute_signing_root(object_root, domain);
 
@@ -121,18 +121,27 @@ mod tests {
  #[test]
  fn test_compute_builder_domain() {
  let mainnet = ChainConfig::mainnet();
- assert_eq!(compute_builder_domain(mainnet.fork_version(), None), mainnet.builder_domain());
+ assert_eq!(
+ compute_builder_domain(mainnet.fork_version(), None),
+ mainnet.application_builder_domain()
+ );
 
  let holesky = ChainConfig::holesky();
- assert_eq!(compute_builder_domain(holesky.fork_version(), None), holesky.builder_domain());
+ assert_eq!(
+ compute_builder_domain(holesky.fork_version(), None),
+ holesky.application_builder_domain()
+ );
 
  let kurtosis = ChainConfig::kurtosis(0, 0);
  assert_eq!(
  compute_builder_domain(kurtosis.fork_version(), None),
- kurtosis.builder_domain()
+ kurtosis.application_builder_domain()
  );
 
  let helder = ChainConfig::helder();
- assert_eq!(compute_builder_domain(helder.fork_version(), None), helder.builder_domain());
+ assert_eq!(
+ compute_builder_domain(helder.fork_version(), None),
+ helder.application_builder_domain()
+ );
  }
 }

bolt-sidecar/src/client/commit_boost.rs

@@ -3,9 +3,10 @@ use std::{str::FromStr, sync::Arc};
 use alloy::{rpc::types::beacon::BlsSignature, signers::Signature};
 use cb_common::{
  commit::{client::SignerClient, request::SignConsensusRequest},
- signer::{BlsPublicKey, EcdsaPublicKey},
+ signer::EcdsaPublicKey,
 };
 use commit_boost::prelude::SignProxyRequest;
+use ethereum_consensus::crypto::bls::PublicKey as BlsPublicKey;
 use eyre::ErrReport;
 use parking_lot::RwLock;
 use thiserror::Error;
@@ -60,7 +61,11 @@ impl CommitBoostSigner {
  );
  let mut pubkeys_lock = this.pubkeys.write();
  let mut proxy_ecdsa_lock = this.proxy_ecdsa.write();
- *pubkeys_lock = pubkeys.consensus;
+ *pubkeys_lock = pubkeys
+ .consensus
+ .into_iter()
+ .map(|k| BlsPublicKey::try_from(k.as_ref()).unwrap())
+ .collect();
  *proxy_ecdsa_lock = pubkeys.proxy_ecdsa;
  }
  Err(e) => {
@@ -74,7 +79,8 @@ impl CommitBoostSigner {
 
  /// Get the consensus public key from the Commit-Boost signer.
  pub fn get_consensus_pubkey(&self) -> BlsPublicKey {
- *self.pubkeys.read().first().expect("consensus pubkey loaded")
+ let pk = self.pubkeys.read().first().expect("consensus pubkey loaded").clone();
+ BlsPublicKey::try_from(pk.as_ref()).expect("consensus pubkey is valid")
  }
 
  /// Get the proxy ECDSA public key from the Commit-Boost signer.
@@ -109,11 +115,17 @@ impl CommitBoostSigner {
 
 #[async_trait::async_trait]
 impl SignerBLS for CommitBoostSigner {
+ fn pubkey(&self) -> BlsPublicKey {
+ self.get_consensus_pubkey()
+ }
+
  async fn sign_commit_boost_root(&self, data: &[u8; 32]) -> eyre::Result<BlsSignature> {
- let request = SignConsensusRequest {
- pubkey: *self.pubkeys.read().first().expect("consensus pubkey loaded"),
- object_root: *data,
- };
+ // convert the pubkey from ethereum_consensus to commit-boost format
+ let pubkey = cb_common::signer::BlsPublicKey::from(
+ alloy::rpc::types::beacon::BlsPublicKey::from_slice(self.pubkey().as_ref()),
+ );
+
+ let request = SignConsensusRequest { pubkey, object_root: *data };
 
  debug!(?request, "Requesting signature from commit_boost");
 

bolt-sidecar/src/config/chain.rs

@@ -92,7 +92,7 @@ impl ChainConfig {
  }
 
  /// Get the domain for signing application-builder messages on the given chain.
- pub fn builder_domain(&self) -> [u8; 32] {
+ pub fn application_builder_domain(&self) -> [u8; 32] {
  self.compute_domain_from_mask(APPLICATION_BUILDER_DOMAIN_MASK)
  }
 
@@ -174,15 +174,15 @@ mod tests {
  use super::ChainConfig;
 
  let mainnet = ChainConfig::mainnet();
- assert_eq!(mainnet.builder_domain(), BUILDER_DOMAIN_MAINNET);
+ assert_eq!(mainnet.application_builder_domain(), BUILDER_DOMAIN_MAINNET);
 
  let holesky = ChainConfig::holesky();
- assert_eq!(holesky.builder_domain(), BUILDER_DOMAIN_HOLESKY);
+ assert_eq!(holesky.application_builder_domain(), BUILDER_DOMAIN_HOLESKY);
 
  let helder = ChainConfig::helder();
- assert_eq!(helder.builder_domain(), BUILDER_DOMAIN_HELDER);
+ assert_eq!(helder.application_builder_domain(), BUILDER_DOMAIN_HELDER);
 
  let kurtosis = ChainConfig::kurtosis(0, 0);
- assert_eq!(kurtosis.builder_domain(), BUILDER_DOMAIN_KURTOSIS);
+ assert_eq!(kurtosis.application_builder_domain(), BUILDER_DOMAIN_KURTOSIS);
  }
 }