Method new

crates/execution/runner/src/test_utils/node.rs:63–142

Launch a new local node with the provided extensions and chain spec.

(
        extensions: Vec<Box<dyn BaseNodeExtension>>,
        chain_spec: Arc<BaseChainSpec>,
    )

impl LocalNode {
    /// Launch a new local node with the provided extensions and chain spec.
    pub async fn new(
        extensions: Vec<Box<dyn BaseNodeExtension>>,
        chain_spec: Arc<BaseChainSpec>,
    ) -> Result<Self> {
        let exec = Runtime::test();

        let network_config = NetworkArgs {
            discovery: DiscoveryArgs { disable_discovery: true, ..DiscoveryArgs::default() },
            ..NetworkArgs::default()
        };

        let unique_ipc_path = format!(
            "/tmp/reth_engine_api_{}_{}_{:?}.ipc",
            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos(),
            std::process::id(),
            std::thread::current().id()
        );

        let mut rpc_args =
            RpcServerArgs::default().with_unused_ports().with_http().with_auth_ipc().with_ws();
        rpc_args.auth_ipc_path = unique_ipc_path;

        let base_node = BaseNode::new(RollupArgs::default());

        let (db, db_path) = Self::create_test_database()?;

        let mut node_config = NodeConfig::new(Arc::clone(&chain_spec))
            .with_network(network_config)
            .with_rpc(rpc_args)
            .with_unused_ports();

        // The Engine API test harness builds blocks back-to-back and expects each canonical head to
        // be immediately usable as the next payload parent. Persist canonical blocks immediately so
        // follow-up payload validation can resolve parent headers from the database-backed paths
        // that reth 2.3.0 now consults during state-root/proof work.
        node_config.engine.persistence_threshold = 0;

        let datadir_path = MaybePlatformPath::<DataDirPath>::from(db_path.clone());
        node_config = node_config
            .with_datadir_args(DatadirArgs { datadir: datadir_path, ..Default::default() });

        let builder = NodeBuilder::new(node_config.clone())
            .with_database(db)
            .with_launch_context(exec.clone())
            .with_types_and_provider::<BaseNode, BlockchainProvider<_>>()
            .with_components(base_node.components())
            .with_add_ons(base_node.add_ons())
            .on_component_initialized(move |_ctx| Ok(()));

        let NodeHandle { node: node_handle, node_exit_future } = extensions
            .into_iter()
            .fold(NodeHooks::new(), |b, ext| ext.apply(b))
            .apply_to(builder)
            .launch()
            .await?;

        let http_api_addr = node_handle
            .rpc_server_handle()