Function run_node_inner

node/src/args.rs:229–429

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

    /// Observer mode: RPC-only node that follows the chain without proposing or voting on blocks.
    /// The value is a derivation index that produces a distinct identity from the base node key.
    #[arg(long)]
    pub observer: Option<u32>,

    /// Hard cap on unique deferred notarized blocks while the execution layer is SYNCING.
    #[arg(long, default_value_t = FINALIZER_PENDING_NOTARIZED_MAX)]
    pub finalizer_pending_notarized_max: usize,
}

impl Command {
    pub fn exec(&self) {
        match self {
            Command::Run { flags } => self.run_node(flags),
            Command::DepositRpc { flags } => self.run_deposit_rpc(flags),
            Command::Keys(cmd) => cmd.exec(),

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

    fn run_deposit_rpc(&self, flags: &DepositRpcFlags) {
        let _critical_log_guard = crate::telemetry::init(Level::INFO, None);
        let genesis = Genesis::load_from_file(&flags.genesis_path)
            .unwrap_or_else(|e| panic!("Failed to load genesis file: {e}"));

        // Validate that both validator keys are present before accepting requests.
        let _key_store = expect_key_store(&flags.key_store_path);

        let key_store_path = flags.key_store_path.clone();
        let genesis_hash = genesis.genesis_hash();
        let namespace = genesis.namespace.into_bytes();
        let port = flags.port;
        let executor = tokio::Runner::default();

        executor.start(|context| async move {
            start_deposit_rpc_server(
                key_store_path,
                genesis_hash,
                namespace,
                port,
                RpcBodyLimits::default(),
                context.stopped(),
            )
            .await
            .unwrap_or_else(|e| panic!("Deposit RPC server failed: {e}"));
        });
    }

    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 {