electra devnet-4 support

Author: ralexstokes

Cargo.lock

@@ -24,8 +24,9 @@ codegen-units = 1
 incremental = false
 
 [workspace.dependencies]
-ethereum-consensus = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "cf3c404043230559660810bc0c9d6d5a8498d819" }
-beacon-api-client = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "cf3c404043230559660810bc0c9d6d5a8498d819" }
+
+ethereum-consensus = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "92f3ec3" }
+beacon-api-client = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "92f3ec3" }
 
 reth = { git = "https://github.com/paradigmxyz/reth", tag = "v1.1.0" }
 reth-basic-payload-builder = { git = "https://github.com/paradigmxyz/reth", tag = "v1.1.0" }

Cargo.toml

@@ -1,7 +1,9 @@
 use crate::{
     auctioneer::auction_schedule::{AuctionSchedule, Proposals, Proposer, RelayIndex, RelaySet},
     bidder::Service as Bidder,
-    compat::{to_blobs_bundle, to_bytes20, to_bytes32, to_execution_payload},
+    compat::{
+        to_blobs_bundle, to_bytes20, to_bytes32, to_execution_payload, to_execution_requests,
+    },
     payload::attributes::{BuilderPayloadBuilderAttributes, ProposalAttributes},
     service::ClockMessage,
     Error,
@@ -61,6 +63,7 @@ fn prepare_submission(
     };
     let fork = context.fork_for(auction_context.slot);
     let execution_payload = to_execution_payload(payload.block(), fork)?;
+    let execution_requests = to_execution_requests(payload.block(), fork)?;
     let signature = sign_builder_message(&message, signing_key, context)?;
     let submission = match fork {
         Fork::Bellatrix => {
@@ -83,6 +86,15 @@ fn prepare_submission(
             blobs_bundle: to_blobs_bundle(payload.sidecars())?,
             signature,
         }),
+        Fork::Electra => {
+            SignedBidSubmission::Electra(block_submission::electra::SignedBidSubmission {
+                message,
+                execution_payload,
+                execution_requests,
+                blobs_bundle: to_blobs_bundle(payload.sidecars())?,
+                signature,
+            })
+        }
         fork => return Err(Error::UnsupportedFork(fork)),
     };
     Ok(submission)

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

@@ -1,21 +1,21 @@
 use crate::Error;
 use alloy_eips::eip2718::Encodable2718;
 use ethereum_consensus::{
-    crypto::{KzgCommitment, KzgProof},
+    crypto::{self, KzgCommitment, KzgProof},
     primitives::{Bytes32, ExecutionAddress},
-    ssz::prelude::{ByteList, ByteVector, SimpleSerializeError, U256},
+    ssz::prelude::{ByteList, ByteVector, DeserializeError, SimpleSerializeError, U256},
     Fork,
 };
 use mev_rs::types::{BlobsBundle, ExecutionPayload};
 use reth::primitives::{
     revm_primitives::{alloy_primitives::Bloom, Address, B256},
-    BlobTransactionSidecar, SealedBlock,
+    BlobTransactionSidecar, Request, SealedBlock,
 };
 
 #[cfg(not(feature = "minimal-preset"))]
-use ethereum_consensus::deneb::mainnet as deneb;
+use ethereum_consensus::{deneb::mainnet as deneb, electra::mainnet as electra};
 #[cfg(feature = "minimal-preset")]
-use ethereum_consensus::deneb::minimal as deneb;
+use ethereum_consensus::{deneb::minimal as deneb, electra::minimal as electra};
 
 pub fn to_bytes32(value: B256) -> Bytes32 {
     Bytes32::try_from(value.as_ref()).unwrap()
@@ -29,13 +29,62 @@ fn to_byte_vector(value: Bloom) -> ByteVector<256> {
     ByteVector::<256>::try_from(value.as_ref()).unwrap()
 }
 
+pub fn to_execution_requests(
+    block: &SealedBlock,
+    fork: Fork,
+) -> Result<electra::ExecutionRequests, Error> {
+    let input = block.body.requests.as_ref();
+    let mut requests = electra::ExecutionRequests::default();
+    if let Some(input) = input {
+        for request in &input.0 {
+            match request {
+                Request::DepositRequest(request) => {
+                    requests.deposits.push(electra::DepositRequest {
+                        public_key: TryFrom::try_from(request.pubkey.as_ref())
+                            .map_err(|err: crypto::BlsError| Error::Consensus(err.into()))?,
+                        withdrawal_credentials: TryFrom::try_from(
+                            request.withdrawal_credentials.as_ref(),
+                        )
+                        .map_err(|err: DeserializeError| {
+                            Error::Consensus(SimpleSerializeError::Deserialize(err).into())
+                        })?,
+                        amount: request.amount,
+                        signature: TryFrom::try_from(request.signature.as_ref())
+                            .map_err(|err: crypto::BlsError| Error::Consensus(err.into()))?,
+                        index: request.index,
+                    });
+                }
+                Request::WithdrawalRequest(request) => {
+                    requests.withdrawals.push(electra::WithdrawalRequest {
+                        source_address: to_bytes20(request.source_address),
+                        validator_public_key: TryFrom::try_from(request.validator_pubkey.as_ref())
+                            .map_err(|err: crypto::BlsError| Error::Consensus(err.into()))?,
+                        amount: request.amount,
+                    });
+                }
+                Request::ConsolidationRequest(request) => {
+                    requests.consolidations.push(electra::ConsolidationRequest {
+                        source_address: to_bytes20(request.source_address),
+                        source_public_key: TryFrom::try_from(request.source_pubkey.as_ref())
+                            .map_err(|err: crypto::BlsError| Error::Consensus(err.into()))?,
+                        target_public_key: TryFrom::try_from(request.target_pubkey.as_ref())
+                            .map_err(|err: crypto::BlsError| Error::Consensus(err.into()))?,
+                    });
+                }
+                _ => return Err(Error::UnsupportedFork(fork)),
+            }
+        }
+    }
+    Ok(requests)
+}
+
 pub fn to_execution_payload(value: &SealedBlock, fork: Fork) -> Result<ExecutionPayload, Error> {
     let hash = value.hash();
     let header = &value.header;
     let transactions = &value.body.transactions;
     let withdrawals = &value.body.withdrawals;
     match fork {
-        Fork::Deneb => {
+        Fork::Deneb | Fork::Electra => {
             let transactions = transactions
                 .iter()
                 .map(|t| deneb::Transaction::try_from(t.encoded_2718().as_ref()).unwrap())

mev-build-rs/src/compat.rs

@@ -23,6 +23,7 @@ fn to_header(execution_payload: &ExecutionPayload) -> Result<ExecutionPayloadHea
         }
         ExecutionPayload::Capella(payload) => ExecutionPayloadHeader::Capella(payload.try_into()?),
         ExecutionPayload::Deneb(payload) => ExecutionPayloadHeader::Deneb(payload.try_into()?),
+        ExecutionPayload::Electra(payload) => ExecutionPayloadHeader::Electra(payload.try_into()?),
     };
     Ok(header)
 }
@@ -89,11 +90,52 @@ pub mod deneb {
     }
 }
 
+pub mod electra {
+    use super::*;
+
+    #[cfg(not(feature = "minimal-preset"))]
+    use ethereum_consensus::electra::mainnet as electra;
+    #[cfg(feature = "minimal-preset")]
+    use ethereum_consensus::electra::minimal as electra;
+
+    #[derive(Debug, PartialEq, Eq)]
+    pub struct AuctionContext {
+        pub builder_public_key: BlsPublicKey,
+        pub bid_trace: BidTrace,
+        pub receive_duration: Duration,
+        pub signed_builder_bid: SignedBuilderBid,
+        pub execution_payload: ExecutionPayload,
+        pub execution_requests: electra::ExecutionRequests,
+        pub value: U256,
+        pub blobs_bundle: BlobsBundle,
+    }
+
+    impl Hash for AuctionContext {
+        fn hash<H: Hasher>(&self, state: &mut H) {
+            self.builder_public_key.hash(state);
+            self.bid_trace.hash(state);
+            self.receive_duration.hash(state);
+            self.signed_builder_bid.hash(state);
+            let payload_root =
+                self.execution_payload.hash_tree_root().expect("can get hash tree root");
+            payload_root.hash(state);
+            let requests_root =
+                self.execution_requests.hash_tree_root().expect("can get hash tree root");
+            requests_root.hash(state);
+            self.value.hash(state);
+            let blobs_bundle_root =
+                self.blobs_bundle.hash_tree_root().expect("can get hash tree root");
+            blobs_bundle_root.hash(state);
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub enum AuctionContext {
     Bellatrix(bellatrix::AuctionContext),
     Capella(capella::AuctionContext),
     Deneb(deneb::AuctionContext),
+    Electra(electra::AuctionContext),
 }
 
 impl AuctionContext {
@@ -134,6 +176,15 @@ impl AuctionContext {
                     public_key: relay_public_key,
                 })
             }
+            SignedBidSubmission::Electra(ref submission) => {
+                BuilderBid::Electra(builder_bid::electra::BuilderBid {
+                    header: execution_payload_header,
+                    blob_kzg_commitments: submission.blobs_bundle.commitments.clone(),
+                    execution_requests: submission.execution_requests.clone(),
+                    value,
+                    public_key: relay_public_key,
+                })
+            }
         };
 
         let signature = sign_builder_message(&bid, relay_secret_key, context)?;
@@ -167,6 +218,16 @@ impl AuctionContext {
                 value,
                 blobs_bundle: submission.blobs_bundle,
             }),
+            SignedBidSubmission::Electra(submission) => Self::Electra(electra::AuctionContext {
+                builder_public_key,
+                bid_trace: submission.message,
+                receive_duration,
+                signed_builder_bid,
+                execution_payload,
+                execution_requests: submission.execution_requests,
+                value,
+                blobs_bundle: submission.blobs_bundle,
+            }),
         };
 
         Ok(auction_context)
@@ -177,6 +238,7 @@ impl AuctionContext {
             Self::Bellatrix(context) => &context.builder_public_key,
             Self::Capella(context) => &context.builder_public_key,
             Self::Deneb(context) => &context.builder_public_key,
+            Self::Electra(context) => &context.builder_public_key,
         }
     }
 
@@ -185,6 +247,7 @@ impl AuctionContext {
             Self::Bellatrix(context) => &context.bid_trace,
             Self::Capella(context) => &context.bid_trace,
             Self::Deneb(context) => &context.bid_trace,
+            Self::Electra(context) => &context.bid_trace,
         }
     }
 
@@ -193,6 +256,7 @@ impl AuctionContext {
             Self::Bellatrix(context) => context.receive_duration,
             Self::Capella(context) => context.receive_duration,
             Self::Deneb(context) => context.receive_duration,
+            Self::Electra(context) => context.receive_duration,
         }
     }
 
@@ -201,6 +265,7 @@ impl AuctionContext {
             Self::Bellatrix(context) => &context.signed_builder_bid,
             Self::Capella(context) => &context.signed_builder_bid,
             Self::Deneb(context) => &context.signed_builder_bid,
+            Self::Electra(context) => &context.signed_builder_bid,
         }
     }
 
@@ -209,6 +274,7 @@ impl AuctionContext {
             Self::Bellatrix(context) => &context.execution_payload,
             Self::Capella(context) => &context.execution_payload,
             Self::Deneb(context) => &context.execution_payload,
+            Self::Electra(context) => &context.execution_payload,
         }
     }
 
@@ -217,6 +283,7 @@ impl AuctionContext {
             Self::Bellatrix(_) => None,
             Self::Capella(_) => None,
             Self::Deneb(context) => Some(&context.blobs_bundle),
+            Self::Electra(context) => Some(&context.blobs_bundle),
         }
     }
 
@@ -225,6 +292,7 @@ impl AuctionContext {
             Self::Bellatrix(context) => context.value,
             Self::Capella(context) => context.value,
             Self::Deneb(context) => context.value,
+            Self::Electra(context) => context.value,
         }
     }
 
@@ -240,6 +308,12 @@ impl AuctionContext {
                     blobs_bundle: context.blobs_bundle.clone(),
                 })
             }
+            Self::Electra(context) => {
+                AuctionContents::Electra(auction_contents::deneb::AuctionContents {
+                    execution_payload: context.execution_payload.clone(),
+                    blobs_bundle: context.blobs_bundle.clone(),
+                })
+            }
         }
     }
 }

mev-relay-rs/src/auction_context.rs

@@ -40,13 +40,15 @@ use ethereum_consensus::{
     bellatrix::mainnet as bellatrix,
     capella::mainnet as capella,
     deneb::mainnet as deneb,
+    electra::mainnet as electra,
     types::mainnet::{ExecutionPayloadHeaderRef, SignedBeaconBlock},
 };
 #[cfg(feature = "minimal-preset")]
 use ethereum_consensus::{
     bellatrix::minimal as bellatrix,
     capella::minimal as capella,
     deneb::minimal as deneb,
+    electra::minimal as electra,
     types::minimal::{ExecutionPayloadHeaderRef, SignedBeaconBlock},
 };
 
@@ -80,6 +82,13 @@ fn validate_header_equality(
                 return Err(RelayError::InvalidExecutionPayloadInBlock);
             }
         }
+        ExecutionPayloadHeader::Electra(local_header) => {
+            let provided_header =
+                provided_header.electra().ok_or(RelayError::InvalidExecutionPayloadInBlock)?;
+            if local_header != provided_header {
+                return Err(RelayError::InvalidExecutionPayloadInBlock);
+            }
+        }
     }
     Ok(())
 }
@@ -188,6 +197,41 @@ fn unblind_block(
             };
             Ok(SignedBeaconBlock::Deneb(inner))
         }
+        SignedBlindedBeaconBlock::Electra(blinded_block) => {
+            let signature = blinded_block.signature.clone();
+            let block = &blinded_block.message;
+            let body = &block.body;
+            let execution_payload = execution_payload.electra().ok_or(Error::InvalidFork {
+                expected: Fork::Electra,
+                provided: execution_payload.version(),
+            })?;
+
+            let inner = electra::SignedBeaconBlock {
+                message: electra::BeaconBlock {
+                    slot: block.slot,
+                    proposer_index: block.proposer_index,
+                    parent_root: block.parent_root,
+                    state_root: block.state_root,
+                    body: electra::BeaconBlockBody {
+                        randao_reveal: body.randao_reveal.clone(),
+                        eth1_data: body.eth1_data.clone(),
+                        graffiti: body.graffiti.clone(),
+                        proposer_slashings: body.proposer_slashings.clone(),
+                        attester_slashings: body.attester_slashings.clone(),
+                        attestations: body.attestations.clone(),
+                        deposits: body.deposits.clone(),
+                        voluntary_exits: body.voluntary_exits.clone(),
+                        sync_aggregate: body.sync_aggregate.clone(),
+                        execution_payload: execution_payload.clone(),
+                        bls_to_execution_changes: body.bls_to_execution_changes.clone(),
+                        blob_kzg_commitments: body.blob_kzg_commitments.clone(),
+                        execution_requests: body.execution_requests.clone(),
+                    },
+                },
+                signature,
+            };
+            Ok(SignedBeaconBlock::Electra(inner))
+        }
     }
 }