Function run_node_inner

node/src/args.rs:229–429

(
    context: tokio::Context,
    flags: RunFlags,
    key_store: KeyStore<PrivateKey>,
    loaded: LoadedCheckpoint<MultisigScheme>,
)

            Command::Keys(cmd) => cmd.exec(),
        }
    }

    pub fn run_node(&self, flags: &RunFlags) {
        // Initialize tokio-console subscriber if feature is enabled
        #[cfg(feature = "tokio-console")]
        {
            console_subscriber::init();
        }

        let loaded = if let Some(checkpoint_path) = &flags.checkpoint_path {
            read_checkpoint::<MultisigScheme>(checkpoint_path, flags.checkpoint_or_default)
        } else {
            LoadedCheckpoint {
                consensus_state: None,
                last_block: None,
                finalized_header: None,
                raw_checkpoint: None,
                finalized_headers_chain: None,
            }
        };
        let store_path = get_expanded_path(&flags.store_path).expect("Invalid store path");

        // Initialize runtime
        let worker_threads = flags
            .worker_threads
            .unwrap_or_else(|| std::thread::available_parallelism().map_or(4, |n| n.get()));
        let cfg = tokio::Config::default()
            .with_tcp_nodelay(Some(true))
            .with_worker_threads(worker_threads)
            .with_storage_directory(store_path)
            .with_catch_panics(false);
        let executor = tokio::Runner::new(cfg);

        let flags = flags.clone();

        executor.start(|context| async move {
            let key_store = expect_key_store(&flags.key_store_path);
            run_node_inner(context, flags, key_store, loaded).await;
        })
    }
}

/// How the configured genesis path looks at startup. Extracted from
/// [`acquire_genesis`] so the present-but-invalid decision can be exercised
/// directly in tests — the live path calls `std::process::exit` on that case,
/// which can't be asserted against in-process.
enum GenesisPathState {
    /// A valid genesis file is already present at the path.
    Valid(Box<Genesis>),
    /// A file exists at the path but does not parse/validate.
    InvalidPresent(String),
    /// No file at the path; first-boot provisioning is required.
    Absent,
}

/// Classify the configured genesis path without side effects (no exit, no RPC).
fn classify_genesis_path(genesis_path: &str) -> GenesisPathState {
    let present = get_expanded_path(genesis_path)