gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-04-29 18:53:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add builder SSZ flow (#6859)

Browse Source
This commit is contained in:
Eitan Seri-Levi
2025-02-03 09:07:42 +03:00
committed by GitHub
parent 55d1e754b4
commit 1e2b547b35
14 changed files with 406 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
beacon_node/builder_client/Cargo.toml
View File

@@ -6,7 +6,9 @@ authors = ["Sean Anderson <sean@sigmaprime.io>"]
[dependencies]
eth2 = { workspace = true }
ethereum_ssz = { workspace = true }
lighthouse_version = { workspace = true }
reqwest = { workspace = true }
sensitive_url = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }

179
beacon_node/builder_client/src/lib.rs
View File

@@ -1,16 +1,24 @@
use eth2::types::builder_bid::SignedBuilderBid;
use eth2::types::fork_versioned_response::EmptyMetadata;
use eth2::types::{
EthSpec, ExecutionBlockHash, ForkVersionedResponse, PublicKeyBytes,
SignedValidatorRegistrationData, Slot,
ContentType, EthSpec, ExecutionBlockHash, ForkName, ForkVersionDecode, ForkVersionDeserialize,
ForkVersionedResponse, PublicKeyBytes, SignedValidatorRegistrationData, Slot,
};
use eth2::types::{FullPayloadContents, SignedBlindedBeaconBlock};
pub use eth2::Error;
use eth2::{ok_or_error, StatusCode, CONSENSUS_VERSION_HEADER};
use reqwest::header::{HeaderMap, HeaderValue};
use eth2::{
ok_or_error, StatusCode, CONSENSUS_VERSION_HEADER, CONTENT_TYPE_HEADER,
JSON_CONTENT_TYPE_HEADER, SSZ_CONTENT_TYPE_HEADER,
};
use reqwest::header::{HeaderMap, HeaderValue, ACCEPT};
use reqwest::{IntoUrl, Response};
use sensitive_url::SensitiveUrl;
use serde::de::DeserializeOwned;
use serde::Serialize;
use ssz::Encode;
use std::str::FromStr;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;
pub const DEFAULT_TIMEOUT_MILLIS: u64 = 15000;
@@ -49,6 +57,7 @@ pub struct BuilderHttpClient {
server: SensitiveUrl,
timeouts: Timeouts,
user_agent: String,
ssz_enabled: Arc<AtomicBool>,
}
impl BuilderHttpClient {
@@ -64,6 +73,7 @@ impl BuilderHttpClient {
server,
timeouts: Timeouts::new(builder_header_timeout),
user_agent,
ssz_enabled: Arc::new(false.into()),
})
}
@@ -71,6 +81,78 @@ impl BuilderHttpClient {
&self.user_agent
}
fn fork_name_from_header(&self, headers: &HeaderMap) -> Result<Option<ForkName>, String> {
headers
.get(CONSENSUS_VERSION_HEADER)
.map(|fork_name| {
fork_name
.to_str()
.map_err(|e| e.to_string())
.and_then(ForkName::from_str)
})
.transpose()
}
fn content_type_from_header(&self, headers: &HeaderMap) -> ContentType {
let Some(content_type) = headers.get(CONTENT_TYPE_HEADER).map(|content_type| {
let content_type = content_type.to_str();
match content_type {
Ok(SSZ_CONTENT_TYPE_HEADER) => ContentType::Ssz,
_ => ContentType::Json,
}
}) else {
return ContentType::Json;
};
content_type
}
async fn get_with_header<
T: DeserializeOwned + ForkVersionDecode + ForkVersionDeserialize,
U: IntoUrl,
>(
&self,
url: U,
timeout: Duration,
headers: HeaderMap,
) -> Result<ForkVersionedResponse<T>, Error> {
let response = self
.get_response_with_header(url, Some(timeout), headers)
.await?;
let headers = response.headers().clone();
let response_bytes = response.bytes().await?;
let Ok(Some(fork_name)) = self.fork_name_from_header(&headers) else {
// if no fork version specified, attempt to fallback to JSON
self.ssz_enabled.store(false, Ordering::SeqCst);
return serde_json::from_slice(&response_bytes).map_err(Error::InvalidJson);
};
let content_type = self.content_type_from_header(&headers);
match content_type {
ContentType::Ssz => {
self.ssz_enabled.store(true, Ordering::SeqCst);
T::from_ssz_bytes_by_fork(&response_bytes, fork_name)
.map(|data| ForkVersionedResponse {
version: Some(fork_name),
metadata: EmptyMetadata {},
data,
})
.map_err(Error::InvalidSsz)
}
ContentType::Json => {
self.ssz_enabled.store(false, Ordering::SeqCst);
serde_json::from_slice(&response_bytes).map_err(Error::InvalidJson)
}
}
}
/// Return `true` if the most recently received response from the builder had SSZ Content-Type.
pub fn is_ssz_enabled(&self) -> bool {
self.ssz_enabled.load(Ordering::SeqCst)
}
async fn get_with_timeout<T: DeserializeOwned, U: IntoUrl>(
&self,
url: U,
@@ -83,6 +165,21 @@ impl BuilderHttpClient {
.map_err(Into::into)
}
/// Perform a HTTP GET request, returning the `Response` for further processing.
async fn get_response_with_header<U: IntoUrl>(
&self,
url: U,
timeout: Option<Duration>,
headers: HeaderMap,
) -> Result<Response, Error> {
let mut builder = self.client.get(url);
if let Some(timeout) = timeout {
builder = builder.timeout(timeout);
}
let response = builder.headers(headers).send().await.map_err(Error::from)?;
ok_or_error(response).await
}
/// Perform a HTTP GET request, returning the `Response` for further processing.
async fn get_response_with_timeout<U: IntoUrl>(
&self,
@@ -112,6 +209,32 @@ impl BuilderHttpClient {
ok_or_error(response).await
}
async fn post_ssz_with_raw_response<U: IntoUrl>(
&self,
url: U,
ssz_body: Vec<u8>,
mut headers: HeaderMap,
timeout: Option<Duration>,
) -> Result<Response, Error> {
let mut builder = self.client.post(url);
if let Some(timeout) = timeout {
builder = builder.timeout(timeout);
}
headers.insert(
CONTENT_TYPE_HEADER,
HeaderValue::from_static(SSZ_CONTENT_TYPE_HEADER),
);
let response = builder
.headers(headers)
.body(ssz_body)
.send()
.await
.map_err(Error::from)?;
ok_or_error(response).await
}
async fn post_with_raw_response<T: Serialize, U: IntoUrl>(
&self,
url: U,
@@ -152,6 +275,42 @@ impl BuilderHttpClient {
Ok(())
}
/// `POST /eth/v1/builder/blinded_blocks` with SSZ serialized request body
pub async fn post_builder_blinded_blocks_ssz<E: EthSpec>(
&self,
blinded_block: &SignedBlindedBeaconBlock<E>,
) -> Result<FullPayloadContents<E>, Error> {
let mut path = self.server.full.clone();
let body = blinded_block.as_ssz_bytes();
path.path_segments_mut()
.map_err(|()| Error::InvalidUrl(self.server.clone()))?
.push("eth")
.push("v1")
.push("builder")
.push("blinded_blocks");
let mut headers = HeaderMap::new();
if let Ok(value) = HeaderValue::from_str(&blinded_block.fork_name_unchecked().to_string()) {
headers.insert(CONSENSUS_VERSION_HEADER, value);
}
let result = self
.post_ssz_with_raw_response(
path,
body,
headers,
Some(self.timeouts.post_blinded_blocks),
)
.await?
.bytes()
.await?;
FullPayloadContents::from_ssz_bytes_by_fork(&result, blinded_block.fork_name_unchecked())
.map_err(Error::InvalidSsz)
}
/// `POST /eth/v1/builder/blinded_blocks`
pub async fn post_builder_blinded_blocks<E: EthSpec>(
&self,
@@ -202,7 +361,17 @@ impl BuilderHttpClient {
.push(format!("{parent_hash:?}").as_str())
.push(pubkey.as_hex_string().as_str());
let resp = self.get_with_timeout(path, self.timeouts.get_header).await;
let mut headers = HeaderMap::new();
if let Ok(ssz_content_type_header) = HeaderValue::from_str(&format!(
"{}; q=1.0,{}; q=0.9",
SSZ_CONTENT_TYPE_HEADER, JSON_CONTENT_TYPE_HEADER
)) {
headers.insert(ACCEPT, ssz_content_type_header);
};
let resp = self
.get_with_header(path, self.timeouts.get_header, headers)
.await;
if matches!(resp, Err(Error::StatusCode(StatusCode::NO_CONTENT))) {
Ok(None)

17
beacon_node/execution_layer/src/lib.rs
View File

@@ -1900,11 +1900,18 @@ impl<E: EthSpec> ExecutionLayer<E> {
if let Some(builder) = self.builder() {
let (payload_result, duration) =
timed_future(metrics::POST_BLINDED_PAYLOAD_BUILDER, async {
builder
.post_builder_blinded_blocks(block)
.await
.map_err(Error::Builder)
.map(|d| d.data)
if builder.is_ssz_enabled() {
builder
.post_builder_blinded_blocks_ssz(block)
.await
.map_err(Error::Builder)
} else {
builder
.post_builder_blinded_blocks(block)
.await
.map_err(Error::Builder)
.map(|d| d.data)
}
})
.await;

95
beacon_node/execution_layer/src/test_utils/mock_builder.rs
View File

@@ -1,15 +1,20 @@
use crate::test_utils::{DEFAULT_BUILDER_PAYLOAD_VALUE_WEI, DEFAULT_JWT_SECRET};
use crate::{Config, ExecutionLayer, PayloadAttributes, PayloadParameters};
use bytes::Bytes;
use eth2::types::PublishBlockRequest;
use eth2::types::{
BlobsBundle, BlockId, BroadcastValidation, EventKind, EventTopic, FullPayloadContents,
ProposerData, StateId, ValidatorId,
};
use eth2::{BeaconNodeHttpClient, Timeouts, CONSENSUS_VERSION_HEADER};
use eth2::{
BeaconNodeHttpClient, Timeouts, CONSENSUS_VERSION_HEADER, CONTENT_TYPE_HEADER,
SSZ_CONTENT_TYPE_HEADER,
};
use fork_choice::ForkchoiceUpdateParameters;
use parking_lot::RwLock;
use sensitive_url::SensitiveUrl;
use slog::{debug, error, info, warn, Logger};
use ssz::Encode;
use std::collections::HashMap;
use std::fmt::Debug;
use std::future::Future;
@@ -26,11 +31,12 @@ use types::builder_bid::{
};
use types::{
Address, BeaconState, ChainSpec, Epoch, EthSpec, ExecPayload, ExecutionPayload,
ExecutionPayloadHeaderRefMut, ExecutionRequests, ForkName, ForkVersionedResponse, Hash256,
PublicKeyBytes, Signature, SignedBlindedBeaconBlock, SignedRoot,
SignedValidatorRegistrationData, Slot, Uint256,
ExecutionPayloadHeaderRefMut, ExecutionRequests, ForkName, ForkVersionDecode,
ForkVersionedResponse, Hash256, PublicKeyBytes, Signature, SignedBlindedBeaconBlock,
SignedRoot, SignedValidatorRegistrationData, Slot, Uint256,
};
use types::{ExecutionBlockHash, SecretKey};
use warp::reply::{self, Reply};
use warp::{Filter, Rejection};
pub const DEFAULT_FEE_RECIPIENT: Address = Address::repeat_byte(42);
@@ -955,6 +961,33 @@ pub fn serve<E: EthSpec>(
)
.boxed();
let blinded_block_ssz = prefix
.and(warp::path("blinded_blocks"))
.and(warp::body::bytes())
.and(warp::header::header::<ForkName>(CONSENSUS_VERSION_HEADER))
.and(warp::path::end())
.and(ctx_filter.clone())
.and_then(
|block_bytes: Bytes, fork_name: ForkName, builder: MockBuilder<E>| async move {
let block =
SignedBlindedBeaconBlock::<E>::from_ssz_bytes_by_fork(&block_bytes, fork_name)
.map_err(|e| warp::reject::custom(Custom(format!("{:?}", e))))?;
let payload = builder
.submit_blinded_block(block)
.await
.map_err(|e| warp::reject::custom(Custom(e)))?;
Ok::<_, warp::reject::Rejection>(
warp::http::Response::builder()
.status(200)
.body(payload.as_ssz_bytes())
.map(add_ssz_content_type_header)
.map(|res| add_consensus_version_header(res, fork_name))
.unwrap(),
)
},
);
let blinded_block =
prefix
.and(warp::path("blinded_blocks"))
@@ -1007,35 +1040,47 @@ pub fn serve<E: EthSpec>(
)
.and(warp::path::end())
.and(ctx_filter.clone())
.and(warp::header::optional::<eth2::types::Accept>("accept"))
.and_then(
|slot: Slot,
parent_hash: ExecutionBlockHash,
pubkey: PublicKeyBytes,
builder: MockBuilder<E>| async move {
builder: MockBuilder<E>,
accept_header: Option<eth2::types::Accept>| async move {
let fork_name = builder.fork_name_at_slot(slot);
let signed_bid = builder
.get_header(slot, parent_hash, pubkey)
.await
.map_err(|e| warp::reject::custom(Custom(e)))?;
let resp: ForkVersionedResponse<_> = ForkVersionedResponse {
version: Some(fork_name),
metadata: Default::default(),
data: signed_bid,
};
let json_bid = serde_json::to_string(&resp)
.map_err(|_| reject("coudn't serialize signed bid"))?;
Ok::<_, Rejection>(
warp::http::Response::builder()
.status(200)
.body(json_bid)
.unwrap(),
)
let accept_header = accept_header.unwrap_or(eth2::types::Accept::Any);
match accept_header {
eth2::types::Accept::Ssz => Ok::<_, Rejection>(
warp::http::Response::builder()
.status(200)
.body(signed_bid.as_ssz_bytes())
.map(add_ssz_content_type_header)
.map(|res| add_consensus_version_header(res, fork_name))
.unwrap(),
),
eth2::types::Accept::Json | eth2::types::Accept::Any => {
let resp: ForkVersionedResponse<_> = ForkVersionedResponse {
version: Some(fork_name),
metadata: Default::default(),
data: signed_bid,
};
Ok::<_, Rejection>(warp::reply::json(&resp).into_response())
}
}
},
);
let routes = warp::post()
.and(validators.or(blinded_block))
// Routes which expect `application/octet-stream` go within this `and`.
.and(
warp::header::exact(CONTENT_TYPE_HEADER, SSZ_CONTENT_TYPE_HEADER)
.and(blinded_block_ssz),
)
.or(validators.or(blinded_block))
.or(warp::get().and(status).or(header))
.map(|reply| warp::reply::with_header(reply, "Server", "lighthouse-mock-builder-server"));
@@ -1048,3 +1093,13 @@ pub fn serve<E: EthSpec>(
fn reject(msg: &'static str) -> Rejection {
warp::reject::custom(Custom(msg.to_string()))
}
/// Add the 'Content-Type application/octet-stream` header to a response.
fn add_ssz_content_type_header<T: Reply>(reply: T) -> warp::reply::Response {
reply::with_header(reply, CONTENT_TYPE_HEADER, SSZ_CONTENT_TYPE_HEADER).into_response()
}
/// Add the `Eth-Consensus-Version` header to a response.
fn add_consensus_version_header<T: Reply>(reply: T, fork_name: ForkName) -> warp::reply::Response {
reply::with_header(reply, CONSENSUS_VERSION_HEADER, fork_name.to_string()).into_response()
}

4
beacon_node/store/src/hot_cold_store.rs
View File

@@ -666,7 +666,9 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
.hot_db
.get_bytes(ExecutionPayload::<E>::db_column(), key)?
{
Some(bytes) => Ok(Some(ExecutionPayload::from_ssz_bytes(&bytes, fork_name)?)),
Some(bytes) => Ok(Some(ExecutionPayload::from_ssz_bytes_by_fork(
&bytes, fork_name,
)?)),
None => Ok(None),
}
}