feat: add deneb compatibility

mev-build-rs/src/auctioneer/service.rs

@@ -3,19 +3,20 @@ use crate::{
     bidder::Message as BidderMessage,
     payload::attributes::{BuilderPayloadBuilderAttributes, ProposalAttributes},
     service::ClockMessage,
-    utils::compat::{to_bytes20, to_bytes32, to_execution_payload},
+    utils::compat::{to_blobs_bundle, to_bytes20, to_bytes32, to_execution_payload},
     Error,
 };
 use ethereum_consensus::{
     clock::convert_timestamp_to_slot,
     crypto::SecretKey,
     primitives::{BlsPublicKey, Epoch, Slot},
     state_transition::Context,
+    Fork,
 };
 use mev_rs::{
     relay::parse_relay_endpoints,
     signing::sign_builder_message,
-    types::{BidTrace, SignedBidSubmission},
+    types::{block_submission, BidTrace, SignedBidSubmission},
     BlindedBlockRelayer, Relay,
 };
 use reth::{
@@ -64,7 +65,30 @@ fn prepare_submission(
     };
     let execution_payload = to_execution_payload(payload.block());
     let signature = sign_builder_message(&message, signing_key, context)?;
-    Ok(SignedBidSubmission { message, execution_payload, signature })
+    let submission = match execution_payload.version() {
+        Fork::Bellatrix => {
+            SignedBidSubmission::Bellatrix(block_submission::bellatrix::SignedBidSubmission {
+                message,
+                execution_payload,
+                signature,
+            })
+        }
+        Fork::Capella => {
+            SignedBidSubmission::Capella(block_submission::capella::SignedBidSubmission {
+                message,
+                execution_payload,
+                signature,
+            })
+        }
+        Fork::Deneb => SignedBidSubmission::Deneb(block_submission::deneb::SignedBidSubmission {
+            message,
+            execution_payload,
+            blobs_bundle: to_blobs_bundle(payload.sidecars()),
+            signature,
+        }),
+        other => unreachable!("fork {other} is not reachable from this type"),
+    };
+    Ok(submission)
 }
 
 #[derive(Debug)]

mev-build-rs/src/utils/compat.rs

@@ -1,13 +1,14 @@
 use ethereum_consensus::{
-    deneb::mainnet as spec,
-    primitives::{Bytes32, ExecutionAddress},
-    ssz::{
-        prelude as ssz_rs,
-        prelude::{ByteList, ByteVector},
+    deneb::{
+        mainnet as spec,
+        polynomial_commitments::{KzgCommitment, KzgProof},
+        Blob,
     },
+    primitives::{Bytes32, ExecutionAddress},
+    ssz::prelude::{self as ssz_rs, ByteList, ByteVector, List},
 };
-use mev_rs::types::ExecutionPayload;
-use reth::primitives::{Address, Bloom, SealedBlock, B256};
+use mev_rs::types::{BlobsBundle, ExecutionPayload};
+use reth::primitives::{Address, BlobTransactionSidecar, Bloom, SealedBlock, B256};
 
 pub fn to_bytes32(value: B256) -> Bytes32 {
     Bytes32::try_from(value.as_ref()).unwrap()
@@ -64,3 +65,27 @@ pub fn to_execution_payload(value: &SealedBlock) -> ExecutionPayload {
     };
     ExecutionPayload::Deneb(payload)
 }
+
+pub fn to_blobs_bundle(sidecars: &[BlobTransactionSidecar]) -> BlobsBundle {
+    let mut commitments = List::default();
+    let mut proofs = List::default();
+    let mut blobs = List::default();
+
+    // TODO: perform length checks to avoid panic on `push`
+    for sidecar in sidecars {
+        for commitment in &sidecar.commitments {
+            let commitment = KzgCommitment::try_from(commitment.as_slice()).unwrap();
+            commitments.push(commitment);
+        }
+        for proof in &sidecar.proofs {
+            let proof = KzgProof::try_from(proof.as_slice()).unwrap();
+            proofs.push(proof);
+        }
+        for blob in &sidecar.blobs {
+            let blob = Blob::try_from(blob.as_ref()).unwrap();
+            blobs.push(blob);
+        }
+    }
+
+    BlobsBundle { commitments, proofs, blobs }
+}

mev-relay-rs/src/relay.rs

@@ -20,9 +20,9 @@ use mev_rs::{
         verify_signed_data,
     },
     types::{
-        self, builder_bid, AuctionContents, AuctionRequest, BidTrace, BuilderBid, ExecutionPayload,
-        ExecutionPayloadHeader, ProposerSchedule, SignedBidSubmission, SignedBlindedBeaconBlock,
-        SignedBuilderBid, SignedValidatorRegistration,
+        auction_contents, builder_bid, AuctionContents, AuctionRequest, BidTrace, BuilderBid,
+        ExecutionPayload, ExecutionPayloadHeader, ProposerSchedule, SignedBidSubmission,
+        SignedBlindedBeaconBlock, SignedBuilderBid, SignedValidatorRegistration,
     },
     BlindedBlockProvider, BlindedBlockRelayer, Error, ProposerScheduler, RelayError,
     ValidatorRegistry,
@@ -574,11 +574,13 @@ impl BlindedBlockProvider for Relay {
                     let auction_contents = match local_payload.version() {
                         Fork::Bellatrix => AuctionContents::Bellatrix(local_payload.clone()),
                         Fork::Capella => AuctionContents::Capella(local_payload.clone()),
-                        Fork::Deneb => AuctionContents::Deneb(types::deneb::AuctionContents {
-                            execution_payload: local_payload.clone(),
-                            // TODO: support blobs
-                            blobs_bundle: Default::default(),
-                        }),
+                        Fork::Deneb => {
+                            AuctionContents::Deneb(auction_contents::deneb::AuctionContents {
+                                execution_payload: local_payload.clone(),
+                                // TODO: support blobs
+                                blobs_bundle: Default::default(),
+                            })
+                        }
                         _ => unreachable!("fork not reachable from type"),
                     };
                     Ok(auction_contents)
@@ -603,7 +605,7 @@ impl BlindedBlockRelayer for Relay {
 
     async fn submit_bid(&self, signed_submission: &SignedBidSubmission) -> Result<(), Error> {
         let (auction_request, value, builder_public_key) = {
-            let bid_trace = &signed_submission.message;
+            let bid_trace = signed_submission.message();
             let builder_public_key = &bid_trace.builder_public_key;
             self.validate_allowed_builder(builder_public_key)?;
 
@@ -614,20 +616,17 @@ impl BlindedBlockRelayer for Relay {
             };
             self.validate_auction_request(&auction_request)?;
 
-            self.validate_builder_submission_trusted(
-                bid_trace,
-                &signed_submission.execution_payload,
-            )?;
+            self.validate_builder_submission_trusted(bid_trace, signed_submission.payload())?;
             debug!(%auction_request, "validated builder submission");
             (auction_request, bid_trace.value, bid_trace.builder_public_key.clone())
         };
 
-        let message = &signed_submission.message;
-        let public_key = &signed_submission.message.builder_public_key;
-        let signature = &signed_submission.signature;
+        let message = signed_submission.message();
+        let public_key = &signed_submission.message().builder_public_key;
+        let signature = signed_submission.signature();
         verify_signed_builder_data(message, public_key, signature, &self.context)?;
 
-        let execution_payload = signed_submission.execution_payload.clone();
+        let execution_payload = signed_submission.payload().clone();
         // NOTE: this does _not_ respect cancellations
         // TODO: move to regime where we track best bid by builder
         // and also move logic to cursor best bid for auction off this API

mev-rs/src/types/auction_contents.rs

@@ -21,12 +21,12 @@ pub mod deneb {
         ssz::prelude::*,
     };
 
-    #[derive(Debug, Default)]
+    #[derive(Clone, Debug, Default, Serializable, HashTreeRoot)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     pub struct BlobsBundle {
-        commitments: List<KzgCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK>,
-        proofs: List<KzgProof, MAX_BLOB_COMMITMENTS_PER_BLOCK>,
-        blobs: List<Blob, MAX_BLOB_COMMITMENTS_PER_BLOCK>,
+        pub commitments: List<KzgCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK>,
+        pub proofs: List<KzgProof, MAX_BLOB_COMMITMENTS_PER_BLOCK>,
+        pub blobs: List<Blob, MAX_BLOB_COMMITMENTS_PER_BLOCK>,
     }
 
     #[derive(Debug)]

mev-rs/src/types/block_submission.rs

@@ -1,7 +1,8 @@
-use crate::types::ExecutionPayload;
+use crate::types::{auction_contents::deneb::BlobsBundle, ExecutionPayload};
 use ethereum_consensus::{
     primitives::{BlsPublicKey, BlsSignature, ExecutionAddress, Hash32, Slot},
     ssz::prelude::*,
+    Fork,
 };
 
 #[derive(Debug, Default, Clone, SimpleSerialize)]
@@ -24,10 +25,105 @@ pub struct BidTrace {
     pub value: U256,
 }
 
+pub mod bellatrix {
+    use super::{BidTrace, BlsSignature, ExecutionPayload};
+    use ethereum_consensus::ssz::prelude::*;
+
+    #[derive(Debug, Clone, Serializable, HashTreeRoot)]
+    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+    pub struct SignedBidSubmission {
+        pub message: BidTrace,
+        pub execution_payload: ExecutionPayload,
+        pub signature: BlsSignature,
+    }
+}
+
+pub mod capella {
+    pub use super::bellatrix::*;
+}
+
+pub mod deneb {
+    use super::{BidTrace, BlsSignature, ExecutionPayload};
+    use crate::types::auction_contents::deneb::BlobsBundle;
+    use ethereum_consensus::ssz::prelude::*;
+
+    #[derive(Debug, Clone, Serializable, HashTreeRoot)]
+    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+    pub struct SignedBidSubmission {
+        pub message: BidTrace,
+        pub execution_payload: ExecutionPayload,
+        pub blobs_bundle: BlobsBundle,
+        pub signature: BlsSignature,
+    }
+}
+
 #[derive(Debug, Clone, Serializable, HashTreeRoot)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct SignedBidSubmission {
-    pub message: BidTrace,
-    pub execution_payload: ExecutionPayload,
-    pub signature: BlsSignature,
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[serde(untagged)]
+#[ssz(transparent)]
+pub enum SignedBidSubmission {
+    Bellatrix(bellatrix::SignedBidSubmission),
+    Capella(capella::SignedBidSubmission),
+    Deneb(deneb::SignedBidSubmission),
+}
+
+impl<'de> serde::Deserialize<'de> for SignedBidSubmission {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = serde_json::Value::deserialize(deserializer)?;
+        if let Ok(inner) = <_ as serde::Deserialize>::deserialize(&value) {
+            return Ok(Self::Deneb(inner))
+        }
+        if let Ok(inner) = <_ as serde::Deserialize>::deserialize(&value) {
+            return Ok(Self::Capella(inner))
+        }
+        if let Ok(inner) = <_ as serde::Deserialize>::deserialize(&value) {
+            return Ok(Self::Bellatrix(inner))
+        }
+        Err(serde::de::Error::custom("no variant could be deserialized from input"))
+    }
+}
+
+impl SignedBidSubmission {
+    pub fn version(&self) -> Fork {
+        match self {
+            Self::Bellatrix(..) => Fork::Bellatrix,
+            Self::Capella(..) => Fork::Capella,
+            Self::Deneb(..) => Fork::Deneb,
+        }
+    }
+
+    pub fn message(&self) -> &BidTrace {
+        match self {
+            Self::Bellatrix(inner) => &inner.message,
+            Self::Capella(inner) => &inner.message,
+            Self::Deneb(inner) => &inner.message,
+        }
+    }
+
+    pub fn payload(&self) -> &ExecutionPayload {
+        match self {
+            Self::Bellatrix(inner) => &inner.execution_payload,
+            Self::Capella(inner) => &inner.execution_payload,
+            Self::Deneb(inner) => &inner.execution_payload,
+        }
+    }
+
+    pub fn signature(&self) -> &BlsSignature {
+        match self {
+            Self::Bellatrix(inner) => &inner.signature,
+            Self::Capella(inner) => &inner.signature,
+            Self::Deneb(inner) => &inner.signature,
+        }
+    }
+
+    pub fn blobs_bundle(&self) -> Option<&BlobsBundle> {
+        match self {
+            Self::Bellatrix(..) => None,
+            Self::Capella(..) => None,
+            Self::Deneb(inner) => Some(&inner.blobs_bundle),
+        }
+    }
 }

mev-rs/src/types/mod.rs

@@ -1,12 +1,12 @@
-mod auction_contents;
+pub mod auction_contents;
 mod auction_request;
-mod block_submission;
+pub mod block_submission;
 pub mod builder_bid;
 mod proposer_schedule;
 
-pub use auction_contents::*;
+pub use auction_contents::{deneb::BlobsBundle, AuctionContents};
 pub use auction_request::*;
-pub use block_submission::*;
+pub use block_submission::{BidTrace, SignedBidSubmission};
 pub use builder_bid::{BuilderBid, SignedBuilderBid};
 pub use ethereum_consensus::{
     builder::SignedValidatorRegistration,