reth_ethereum_engine_primitives/
payload.rsuse alloy_eips::eip4844::BlobTransactionSidecar;
use alloy_primitives::{Address, B256, U256};
use alloy_rlp::Encodable;
use alloy_rpc_types_engine::{
ExecutionPayloadEnvelopeV2, ExecutionPayloadEnvelopeV3, ExecutionPayloadEnvelopeV4,
ExecutionPayloadV1, PayloadAttributes, PayloadId,
};
use reth_chain_state::ExecutedBlock;
use reth_payload_primitives::{BuiltPayload, PayloadBuilderAttributes};
use reth_primitives::{SealedBlock, Withdrawals};
use reth_rpc_types_compat::engine::payload::{
block_to_payload_v1, block_to_payload_v3, block_to_payload_v4,
convert_block_to_payload_field_v2,
};
use std::convert::Infallible;
#[derive(Debug, Clone)]
pub struct EthBuiltPayload {
pub(crate) id: PayloadId,
pub(crate) block: SealedBlock,
pub(crate) executed_block: Option<ExecutedBlock>,
pub(crate) fees: U256,
pub(crate) sidecars: Vec<BlobTransactionSidecar>,
}
impl EthBuiltPayload {
pub const fn new(
id: PayloadId,
block: SealedBlock,
fees: U256,
executed_block: Option<ExecutedBlock>,
) -> Self {
Self { id, block, executed_block, fees, sidecars: Vec::new() }
}
pub const fn id(&self) -> PayloadId {
self.id
}
pub const fn block(&self) -> &SealedBlock {
&self.block
}
pub const fn fees(&self) -> U256 {
self.fees
}
pub fn sidecars(&self) -> &[BlobTransactionSidecar] {
&self.sidecars
}
pub fn extend_sidecars(&mut self, sidecars: Vec<BlobTransactionSidecar>) {
self.sidecars.extend(sidecars)
}
}
impl BuiltPayload for EthBuiltPayload {
fn block(&self) -> &SealedBlock {
&self.block
}
fn fees(&self) -> U256 {
self.fees
}
fn executed_block(&self) -> Option<ExecutedBlock> {
self.executed_block.clone()
}
}
impl BuiltPayload for &EthBuiltPayload {
fn block(&self) -> &SealedBlock {
(**self).block()
}
fn fees(&self) -> U256 {
(**self).fees()
}
fn executed_block(&self) -> Option<ExecutedBlock> {
self.executed_block.clone()
}
}
impl From<EthBuiltPayload> for ExecutionPayloadV1 {
fn from(value: EthBuiltPayload) -> Self {
block_to_payload_v1(value.block)
}
}
impl From<EthBuiltPayload> for ExecutionPayloadEnvelopeV2 {
fn from(value: EthBuiltPayload) -> Self {
let EthBuiltPayload { block, fees, .. } = value;
Self { block_value: fees, execution_payload: convert_block_to_payload_field_v2(block) }
}
}
impl From<EthBuiltPayload> for ExecutionPayloadEnvelopeV3 {
fn from(value: EthBuiltPayload) -> Self {
let EthBuiltPayload { block, fees, sidecars, .. } = value;
Self {
execution_payload: block_to_payload_v3(block),
block_value: fees,
should_override_builder: false,
blobs_bundle: sidecars.into_iter().map(Into::into).collect::<Vec<_>>().into(),
}
}
}
impl From<EthBuiltPayload> for ExecutionPayloadEnvelopeV4 {
fn from(value: EthBuiltPayload) -> Self {
let EthBuiltPayload { block, fees, sidecars, .. } = value;
Self {
execution_payload: block_to_payload_v4(block),
block_value: fees,
should_override_builder: false,
blobs_bundle: sidecars.into_iter().map(Into::into).collect::<Vec<_>>().into(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EthPayloadBuilderAttributes {
pub id: PayloadId,
pub parent: B256,
pub timestamp: u64,
pub suggested_fee_recipient: Address,
pub prev_randao: B256,
pub withdrawals: Withdrawals,
pub parent_beacon_block_root: Option<B256>,
}
impl EthPayloadBuilderAttributes {
pub const fn payload_id(&self) -> PayloadId {
self.id
}
pub fn new(parent: B256, attributes: PayloadAttributes) -> Self {
let id = payload_id(&parent, &attributes);
Self {
id,
parent,
timestamp: attributes.timestamp,
suggested_fee_recipient: attributes.suggested_fee_recipient,
prev_randao: attributes.prev_randao,
withdrawals: attributes.withdrawals.unwrap_or_default().into(),
parent_beacon_block_root: attributes.parent_beacon_block_root,
}
}
}
impl PayloadBuilderAttributes for EthPayloadBuilderAttributes {
type RpcPayloadAttributes = PayloadAttributes;
type Error = Infallible;
fn try_new(parent: B256, attributes: PayloadAttributes) -> Result<Self, Infallible> {
Ok(Self::new(parent, attributes))
}
fn payload_id(&self) -> PayloadId {
self.id
}
fn parent(&self) -> B256 {
self.parent
}
fn timestamp(&self) -> u64 {
self.timestamp
}
fn parent_beacon_block_root(&self) -> Option<B256> {
self.parent_beacon_block_root
}
fn suggested_fee_recipient(&self) -> Address {
self.suggested_fee_recipient
}
fn prev_randao(&self) -> B256 {
self.prev_randao
}
fn withdrawals(&self) -> &Withdrawals {
&self.withdrawals
}
}
pub(crate) fn payload_id(parent: &B256, attributes: &PayloadAttributes) -> PayloadId {
use sha2::Digest;
let mut hasher = sha2::Sha256::new();
hasher.update(parent.as_slice());
hasher.update(&attributes.timestamp.to_be_bytes()[..]);
hasher.update(attributes.prev_randao.as_slice());
hasher.update(attributes.suggested_fee_recipient.as_slice());
if let Some(withdrawals) = &attributes.withdrawals {
let mut buf = Vec::new();
withdrawals.encode(&mut buf);
hasher.update(buf);
}
if let Some(parent_beacon_block) = attributes.parent_beacon_block_root {
hasher.update(parent_beacon_block);
}
let out = hasher.finalize();
PayloadId::new(out.as_slice()[..8].try_into().expect("sufficient length"))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn attributes_serde() {
let attributes = r#"{"timestamp":"0x1235","prevRandao":"0xf343b00e02dc34ec0124241f74f32191be28fb370bb48060f5fa4df99bda774c","suggestedFeeRecipient":"0x0000000000000000000000000000000000000000","withdrawals":null,"parentBeaconBlockRoot":null}"#;
let _attributes: PayloadAttributes = serde_json::from_str(attributes).unwrap();
}
}