Struct NodeTestContext 

pub struct NodeTestContext<Node, AddOns>
where
    Node: FullNodeComponents,
    AddOns: RethRpcAddOns<Node>,
{
    pub inner: FullNode<Node, AddOns>,
    pub payload: PayloadTestContext<<Node::Types as NodeTypes>::Payload>,
    pub network: NetworkTestContext<Node::Network>,
    pub rpc: RpcTestContext<Node, AddOns::EthApi>,
    pub canonical_stream: CanonStateNotificationStream<PrimitivesTy<Node::Types>>,
}

A helper struct to handle node actions

Fields

inner: FullNode<Node, AddOns>

The core structure representing the full node.

payload: PayloadTestContext<<Node::Types as NodeTypes>::Payload>

Context for testing payload-related features.

network: NetworkTestContext<Node::Network>

Context for testing network functionalities.

rpc: RpcTestContext<Node, AddOns::EthApi>

Context for testing RPC features.

canonical_stream: CanonStateNotificationStream<PrimitivesTy<Node::Types>>

Canonical state events.

Implementations

impl<Node, Payload, AddOns> NodeTestContext<Node, AddOns>

where Payload: PayloadTypes, Node: FullNodeComponents, Node::Types: NodeTypes<ChainSpec: EthereumHardforks, Payload = Payload>, Node::Network: PeersHandleProvider, AddOns: RethRpcAddOns<Node>,

pub async fn new( node: FullNode<Node, AddOns>, attributes_generator: impl Fn(u64) -> Payload::PayloadAttributes + Send + Sync + 'static, ) -> Result<Self>

Creates a new test node

Payload timestamps start after the default Cancun timestamp of the payload context, or after the timestamp of the latest block if it is newer, e.g. for a custom genesis or an imported chain.

pub async fn connect(&mut self, node: &mut Self)

Establish a connection to the node

pub async fn advance( &mut self, length: u64, tx_generator: impl Fn(u64) -> Pin<Box<dyn Future<Output = Bytes>>>, ) -> Result<Vec<Payload::BuiltPayload>>

where AddOns::EthApi: EthApiSpec<Provider: BlockReader<Block = BlockTy<Node::Types>>> + EthTransactions + TraceExt,

Advances the chain length blocks.

Returns the added chain as a Vec of block hashes.

pub async fn inject_and_advance( &mut self, raw_tx: Bytes, ) -> Result<(B256, Payload::BuiltPayload)>

where AddOns::EthApi: EthApiSpec<Provider: BlockReader<Block = BlockTy<Node::Types>>> + EthTransactions + TraceExt,

Injects the raw transaction into the pool, advances the node one block and waits until the block is committed, returning the transaction hash and the built payload.

Returns an error if the transaction is not included in the block, see Self::assert_new_block.

pub fn current_forkchoice_state(&self) -> Result<ForkchoiceState>

Returns the current forkchoice state of the node.

pub fn set_next_payload_timestamp(&mut self, timestamp: u64) -> Result<()>

Sets the timestamp of the next payload built by Self::new_payload and the methods built on it, such as Self::advance_block.

Later payloads continue from this timestamp, one second apart. The attributes generator is called with the new timestamp, so fork-dependent attributes follow it.

Returns an error if the timestamp is not greater than the timestamp of the current latest block, which is the parent of the next payload.

pub async fn new_payload(&mut self) -> Result<Payload::BuiltPayload>

Creates a new payload from given attributes generator expects a payload attribute event and waits until the payload is built.

It triggers the resolve payload via engine api and expects the built payload event.

pub async fn build_and_submit_payload( &mut self, ) -> Result<Payload::BuiltPayload>

Triggers payload building job and submits it to the engine.

pub async fn advance_block(&mut self) -> Result<Payload::BuiltPayload>

Advances the node forward one block by building a payload and importing it with Self::import_payload.

pub async fn advance_block_synced(&mut self) -> Result<Payload::BuiltPayload>

Advances the node forward one block like Self::advance_block and waits until the transaction pool processed the new block, see Self::wait_for_pool_head.

pub async fn advance_blocks( &mut self, length: u64, ) -> Result<Vec<Payload::BuiltPayload>>

Advances the chain length blocks, see Self::advance_block.

Unlike Self::advance, this does not inject transactions, so the blocks include the pending transactions of the pool, if any.

Returns the built payloads.

pub async fn advance_until_receipt( &mut self, hash: B256, ) -> Result<RpcReceipt<<AddOns::EthApi as EthApiTypes>::NetworkTypes>>

where AddOns::EthApi: EthApiSpec<Provider: BlockReader<Block = BlockTy<Node::Types>>> + EthTransactions + TraceExt + LoadReceipt + 'static,

Advances the chain one block at a time until the transaction with the given hash is included in a canonical block, returning its receipt.

Returns the receipt without advancing if the transaction is already included. Returns an error if the transaction is not included within WAIT_TIMEOUT.

pub async fn advance_while<F: Future>(&mut self, fut: F) -> Result<F::Output>

Drives fut to completion while advancing the chain one block every POLL_INTERVAL, returning its output.

This is useful for futures that only complete once their transaction is mined, e.g. an eth_sendRawTransactionSync request. fut is also polled while a block is built, but the block is always built to completion, so the chain may advance one more block after fut completed.

Returns an error if fut does not complete within WAIT_TIMEOUT.

pub async fn wait_block( &self, number: BlockNumber, expected_block_hash: BlockHash, wait_finish_checkpoint: bool, ) -> Result<()>

Waits for block to be available on node.

Returns an error if the block is not available within WAIT_TIMEOUT.

pub async fn wait_unwind(&self, number: BlockNumber) -> Result<()>

Waits for the node to unwind to the given block number.

Returns an error if the node does not unwind within WAIT_TIMEOUT.

pub async fn wait_for_pool( &self, condition: impl FnMut(&Node::Pool) -> bool, ) -> Result<()>

Waits until condition holds for the transaction pool of the node.

Returns an error if the condition does not hold within WAIT_TIMEOUT.

pub async fn wait_for_pool_head(&self, hash: B256) -> Result<()>

Waits until the transaction pool of the node processed the canonical state update that made the block with the given hash its head.

The pool maintenance task processes new heads in the background, so right after e.g. a forkchoice update the pool can still contain the transactions mined in the new block or use outdated sender nonces and pending fees. The pool updates its last seen block together with these, so they are up to date once this returns. Exceptions are reorgs, after which the maintenance task re-injects the transactions of the old chain only afterwards, so wait for them with Self::wait_for_pool, and commits deeper than the maximum update depth of the maintenance task, e.g. after a long sync, which only update the last seen block.

Returns an error if the pool does not process the block within WAIT_TIMEOUT, e.g. because the block is not the canonical head, the pool already processed a newer head, or the block was synced by backfill, which does not notify the pool.

pub async fn assert_new_block( &mut self, tip_tx_hash: B256, block_hash: B256, block_number: BlockNumber, ) -> Result<()>

Asserts that a new block has been added to the blockchain and the tx has been included in the block, at any position.

Does NOT work for pipeline since there’s no stream notification! Returns an error if the block is not committed within WAIT_TIMEOUT.

pub fn block_hash(&self, number: u64) -> BlockHash

Gets block hash by number.

pub async fn sync_to(&self, block: BlockHash) -> Result<()>

Sends FCU and waits for the node to sync to the given block.

Returns an error if the node does not sync within WAIT_TIMEOUT.

pub async fn update_forkchoice( &self, current_head: B256, new_head: B256, ) -> Result<ForkchoiceUpdated>

Sends a forkchoice update message to the engine and returns its response.

pub async fn update_optimistic_forkchoice( &self, hash: B256, ) -> Result<ForkchoiceUpdated>

Sends forkchoice update to the engine api with a zero finalized hash and returns its response.

pub async fn submit_payload( &self, payload: Payload::BuiltPayload, ) -> Result<B256>

Submits a payload to the engine.

pub async fn import_payload( &self, payload: Payload::BuiltPayload, ) -> Result<B256>

Submits a payload to the engine and makes its block the canonical head, returning the block hash.

The forkchoice update marks the block as head, safe, and finalized block, like Self::advance_block does, so the node can’t reorg to a chain without the block afterwards. The engine only reports the forkchoice update valid after making the head canonical, so the block is the latest block of the node once this returns. The transaction pool processes the new block in the background, see Self::wait_for_pool.

The parent of the payload must be known to the node, e.g. to import a payload built by another node into its peers. Returns an error if the engine does not report the forkchoice update valid, e.g. because the payload is invalid.

pub fn rpc_url(&self) -> Url

Returns the RPC URL.

pub fn rpc_client(&self) -> Option<HttpClient>

Returns an RPC client.

pub fn rpc_provider( &self, ) -> FillProvider<impl TxFiller<Ethereum> + use<Node, Payload, AddOns>, RootProvider>

Returns an alloy provider with the recommended fillers connected to the HTTP RPC server.

Panics

If the HTTP RPC server is disabled.

pub fn rpc_provider_with_wallet<W>( &self, wallet: W, ) -> FillProvider<impl TxFiller<Ethereum> + use<W, Node, Payload, AddOns>, RootProvider>

where W: IntoWallet<Ethereum, NetworkWallet: Clone>,

Returns an alloy provider with the recommended fillers and the given wallet connected to the HTTP RPC server.

Transactions sent via the provider are signed by the wallet, e.g. a PrivateKeySigner of the test Wallet.

Panics

If the HTTP RPC server is disabled.

pub fn rpc_provider_for<Net: RecommendedFillers>( &self, ) -> FillProvider<impl TxFiller<Net> + use<Net, Node, Payload, AddOns>, RootProvider<Net>, Net>

Returns an alloy provider for the network Net with its recommended fillers connected to the HTTP RPC server, polling every RPC_PROVIDER_POLL_INTERVAL.

This is Self::rpc_provider for nodes whose RPC types differ from Ethereum’s.

Panics

If the HTTP RPC server is disabled.

pub fn rpc_provider_with_wallet_for<Net, W>( &self, wallet: W, ) -> FillProvider<impl TxFiller<Net> + use<Net, W, Node, Payload, AddOns>, RootProvider<Net>, Net>

where Net: RecommendedFillers, W: IntoWallet<Net, NetworkWallet: Clone>,

Returns an alloy provider for the network Net with its recommended fillers and the given wallet connected to the HTTP RPC server, polling every RPC_PROVIDER_POLL_INTERVAL.

This is Self::rpc_provider_with_wallet for nodes whose RPC types differ from Ethereum’s.

Panics

If the HTTP RPC server is disabled.

pub fn auth_server_handle(&self) -> AuthServerHandle

Returns an Engine API client.

pub fn to_node_client(&self) -> Result<NodeClient<Payload>>

Creates a crate::testsuite::NodeClient from this test context.

This helper method extracts the necessary handles and creates a client that can interact with both the regular RPC and Engine API endpoints. It automatically includes the beacon engine handle for direct consensus engine interaction and read-only access to the node’s database.

pub async fn testing_build_block_v1( &self, request: TestingBuildBlockRequestV1, ) -> Result<ExecutionPayloadEnvelopeV5>

Calls the testing_buildBlockV1 RPC on this node.

This endpoint builds a block using the provided parent, payload attributes, and transactions. Requires the Testing RPC module to be enabled.

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.