Struct E2ETestSetupBuilder 

pub struct E2ETestSetupBuilder<N: NodeBuilderHelper> { /* private fields */ }

Builder for configuring and launching test node setups.

By default, the nodes:

• are Default instances of N, see Self::with_node,
• run on a shared Runtime::test runtime, unless they are restartable,
• build payloads with eth_payload_attributes for the hardforks active in the chain spec, unless created with Self::new_with_attributes_generator,
• have discovery disabled, use unused ports and serve all RPC modules except testing over HTTP,
• report an idle sync state from startup, so they gossip transactions before their first block,
• do not persist their peers, so a restarted node only connects to the peers a test connects it to,
• are connected to each other.

Once launched, each node receives a forkchoice update that makes genesis the head, safe and finalized block, unless dev mining is enabled.

Configuration and tree configuration modifiers are applied in the order they are added. Like for a node launched from the command line, the tree configuration of a node is derived from its final node configuration, see NodeConfig::tree_config, so the engine arguments and --debug.skip-state-root set by node configuration modifiers take effect. Tree configuration modifiers are applied last and take precedence over them.

Use E2ETestSetupExt::test_setup_for to set up nodes on the test_chain_spec at a hardfork, or E2ETestSetupExt::test_setup for any other chain spec:

let (mut node, wallet) = EthereumNode::test_setup_for(EthereumHardfork::Cancun)
    .with_tree_config_modifier(|config| config.with_persistence_threshold(0))
    .build_single()
    .await?;

Implementations

impl E2ETestSetupBuilder<EthereumNode>

pub fn with_snap_control(self, control: &SnapControl) -> Self

Wraps the backfill chosen by the node configuration with control.

impl<N: NodeBuilderHelper> E2ETestSetupBuilder<N>

pub fn new(num_nodes: usize, chain_spec: Arc<N::ChainSpec>) -> Self

where PayloadAttrTy<N>: From<PayloadAttributes>,

Creates a new builder for num_nodes nodes of the given chain.

The nodes build payloads with eth_payload_attributes for the chain spec, which requires the payload attributes of the node to be convertible from Ethereum’s. Use Self::new_with_attributes_generator for other nodes.

pub fn new_with_attributes_generator<G>( num_nodes: usize, chain_spec: Arc<N::ChainSpec>, attributes_generator: G, ) -> Self

where G: Fn(u64) -> PayloadAttrTy<N> + Send + Sync + 'static,

Creates a new builder for num_nodes nodes of the given chain, whose payloads are built with the attributes returned by attributes_generator, see Self::with_attributes_generator.

Unlike Self::new, this does not require the payload attributes of the node to be convertible from Ethereum’s.

pub const fn with_num_nodes(self, num_nodes: usize) -> Self

Sets the number of nodes to launch.

pub fn with_runtime(self, runtime: Runtime) -> Self

Launches the nodes on the given runtime instead of a new Runtime::test.

This lets multiple setups, or other components of a test, share the same tokio handle and rayon pools. Note that the tasks of the nodes are only shut down once all handles to the runtime are dropped, not when the nodes are dropped. Restartable nodes, see Self::with_restartable_nodes, can not share a runtime.

pub fn with_attributes_generator<G>(self, generator: G) -> Self

where G: Fn(u64) -> PayloadAttrTy<N> + Send + Sync + 'static,

Sets the generator for the payload attributes of the payloads built by the test nodes.

The generator is called with the timestamp of the next payload. It replaces the generator of the constructor, which is eth_payload_attributes for the chain spec of the setup for Self::new.

pub const fn with_connect_nodes(self, connect_nodes: bool) -> Self

Sets whether nodes should be interconnected (default: true).

pub fn with_tree_config_modifier<G>(self, modifier: G) -> Self

where G: Fn(TreeConfig) -> TreeConfig + Send + Sync + 'static,

Adds a modifier for the tree configuration.

The closure receives the current tree config and returns a modified version. The base config is derived from the node configuration after all node configuration modifiers ran, see NodeConfig::tree_config. Unless a node configuration modifier changes engine.cross_block_cache_size, it uses a small cross block cache of 1 MiB.

pub fn with_node_config_modifier<G>(self, modifier: G) -> Self

where G: Fn(NodeConfig<N::ChainSpec>) -> NodeConfig<N::ChainSpec> + Send + Sync + 'static,

Adds a modifier for the node configuration.

The closure receives the current node config and returns a modified version. Its engine arguments and debug.skip_state_root configure the engine tree, unless a tree configuration modifier overrides them.

pub fn with_rpc_modifier<G>(self, modifier: G) -> Self

where G: Fn(RpcServerArgs) -> RpcServerArgs + Send + Sync + 'static,

Adds a modifier for the RPC server arguments.

The closure receives the current arguments, which serve all modules except testing over HTTP on an unused port.

pub fn with_pruning(self, pruning: PruningArgs) -> Self

Sets the pruning arguments for the test nodes.

pub const fn with_storage_v2(self, storage_v2: bool) -> Self

Sets whether nodes use the v2 storage layout (--storage.v2), which routes tx hashes, history indices, etc. to RocksDB and changesets/senders to static files.

Defaults to the node’s --storage.v2 default. Node config modifiers run afterwards and can still override it.

pub fn with_dev_mode(self, dev: bool) -> Self

Sets whether the nodes run in dev mode (--dev).

Unlike dev mining, this only sets the dev flag and does not start a local miner.

pub fn with_dev_mining(self, block_time: Option<Duration>) -> Self

where N: DebugNode<Adapter<N>>,

Launches the node in dev mode with a local miner that builds a block every block_time, or as soon as a transaction is pending if None.

Dev mining is limited to a single node, since every node would mine its own chain. The local miner drives forkchoice and payload building, so the node does not receive the initial forkchoice update to genesis, and the block producing helpers of NodeTestContext, e.g. NodeTestContext::advance_block and NodeTestContext::update_forkchoice, must not be used. Use Self::map_dev_payload_attributes to customize the payload attributes of the mined blocks.

pub fn map_dev_payload_attributes<G>(self, map: G) -> Self

where G: Fn(PayloadAttrTy<N>) -> PayloadAttrTy<N> + Send + Sync + 'static,

Maps the payload attributes of the blocks built by the local miner of dev mining nodes, e.g. to set the fee recipient.

Mappers are applied in the order they are added. Has no effect unless dev mining is enabled.

pub fn with_backfill<F, B>(self, backfill: F) -> Self

where F: Fn(&NodeConfig<N::ChainSpec>) -> B + Send + Sync + 'static, B: BackfillSyncBuilder<NodeTypesWithDBAdapter<N, TmpDB>, BackfillClientFor<FullNodeTypesAdapter<N, TmpDB, BlockchainProvider<NodeTypesWithDBAdapter<N, TmpDB>>>, ComponentsFor<FullNodeTypesAdapter<N, TmpDB, BlockchainProvider<NodeTypesWithDBAdapter<N, TmpDB>>>>>> + 'static,

Launches each node with the engine’s backfill built by the BackfillSyncBuilder that backfill returns for the node’s final configuration, instead of the staged pipeline.

Like a node launched from the command line, the backfill follows the node’s flags, e.g. with_backfill(EthereumBackfill::new) snap syncs once a node configuration modifier sets --snap.v2. A restarted node builds its backfill again from its configuration.

Cannot be combined with dev mining: the harness launches dev mining nodes with the staged pipeline.

pub fn with_node<F>(self, node: F) -> Self

where F: Fn(usize) -> N + Send + Sync + 'static,

Sets the factory of the node instances, which is called with the index of each node when it is launched.

Defaults to Default::default. Use this to configure the node type, or to keep a handle of the node instance, e.g. one that reads state of the node once it is launched.

pub fn with_node_builder_modifier<G>(self, modifier: G) -> Self

where G: Fn(TestNodeBuilder<N>) -> TestNodeBuilder<N> + Send + Sync + 'static,

Adds a modifier for the node builder of each test node.

The closure receives the TestNodeBuilder after the node types, components and add-ons are configured, and returns it to be launched. It can e.g. install an ExEx with install_exex, extend the RPC modules with extend_rpc_modules, set the on_component_initialized, on_node_started and on_rpc_started hooks, or modify the add-ons with map_add_ons.

Modifiers are applied to every node in the order they are added. The node builder keeps a single hook of each kind, so a modifier that sets e.g. the extend_rpc_modules hook replaces the one set by an earlier modifier. The datadir and tree configuration of the node are derived before the modifiers run, so change the node configuration with Self::with_node_config_modifier instead of builder.config.

pub const fn with_restartable_nodes(self) -> Self

Makes the nodes restartable, so they can be stopped and launched again on the same datadir with NodeTestContext::stop and NodeTestContext::restart.

Each restartable node runs on a Runtime::test runtime of its own instead of the shared one, so stopping it shuts down only its tasks. This costs a few threads per node, which is why nodes are not restartable by default. Conflicts with Self::with_runtime.

pub async fn build(self) -> Result<(Vec<NodeHelperType<N>>, Wallet)>

Builds and launches the test nodes.

pub async fn build_single(self) -> Result<(NodeHelperType<N>, Wallet)>

Builds and launches a single test node.

Returns an error if the builder was not configured with exactly one node.

Trait Implementations

impl<N: NodeBuilderHelper> Debug for E2ETestSetupBuilder<N>

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

Formats the value using the given formatter.

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: 184 bytes