Merge pull request #184 from ralexstokes/deneb-updates

lay foundation for deneb (via polymorphic types)

Cargo.toml

@@ -14,8 +14,8 @@ default-members = ["bin/mev"]
 version = "0.3.0"
 
 [workspace.dependencies]
-ethereum-consensus = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "b9baee3f3b9fc76bd9b5bc22b78edc05446af815" }
-beacon-api-client = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "b9baee3f3b9fc76bd9b5bc22b78edc05446af815" }
+ethereum-consensus = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "50ebe81afdcd751e265e05647b2109834ce1424e" }
+beacon-api-client = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "50ebe81afdcd751e265e05647b2109834ce1424e" }
 
 reth-payload-builder = { git = "https://github.com/paradigmxyz/reth", rev = "0a3884ba81579a775a0305be3a6621cd6782176a" }
 reth-primitives = { git = "https://github.com/paradigmxyz/reth", rev = "0a3884ba81579a775a0305be3a6621cd6782176a" }

mev-boost-rs/src/relay_mux.rs

@@ -7,7 +7,7 @@ use futures::{stream, StreamExt};
 use mev_rs::{
     relay::Relay,
     types::{
-        AuctionRequest, ExecutionPayload, SignedBlindedBeaconBlock, SignedBuilderBid,
+        AuctionContents, AuctionRequest, SignedBlindedBeaconBlock, SignedBuilderBid,
         SignedValidatorRegistration,
     },
     BlindedBlockProvider, BoostError, Error,
@@ -39,7 +39,7 @@ fn validate_bid(
     public_key: &BlsPublicKey,
     context: &Context,
 ) -> Result<(), Error> {
-    let bid_public_key = &bid.message.public_key;
+    let bid_public_key = bid.message.public_key();
     if bid_public_key != public_key {
         return Err(BoostError::BidPublicKeyMismatch {
             bid: bid_public_key.clone(),
@@ -200,7 +200,7 @@ impl BlindedBlockProvider for RelayMux {
 
         // TODO: change `value` so it does the copy internally
         let mut best_bid_indices =
-            select_best_bids(bids.iter().map(|(_, bid)| bid.message.value).enumerate());
+            select_best_bids(bids.iter().map(|(_, bid)| bid.message.value()).enumerate());
 
         // if multiple distinct bids with same bid value, break tie by randomly picking one
         let mut rng = rand::thread_rng();
@@ -210,12 +210,12 @@ impl BlindedBlockProvider for RelayMux {
             best_bid_indices.split_first().expect("there is at least one bid");
 
         let (best_relay, best_bid) = &bids[*best_bid_index];
-        let best_block_hash = best_bid.message.header.block_hash();
+        let best_block_hash = best_bid.message.header().block_hash();
 
         let mut best_relays = vec![best_relay.clone()];
         for bid_index in rest {
             let (relay, bid) = &bids[*bid_index];
-            if bid.message.header.block_hash() == best_block_hash {
+            if bid.message.header().block_hash() == best_block_hash {
                 best_relays.push(relay.clone());
             }
         }
@@ -241,7 +241,7 @@ impl BlindedBlockProvider for RelayMux {
     async fn open_bid(
         &self,
         signed_block: &mut SignedBlindedBeaconBlock,
-    ) -> Result<ExecutionPayload, Error> {
+    ) -> Result<AuctionContents, Error> {
         let (auction_request, relays) = {
             let mut state = self.state.lock();
             let key = bid_key_from(signed_block, &state.latest_pubkey);
@@ -269,11 +269,11 @@ impl BlindedBlockProvider for RelayMux {
         let expected_block_hash = payload_header.block_hash();
         for (relay, response) in responses.into_iter() {
             match response {
-                Ok(payload) => {
-                    let block_hash = payload.block_hash();
+                Ok(auction_contents) => {
+                    let block_hash = auction_contents.execution_payload().block_hash();
                     if block_hash == expected_block_hash {
                         info!(%auction_request, %block_hash, %relay, "acquired payload");
-                        return Ok(payload)
+                        return Ok(auction_contents)
                     } else {
                         warn!(?block_hash, ?expected_block_hash, %relay, "incorrect block hash delivered by relay");
                     }

mev-boost-rs/tests/identity_builder.rs

@@ -6,13 +6,14 @@ use ethereum_consensus::{
     crypto::SecretKey,
     primitives::{BlsPublicKey, Slot, U256},
     state_transition::Context,
+    Fork,
 };
 use mev_rs::{
     blinded_block_provider::BlindedBlockProvider,
     signing::sign_builder_message,
     types::{
-        AuctionRequest, BuilderBid, ExecutionPayload, ExecutionPayloadHeader,
-        SignedBlindedBeaconBlock, SignedBuilderBid,
+        builder_bid, AuctionContents, AuctionRequest, BuilderBid, ExecutionPayload,
+        ExecutionPayloadHeader, SignedBlindedBeaconBlock, SignedBuilderBid,
     },
     Error,
 };
@@ -61,7 +62,7 @@ impl BlindedBlockProvider for IdentityBuilder {
         let state = self.registrations.lock().unwrap();
         let preferences = state.get(public_key).unwrap();
         let value = U256::from(1337);
-        let (payload, header) = if *slot < capella_fork_slot {
+        let (payload, mut builder_bid) = if *slot < capella_fork_slot {
             let mut payload = bellatrix::ExecutionPayload {
                 parent_hash: parent_hash.clone(),
                 fee_recipient: preferences.fee_recipient.clone(),
@@ -71,7 +72,12 @@ impl BlindedBlockProvider for IdentityBuilder {
             let header = ExecutionPayloadHeader::Bellatrix(
                 bellatrix::ExecutionPayloadHeader::try_from(&mut payload).unwrap(),
             );
-            (ExecutionPayload::Bellatrix(payload), header)
+            let builder_bid = BuilderBid::Bellatrix(builder_bid::bellatrix::BuilderBid {
+                header,
+                value,
+                public_key: self.public_key.clone(),
+            });
+            (ExecutionPayload::Bellatrix(payload), builder_bid)
         } else {
             let mut payload = capella::ExecutionPayload {
                 parent_hash: parent_hash.clone(),
@@ -82,10 +88,14 @@ impl BlindedBlockProvider for IdentityBuilder {
             let header = ExecutionPayloadHeader::Capella(
                 capella::ExecutionPayloadHeader::try_from(&mut payload).unwrap(),
             );
-            (ExecutionPayload::Capella(payload), header)
+            let builder_bid = BuilderBid::Capella(builder_bid::capella::BuilderBid {
+                header,
+                value,
+                public_key: self.public_key.clone(),
+            });
+            (ExecutionPayload::Capella(payload), builder_bid)
         };
 
-        let mut builder_bid = BuilderBid { header, value, public_key: self.public_key.clone() };
         let signature =
             sign_builder_message(&mut builder_bid, &self.signing_key, &self.context).unwrap();
         let signed_builder_bid = SignedBuilderBid { message: builder_bid, signature };
@@ -97,9 +107,16 @@ impl BlindedBlockProvider for IdentityBuilder {
     async fn open_bid(
         &self,
         signed_block: &mut SignedBlindedBeaconBlock,
-    ) -> Result<ExecutionPayload, Error> {
+    ) -> Result<AuctionContents, Error> {
         let slot = signed_block.message().slot();
         let state = self.bids.lock().unwrap();
-        Ok(state.get(&slot).cloned().unwrap())
+        let execution_payload = state.get(&slot).cloned().unwrap();
+        let auction_contents = match signed_block.message().version() {
+            Fork::Bellatrix => AuctionContents::Bellatrix(execution_payload),
+            Fork::Capella => AuctionContents::Capella(execution_payload),
+            Fork::Deneb => unimplemented!(),
+            _ => unreachable!("fork not reachable from this type"),
+        };
+        Ok(auction_contents)
     }
 }

mev-boost-rs/tests/integration.rs

@@ -151,12 +151,12 @@ async fn propose_block(
         public_key: proposer.validator.public_key.clone(),
     };
     let signed_bid = beacon_node.fetch_best_bid(&request).await.unwrap();
-    let bid_parent_hash = signed_bid.message.header.parent_hash();
+    let bid_parent_hash = signed_bid.message.header().parent_hash();
     assert_eq!(bid_parent_hash, &parent_hash);
 
     let signed_block = match fork {
         Fork::Bellatrix => {
-            let header = signed_bid.message.header.bellatrix().unwrap().clone();
+            let header = signed_bid.message.header().bellatrix().unwrap().clone();
             let beacon_block_body = bellatrix::BlindedBeaconBlockBody {
                 execution_payload_header: header,
                 ..Default::default()
@@ -182,7 +182,7 @@ async fn propose_block(
             SignedBlindedBeaconBlock::Bellatrix(signed_block)
         }
         Fork::Capella => {
-            let header = signed_bid.message.header.capella().unwrap().clone();
+            let header = signed_bid.message.header().capella().unwrap().clone();
             let beacon_block_body = capella::BlindedBeaconBlockBody {
                 execution_payload_header: header,
                 ..Default::default()
@@ -212,7 +212,8 @@ async fn propose_block(
 
     beacon_node.check_status().await.unwrap();
 
-    let payload = beacon_node.open_bid(&signed_block).await.unwrap();
+    let auction_contents = beacon_node.open_bid(&signed_block).await.unwrap();
+    let payload = auction_contents.execution_payload();
 
     let payload_parent_hash = payload.parent_hash();
     assert_eq!(payload_parent_hash, &parent_hash);

mev-relay-rs/src/relay.rs

@@ -17,9 +17,9 @@ use ethereum_consensus::{
 use mev_rs::{
     signing::sign_builder_message,
     types::{
-        AuctionRequest, BidTrace, BuilderBid, ExecutionPayload, ExecutionPayloadHeader,
-        ProposerSchedule, SignedBidSubmission, SignedBlindedBeaconBlock, SignedBuilderBid,
-        SignedValidatorRegistration,
+        builder_bid, AuctionContents, AuctionRequest, BidTrace, BuilderBid, ExecutionPayload,
+        ExecutionPayloadHeader, ProposerSchedule, SignedBidSubmission, SignedBlindedBeaconBlock,
+        SignedBuilderBid, SignedValidatorRegistration,
     },
     BlindedBlockProvider, BlindedBlockRelayer, Error, ProposerScheduler, RelayError,
     ValidatorRegistry,
@@ -416,7 +416,20 @@ impl Relay {
             }
         }
         let header = to_header(&mut execution_payload)?;
-        let mut bid = BuilderBid { header, value, public_key: self.public_key.clone() };
+        let mut bid = match header.version() {
+            Fork::Bellatrix => BuilderBid::Bellatrix(builder_bid::bellatrix::BuilderBid {
+                header,
+                value,
+                public_key: self.public_key.clone(),
+            }),
+            Fork::Capella => BuilderBid::Capella(builder_bid::capella::BuilderBid {
+                header,
+                value,
+                public_key: self.public_key.clone(),
+            }),
+            Fork::Deneb => unimplemented!(),
+            _ => unreachable!("this fork is not reachable from this type"),
+        };
         let signature = sign_builder_message(&mut bid, &self.secret_key, &self.context)?;
         let signed_builder_bid = SignedBuilderBid { message: bid, signature };
 
@@ -481,7 +494,7 @@ impl BlindedBlockProvider for Relay {
     async fn open_bid(
         &self,
         signed_block: &mut SignedBlindedBeaconBlock,
-    ) -> Result<ExecutionPayload, Error> {
+    ) -> Result<AuctionContents, Error> {
         let auction_request = {
             let block = signed_block.message();
             let slot = block.slot();
@@ -506,7 +519,7 @@ impl BlindedBlockProvider for Relay {
             let block = signed_block.message();
             let body = block.body();
             let execution_payload_header = body.execution_payload_header();
-            let local_header = &auction_context.signed_builder_bid.message.header;
+            let local_header = auction_context.signed_builder_bid.message.header();
             if let Err(err) = validate_header_equality(local_header, execution_payload_header) {
                 warn!(%err, %auction_request, "invalid incoming signed blinded beacon block");
                 return Err(RelayError::InvalidSignedBlindedBeaconBlock.into())
@@ -533,7 +546,13 @@ impl BlindedBlockProvider for Relay {
                     let local_payload = &auction_context.execution_payload;
                     let block_hash = local_payload.block_hash();
                     info!(%auction_request, %block_root, %block_hash, "returning local payload");
-                    Ok(local_payload.clone())
+                    let auction_contents = match local_payload.version() {
+                        Fork::Bellatrix => AuctionContents::Bellatrix(local_payload.clone()),
+                        Fork::Capella => AuctionContents::Capella(local_payload.clone()),
+                        Fork::Deneb => unimplemented!(),
+                        _ => unreachable!("fork not reachable from type"),
+                    };
+                    Ok(auction_contents)
                 }
             }
             Err(err) => {

mev-rs/src/blinded_block_provider/api/client.rs

@@ -1,14 +1,14 @@
 use crate::{
     types::{
-        AuctionRequest, ExecutionPayload, SignedBlindedBeaconBlock, SignedBuilderBid,
+        AuctionContents, AuctionRequest, SignedBlindedBeaconBlock, SignedBuilderBid,
         SignedValidatorRegistration,
     },
     Error,
 };
-use axum::http::StatusCode;
+use axum::http::{Method, StatusCode};
 use beacon_api_client::{
     api_error_or_ok, mainnet::Client as BeaconApiClient, ApiResult, Error as ApiError,
-    VersionedValue,
+    VersionedValue, ETH_CONSENSUS_VERSION_HEADER,
 };
 
 /// A `Client` for a service implementing the Builder APIs.
@@ -63,11 +63,26 @@ impl Client {
     pub async fn open_bid(
         &self,
         signed_block: &SignedBlindedBeaconBlock,
-    ) -> Result<ExecutionPayload, Error> {
-        let response = self.api.http_post("/eth/v1/builder/blinded_blocks", signed_block).await?;
+    ) -> Result<AuctionContents, Error> {
+        let endpoint = self
+            .api
+            .endpoint
+            .join("/eth/v1/builder/blinded_blocks")
+            .map_err(beacon_api_client::Error::Url)?;
+        let response = self
+            .api
+            .http
+            .request(Method::POST, endpoint)
+            .header(ETH_CONSENSUS_VERSION_HEADER, signed_block.version().to_string())
+            .json(signed_block)
+            .send()
+            .await
+            .map_err(beacon_api_client::Error::Http)?;
 
-        let result: ApiResult<VersionedValue<ExecutionPayload>> =
-            response.json().await.map_err(beacon_api_client::Error::Http)?;
+        let result = response
+            .json::<ApiResult<VersionedValue<AuctionContents>>>()
+            .await
+            .map_err(beacon_api_client::Error::Http)?;
         match result {
             ApiResult::Ok(result) => Ok(result.data),
             ApiResult::Err(err) => Err(ApiError::from(err).into()),

mev-rs/src/blinded_block_provider/api/server.rs

@@ -2,7 +2,7 @@ use crate::{
     blinded_block_provider::BlindedBlockProvider,
     error::Error,
     types::{
-        AuctionRequest, ExecutionPayload, SignedBlindedBeaconBlock, SignedBuilderBid,
+        AuctionContents, AuctionRequest, SignedBlindedBeaconBlock, SignedBuilderBid,
         SignedValidatorRegistration,
     },
 };
@@ -48,13 +48,14 @@ pub(crate) async fn handle_fetch_bid<B: BlindedBlockProvider>(
 pub(crate) async fn handle_open_bid<B: BlindedBlockProvider>(
     State(builder): State<B>,
     Json(mut block): Json<SignedBlindedBeaconBlock>,
-) -> Result<Json<VersionedValue<ExecutionPayload>>, Error> {
-    let payload = builder.open_bid(&mut block).await?;
+) -> Result<Json<VersionedValue<AuctionContents>>, Error> {
+    let auction_contents = builder.open_bid(&mut block).await?;
+    let payload = auction_contents.execution_payload();
     let block_hash = payload.block_hash();
     let slot = block.message().slot();
     trace!(%slot, %block_hash, "returning payload");
     let version = payload.version();
-    let response = VersionedValue { version, data: payload, meta: Default::default() };
+    let response = VersionedValue { version, data: auction_contents, meta: Default::default() };
     Ok(Json(response))
 }
 

mev-rs/src/blinded_block_provider/mod.rs

@@ -7,7 +7,7 @@ pub use {api::client::Client, api::server::Server};
 use crate::{
     error::Error,
     types::{
-        AuctionRequest, ExecutionPayload, SignedBlindedBeaconBlock, SignedBuilderBid,
+        AuctionContents, AuctionRequest, SignedBlindedBeaconBlock, SignedBuilderBid,
         SignedValidatorRegistration,
     },
 };
@@ -28,5 +28,5 @@ pub trait BlindedBlockProvider {
     async fn open_bid(
         &self,
         signed_block: &mut SignedBlindedBeaconBlock,
-    ) -> Result<ExecutionPayload, Error>;
+    ) -> Result<AuctionContents, Error>;
 }

mev-rs/src/serde.rs

@@ -4,16 +4,17 @@ pub(crate) use ethereum_consensus::serde::as_str;
 mod tests {
     use ethereum_consensus::{primitives::U256, types::mainnet::ExecutionPayloadHeader};
 
-    use crate::types::{AuctionRequest, BuilderBid, SignedBuilderBid};
+    use crate::types::{builder_bid::deneb, AuctionRequest, BuilderBid, SignedBuilderBid};
 
     #[test]
     fn test_fmt() {
         let signed_bid = SignedBuilderBid {
-            message: BuilderBid {
+            message: BuilderBid::Deneb(deneb::BuilderBid {
                 header: ExecutionPayloadHeader::Deneb(Default::default()),
+                blob_kzg_commitments: Default::default(),
                 value: U256::from(234),
                 public_key: Default::default(),
-            },
+            }),
             signature: Default::default(),
         };