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 engine: EngineTestContext<<Node::Types as NodeTypes>::Payload>,
    pub canonical_stream: CanonStateNotificationStream<PrimitivesTy<Node::Types>>,
    /* private fields */
}

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.

engine: EngineTestContext<<Node::Types as NodeTypes>::Payload>

Context for sending payloads and forkchoice updates to the engine independent of the Engine API version.

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 fn inject_and_advance( &mut self, raw_tx: Bytes, ) -> BoxFuture<'_, 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>

Builds a payload on top of the latest block and returns it without submitting it to the engine.

Sends a forkchoice update with the next payload attributes, see Self::set_next_payload_timestamp, and resolves the payload job it starts with PayloadKind::WaitForPending, which waits for the build in progress instead of returning an empty payload. The payload can still contain no transactions, e.g. if the pool had none when the build started. Payload jobs started by others, e.g. by forkchoice updates with payload attributes sent by the test, do not affect this.

Returns an error if the forkchoice update fails or starts no payload job, e.g. because the engine is syncing, or if the payload job fails to build a payload.

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

Triggers payload building job and submits it to the engine.

Returns an error if the engine reports the payload invalid, see Self::submit_payload.

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.

The block becomes the head, the safe and finalized blocks follow the Finality policy of the context.

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.

This only waits for the canonical state update of the pool itself, which removes the transactions mined in the block and updates sender nonces and pending fees. Nodes that run additional pool maintenance tasks on new blocks have to wait for the expected contents of the pool instead, e.g. with Self::wait_for_pool_removal for the mined transactions.

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 build_payload_on( &mut self, parent: B256, ) -> Result<Payload::BuiltPayload>

Builds a payload on the block with the given hash with the next payload attributes and returns it without submitting it, like Self::new_payload does for the head.

The payload job is started with a forkchoice update to parent that keeps the safe and finalized blocks of the node. Its effect depends on parent:

• The head, or a canonical ancestor of it that is not below the finalized block: the head stays, the engine builds on parent without changing the canonical chain. The exception is a tree config with both always_process_payload_attributes_on_canonical_head and unwind_canonical_header, under which the engine moves the head back to an ancestor.
• A block on a side chain: the engine first makes the side chain canonical, so parent becomes the head, reorging the chain.
• A canonical block below the finalized block, or a side chain block that does not descend from the finalized block: the engine rejects the update and this returns an error, the head stays. Blocks imported under Finality::Head are finalized, import them under Finality::Keep or Finality::Lag to build on them later, see Self::set_finality.
• A block the node does not know: the engine starts no payload job and requests the block from its peers, and this returns an error.

The payload includes transactions of the pool, which tracks the head: transactions mined in the blocks above parent are not in the pool anymore, so the payload does not include them, and pool transactions that are invalid on parent are skipped.

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

Builds a block on the block with the given hash and imports it with Self::import_payload, so it becomes the head.

If parent is not the head, this reorgs the chain, so parent must be the finalized block or descend from it, see Self::build_payload_on. The safe and finalized blocks follow the Finality policy of the context. The transaction pool processes the reorg in the background, see Self::reorg_to.

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

Builds a chain of length blocks on the block with the given hash and makes its tip the head, see Self::advance_block_on.

The first block is built on parent and each further block on the previous one, so this reorgs the chain if parent is not the head. Returns the built payloads, does nothing for a length of 0.

pub fn advance_until_receipt( &mut self, hash: B256, ) -> BoxFuture<'_, 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_until_pool_drained( &mut self, ) -> Result<Vec<Payload::BuiltPayload>>

Advances the chain one block at a time until the transaction pool has no pending transactions left, returning the built payloads.

Pending transactions are the ones the pool considers ready for the next block, which the payload builder picks from. This does not wait for the other transactions of the pool, which stay in it: queued transactions, e.g. behind a nonce gap, and transactions whose fee cap is below the base fee or blob fee of the next block. Transactions that become pending once a built block is processed, e.g. because it lowered the base fee, are included in the following blocks. The pool decides when to stop, not the content of the blocks, since payload builders can add transactions of their own that are not pool transactions.

The pool processes new blocks in the background, so this waits until it processed the current head before it looks at the pool, see Self::wait_for_pool_head, and advances with Self::advance_block_synced. No block is built once the pool has no pending transactions: the last payload is the block after which none were left, not an extra empty block, and no payload is returned if the pool has none to begin with.

Returns an error if the pool does not process the current head within WAIT_TIMEOUT, e.g. because it was synced by backfill, or, listing them, if pending transactions are left after WAIT_TIMEOUT, e.g. because the payload builder skips them.

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 fn mine( &mut self, txs: impl IntoIterator<Item = Bytes>, ) -> MinedBlockFuture<'_, Payload::BuiltPayload, RpcReceipt<<AddOns::EthApi as EthApiTypes>::NetworkTypes>>

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

Injects the raw transactions into the pool in the given order, advances the node one block and returns the mined block with the receipts of the transactions.

The block must include all given transactions, in any order, and no other transaction of the pool, so a transaction that is dropped or that rides along fails instead of going unnoticed. An empty txs mines a block without pool transactions. Transactions that the payload builder adds by itself, e.g. from the payload attributes, are not pool transactions and may be included. Use Self::mine_including if other pool transactions may be included too.

The receipts are in the order of txs and can report reverted transactions, see MinedBlock::ensure_success. The committed chain segment is taken from Self::canonical_stream, whose notifications up to the one of the mined block are consumed, so the stream does not need to be aligned with the mined blocks before.

The block is imported with Self::import_payload, so the transaction pool processes it in the background, see Self::advance_block_synced.

Returns an error if the pool rejects a transaction, or, without importing the block, if the block does not include the expected transactions, listing the missing and the unexpected ones.

Use Self::mine_pooled for transactions that are already in the pool, e.g. sent through Self::rpc_provider_with_wallet or added with the pool API, and Self::mine_signed for signed transactions that should all succeed.

The helpers that drive the eth API return boxed futures: with the new trait solver, awaiting the unboxed future makes every caller borrow-check its whole state machine, which dominates compile time for nodes with large eth API impls.

pub fn mine_including( &mut self, txs: impl IntoIterator<Item = Bytes>, ) -> MinedBlockFuture<'_, Payload::BuiltPayload, RpcReceipt<<AddOns::EthApi as EthApiTypes>::NetworkTypes>>

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

Mines the raw transactions like Self::mine, but the block may also include other transactions of the pool, e.g. transactions that peers gossiped to the node.

Only the receipts of the given transactions are returned.

pub fn mine_signed<T: Encodable2718>( &mut self, txs: impl IntoIterator<Item = T>, ) -> MinedBlockFuture<'_, Payload::BuiltPayload, RpcReceipt<<AddOns::EthApi as EthApiTypes>::NetworkTypes>>

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

Mines the signed transactions like Self::mine and returns an error if one of them reverted, see MinedBlock::ensure_success.

The transactions are EIP-2718 encoded before they are sent to the pool, so signed transactions or envelopes, e.g. of a custom transaction type, can be passed without encoding them first.

pub fn mine_pooled( &mut self, hashes: impl IntoIterator<Item = B256>, ) -> MinedBlockFuture<'_, Payload::BuiltPayload, RpcReceipt<<AddOns::EthApi as EthApiTypes>::NetworkTypes>>

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

Mines the transactions with the given hashes like Self::mine, for transactions that are already in the pool, e.g. sent through Self::rpc_provider_with_wallet or added with the pool API.

The receipts are in the order of hashes.

Before building a block, returns an error naming the first hash that is not in the pool, e.g. of a transaction that was already mined or replaced. Transactions in any sub-pool pass this check, not only pending ones, since the pool sorts transactions for its own view of the next block, which can lag behind the block that is built. A transaction the block can not include, e.g. one queued behind a nonce gap, is reported as missing like with Self::mine.

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_pooled, 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.

This only covers the canonical state update of the pool itself. Nodes can run additional pool maintenance tasks on new blocks, e.g. to remove mined transactions from a separate sub-pool or to evict transactions by their own rules, and the pool can report the new head before these processed the block. Tests of such nodes have to wait for the expected contents of the pool instead, with Self::wait_for_pool_removal, Self::wait_for_pooled or Self::wait_for_pool.

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 wait_for_pooled( &self, hashes: impl IntoIterator<Item = B256>, ) -> Result<()>

Waits until all transactions with the given hashes are in the transaction pool of the node.

The transactions must be in the pool at the same time, so this keeps waiting if one of them leaves the pool again, e.g. because it is mined or replaced, before the others entered.

Returns an error listing the transactions that are still missing if they are not all in the pool within WAIT_TIMEOUT.

pub async fn wait_for_pool_removal( &self, hashes: impl IntoIterator<Item = B256>, ) -> Result<()>

Waits until none of the transactions with the given hashes is in the transaction pool of the node, regardless of why they left, e.g. because they were mined, replaced or evicted.

Unlike Self::wait_for_pool_head, this does not depend on which task removes the transactions, so it also covers nodes with additional pool maintenance tasks. It returns right away for transactions that never entered the pool, so wait for transactions that arrive in the background, e.g. from peers, with Self::wait_for_pooled first.

Returns an error listing the transactions that are still pooled if they do not all leave the pool within WAIT_TIMEOUT.

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

Waits until the node has persisted at least the block with the given number to disk.

The engine keeps the most recent blocks in memory, so tests that inspect the database directly, e.g. via assert_trie_consistency, must first advance the chain far enough and wait for the persistence service to catch up. This checks the Finish stage checkpoint of the database, which is committed together with the saved blocks, so all blocks up to number are readable from disk once this returns. Their state and trie are committed in the same transaction, unless the engine keeps the state of the most recently persisted blocks masked by its in-memory suffix (TreeConfig::num_state_masking_blocks, disabled by a persistence threshold of 0), in which case the persisted state can lag behind number. The pruner runs after the save in a separate commit, so pruning of the saved blocks can still be pending, wait for it with Self::wait_for_prune_checkpoint.

Unlike Self::wait_block, this does not check the block hash, so it also returns if the persisted block at number is not canonical anymore.

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

pub async fn wait_for_prune_checkpoint( &self, segment: PruneSegment, block: BlockNumber, ) -> Result<()>

Waits until the pruner has pruned segment of the node up to at least the block with the given number.

The persistence service acknowledges a save before it runs the pruner for the new database tip in a separate commit, so a block being persisted, e.g. awaited with Self::wait_for_persisted_block, does not mean the pruner has run for it yet. The pruner saves the checkpoint of a segment in the same provider commit as the pruned data, which commits static files and RocksDB before the database transaction, so the data of segment up to block is pruned once this returns.

Returns an error if the segment is not pruned within WAIT_TIMEOUT, e.g. because the node is not configured to prune it or block is within its retention window.

pub async fn wait_for_head(&self, hash: BlockHash) -> Result<()>

Waits until the block with the given hash is the latest block of the node, i.e. its canonical head.

This only observes the node and sends nothing to the engine, so the block has to become the head otherwise, e.g. through a forkchoice update the test sent itself, which may start a backfill sync to the block. Self::sync_to instead keeps sending forkchoice updates that make the block the head, safe and finalized block until it is the head, and then waits briefly for the transaction pool, which this does not, see Self::wait_for_pool_head. Self::wait_block waits for the header at a block number, which a canonical block that is not the head also satisfies, and after a backfill sync it can return before the engine made the synced block its head, even when it waits for the Finish checkpoint of the pipeline.

Returns an error naming the head of the node if the block is not the head within WAIT_TIMEOUT, e.g. because the node made another block its head.

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 fn snap_attempt(&self) -> Result<SnapAttempt>

where <Node::Provider as DatabaseProviderFactory>::Provider: MetadataProvider,

Returns the snap attempt the node persisted.

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

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

The forkchoice update makes the block the head, safe and finalized block, regardless of the Finality policy of the context. Returns an error if the node does not sync within WAIT_TIMEOUT.

pub async fn sync_to_forkchoice(&self, state: ForkchoiceState) -> Result<()>

Sends the forkchoice update state and waits for the node to sync to its head, like Self::sync_to, but with the safe and finalized blocks of state.

A finalized block below the head, e.g. one the node does not know yet, lets a backfill anchor to it, as a snap sync anchors its pivot to the finalized 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.

The update makes new_head the head and current_head the safe and finalized block, regardless of the Finality policy of the context.

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 with newPayload and returns its block hash.

This only inserts the block, it does not make it canonical, see Self::import_payload. Returns the block hash if the engine reports the payload:

• VALID: the engine executed the block on top of its parent, or knew it as valid already.
• SYNCING or ACCEPTED: the engine did not execute the block, e.g. because its parent is unknown, so the block is not known to be valid yet, see Self::submit_payload_with_status.

Returns an error with the validation error and the latest valid hash if the engine reports the payload INVALID. Use Self::submit_payload_with_status to inspect the status instead, e.g. to test that a payload is rejected.

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

Submits a payload to the engine with newPayload and returns the payload status the engine reports.

Unlike Self::submit_payload, this returns INVALID statuses instead of an error. This only inserts the block, it does not make it canonical. The engine reports:

• VALID if it executed the block on top of its parent, or knew it as valid already. The latest valid hash is the block hash.
• INVALID if the block failed validation, or descends from a block that did. The latest valid hash is the hash of the most recent valid ancestor, or None if the engine can’t determine it, e.g. because the block hash does not match the payload.
• SYNCING if it did not execute the block because the parent of the block is unknown, in which case it buffers the block and executes it once the parent is inserted, or because the node is syncing.
• ACCEPTED if it accepted the block without executing it. The reth engine tree does not report this status.

Returns an error if the engine fails to process the payload, e.g. because it shut down.

pub const fn set_finality(&mut self, finality: Finality)

Sets which blocks Self::import_payload and the block producing helpers built on it, such as Self::advance_block, mark as safe and finalized, see Finality.

The policy applies from the next imported block on, the current safe and finalized blocks are not changed. Defaults to Finality::Head.

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 safe and finalized blocks according to the Finality policy of the context, see Self::set_finality. Under the default Finality::Head, the block also becomes the safe and finalized block, so only a forkchoice update that moves the finalized block to another chain can reorg it. 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 reports the payload invalid, see Self::submit_payload, or does not report the forkchoice update valid, e.g. because the parent is unknown, or because the block does not descend from the safe and finalized blocks that Finality::Keep and Finality::Lag keep.

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

Makes the known block with the given hash the head of the node, keeping its safe and finalized blocks, and returns once the block is the latest block.

The engine makes a block on a side chain canonical, which reorgs the chain, e.g. back to a chain the node left with Self::advance_fork. This requires the block to descend from the finalized block, so blocks imported under Finality::Head can’t be reorged away from, import them under Finality::Keep or Finality::Lag, see Self::set_finality. The engine does not move the head back to a canonical ancestor, so this returns an error for those, build a block on the ancestor with Self::advance_block_on instead.

The transaction pool processes the reorg in the background: once Self::wait_for_pool_head returns for the block, the pool has removed the transactions mined in the new chain and updated sender nonces and fees to it, while the maintenance task re-injects the transactions of the reorged blocks only afterwards, wait for them with Self::wait_for_pool.

Returns an error if the node does not know the block or one of its ancestors, if the block is invalid, or if it does not descend from the safe and finalized blocks.

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<TestingBuildBlockResponseV1>

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.

pub async fn stop(self) -> Result<StoppedNode<Node, AddOns>>

Stops the node and closes its database, keeping its datadir to launch the node again with StoppedNode::start.

The node shuts down like a node that receives SIGTERM: the engine persists every block of its canonical chain together with its state, and the tasks of the node exit. Blocks that are not canonical, e.g. payloads that were only submitted with Self::submit_payload, are lost. Local transactions of the pool are saved to the datadir and reinserted when the node starts again.

Returns once the node released its database, so the database, static files and RocksDB are closed and nothing writes to the datadir anymore, including the pruner that runs after the last save. Peers of the node notice the disconnect in the background.

Only restartable nodes, see E2ETestSetupBuilder::with_restartable_nodes, can be stopped. Returns an error for other nodes, if the node does not shut down within WAIT_TIMEOUT, or if the test keeps the database open:

• a handle of the node that holds its database, e.g. a clone of inner.provider or a NodeClient, makes this fail once the database is still in use DATABASE_RELEASE_TIMEOUT after the node shut down,
• an open database transaction, e.g. a provider of database_provider_ro, makes this fail right away,
• a handle of RocksDB, e.g. of inner.provider.rocksdb_provider(), makes this fail once RocksDB is still open DATABASE_RELEASE_TIMEOUT after the node shut down.

Drop such handles before stopping the node.

pub async fn stop_with_release_timeout( self, release_timeout: Duration, ) -> Result<StoppedNode<Node, AddOns>>

Stops the node like Self::stop, but waits at most release_timeout instead of DATABASE_RELEASE_TIMEOUT for the database and RocksDB to be released.

pub async fn restart(self) -> Result<Self>

Stops the node with Self::stop and starts it again with StoppedNode::start, returning its new test context.

pub fn take_exit_future(&mut self) -> Option<NodeExitFuture>

Takes the future that resolves when the consensus engine of the node exits.

It resolves with an error if the engine exits because of a fatal error, and with Ok once the node is stopped, so a test can use it to notice a node that died. Returns None if the future was already taken or the node was not launched by E2ETestSetupBuilder.

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.