Enum RethNewPayloadInput 

pub enum RethNewPayloadInput<ExecutionData> {
    ExecutionData(ExecutionData),
    BigBlockData(Box<BigBlockData<ExecutionData>>),
    BlockRlp {
        block: Bytes,
        bal: Option<Bytes>,
    },
}

The input to reth_newPayload.

Reth accepts standard execution data, big-block execution data, and raw RLP-encoded blocks. Raw blocks are sent as a legacy bare byte string when no block access list is present, and as an object containing block and bal when one is present.

Examples

Standard execution data can use any serializable execution-data type:

use alloy_reth::RethNewPayloadInput;

let input = RethNewPayloadInput::execution_data(serde_json::json!({
    "payload": "0x01",
    "sidecar": "0x02",
}));
assert!(serde_json::to_value(input).is_ok());

Big-block data carries the constituent execution environments and their block hashes:

use alloy_primitives::B256;
use alloy_reth::{BigBlockData, RethNewPayloadInput};

let input = RethNewPayloadInput::big_block_data(BigBlockData {
    env_switches: vec![serde_json::json!({"payload": "0x01"})],
    prior_block_hashes: vec![(7, B256::ZERO)],
    block_number: 8,
    merged_block_access_list: None,
});
assert!(serde_json::to_value(input).is_ok());

Raw RLP data may be sent with an optional merged block access list:

use alloy_primitives::Bytes;
use alloy_reth::RethNewPayloadInput;

let input = RethNewPayloadInput::<serde_json::Value>::block_rlp_with_bal(
    Bytes::from_static(&[0x01]),
    Bytes::from_static(&[0x02]),
);
assert_eq!(serde_json::to_value(input).unwrap()["block"], "0x01");

Variants

ExecutionData(ExecutionData)

Standard execution data (payload + sidecar).

BigBlockData(Box<BigBlockData<ExecutionData>>)

Big-block execution data.

BlockRlp

Raw RLP-encoded block bytes and an optional merged block access list.

Fields

block: Bytes

RLP-encoded block bytes.

bal: Option<Bytes>

Optional merged block access list bytes.

Implementations

impl<E> RethNewPayloadInput<E>

pub const fn execution_data(data: E) -> Self

Creates a new RethNewPayloadInput from execution data.

pub fn big_block_data(data: BigBlockData<E>) -> Self

Creates a new RethNewPayloadInput from big-block execution data.

pub fn block_rlp(bytes: impl Into<Bytes>) -> Self

Creates a new RethNewPayloadInput from raw RLP-encoded block bytes.

pub fn block_rlp_with_bal( block: impl Into<Bytes>, bal: impl Into<Bytes>, ) -> Self

Creates a new RethNewPayloadInput from raw RLP bytes and a block access list.

Trait Implementations

impl<ExecutionData: Clone> Clone for RethNewPayloadInput<ExecutionData>

fn clone(&self) -> RethNewPayloadInput<ExecutionData>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<ExecutionData: Debug> Debug for RethNewPayloadInput<ExecutionData>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, E> Deserialize<'de> for RethNewPayloadInput<E>

where E: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E> From<RethNewPayloadInput<E>> for RethNewPayloadParams<E>

fn from(payload: RethNewPayloadInput<E>) -> Self

Converts to this type from the input type.

impl<E> Serialize for RethNewPayloadInput<E>

where E: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.