Struct Command 

pub struct Command {
    rpc_url: String,
    engine_rpc_url: String,
    testing_rpc_url: String,
    jwt_secret: PathBuf,
    target_gas: u64,
    from_block: u64,
    execute: bool,
    count: u64,
    prefetch_buffer: usize,
    output_dir: PathBuf,
}

reth bench generate-big-block command

Generates a large block by fetching transactions from existing blocks and packing them into a single block using the testing_buildBlockV1 RPC endpoint.

Fields

rpc_url: String

The RPC URL to use for fetching blocks (can be an external archive node).

engine_rpc_url: String

The engine RPC URL (with JWT authentication).

testing_rpc_url: String

The RPC URL for testing_buildBlockV1 calls (same node as engine, regular RPC port).

jwt_secret: PathBuf

Path to the JWT secret file for engine API authentication.

target_gas: u64

Target gas to pack into the block. Accepts short notation: K for thousand, M for million, G for billion (e.g., 1G = 1 billion).

from_block: u64

Block number to start fetching transactions from (required).

This must be the last canonical block BEFORE any gas limit ramping was performed. The command collects transactions from historical blocks starting at this number to pack into large blocks.

How to determine this value:

• If starting from a fresh node (no gas limit ramp yet): use the current chain tip
• If gas limit ramping has already been performed: use the block number that was the chain tip BEFORE ramping began (you must track this yourself)

Using a block after ramping started will cause transaction collection to fail because those blocks contain synthetic transactions that cannot be replayed.

execute: bool

Execute the payload (call newPayload + forkchoiceUpdated). If false, only builds the payload and prints it.

count: u64

Number of payloads to generate. Each payload uses the previous as parent. When count == 1, the payload is only generated and saved, not executed. When count > 1, each payload is executed before building the next.

prefetch_buffer: usize

Number of transaction batches to prefetch in background when count > 1. Higher values reduce latency but use more memory.

output_dir: PathBuf

Output directory for generated payloads. Each payload is saved as payload_block_N.json.

Implementations

impl Command

pub async fn execute(self, _ctx: CliContext) -> Result<()>

Execute the generate-big-block command

async fn execute_sequential( &self, auth_provider: &RootProvider<AnyNetwork>, testing_provider: &RootProvider<AnyNetwork>, transactions: Vec<Bytes>, parent_hash: B256, parent_timestamp: u64, ) -> Result<()>

Sequential execution path for single payload or no-execute mode.

async fn execute_pipelined( &self, auth_provider: &RootProvider<AnyNetwork>, testing_provider: &RootProvider<AnyNetwork>, start_block: u64, initial_parent_hash: B256, initial_parent_timestamp: u64, ) -> Result<()>

Pipelined execution - fetches transactions and builds payloads in background.

async fn build_payload( &self, testing_provider: &RootProvider<AnyNetwork>, transactions: &[Bytes], index: u64, parent_hash: B256, parent_timestamp: u64, ) -> Result<BuiltPayload>

Build a single payload via testing_buildBlockV1.

async fn build_payload_static( testing_provider: &RootProvider<AnyNetwork>, transactions: &[Bytes], index: u64, parent_hash: B256, parent_timestamp: u64, ) -> Result<BuiltPayload>

Static version for use in spawned tasks.

fn save_payload(&self, payload: &BuiltPayload) -> Result<()>

Save a payload to disk.

async fn execute_payload_v4( &self, provider: &RootProvider<AnyNetwork>, envelope: ExecutionPayloadEnvelopeV4, parent_hash: B256, ) -> Result<()>

Trait Implementations

impl Args for Command

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl CommandFactory for Command

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl Debug for Command

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

Formats the value using the given formatter.

impl FromArgMatches for Command

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Command

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 160 bytes