feat: add deneb compatibility

mev-build-rs/src/auctioneer.rs

@@ -10,11 +10,12 @@ use ethereum_consensus::{
     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::{
@@ -50,7 +51,25 @@ 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 => unimplemented!(),
+        other => unreachable!("fork {other} is not reachable from this type"),
+    };
+    Ok(submission)
 }
 
 #[derive(Deserialize, Debug, Default, Clone)]

mev-relay-rs/src/relay.rs

@@ -593,7 +593,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)?;
 
@@ -604,20 +604,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,7 +21,7 @@ pub mod deneb {
         ssz::prelude::*,
     };
 
-    #[derive(Debug)]
+    #[derive(Clone, Debug, Serializable, HashTreeRoot)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     pub struct BlobsBundle {
         commitments: List<KzgCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK>,

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;
 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::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,