aldabra/crates/aldabra-mcp/src/main.rs

//! aldabra — MCP server entry point.
//!
//! Speaks MCP over stdio. Any MCP client (e.g. Claude Code)
//! launches this as a subprocess and gets a wallet's worth of tools.
//!
//! ## Phase 1 tools (target — server wiring lands in 1.7)
//!
//! - `wallet.address` — derived CIP-1852 base address
//! - `wallet.balance` — ADA + native-asset balance via chain backend
//! - `wallet.utxos`   — list UTXOs at the wallet address
//! - `wallet.network` — configured network selector
//!
//! ## Phase 2-4 tools
//!
//! See `ROADMAP.md` at the repo root.
//!
//! ## Logging
//!
//! Stderr only — stdout is the MCP transport, must stay clean.

mod bootstrap;
mod config;
mod tools;

use std::process::ExitCode;

use anyhow::Result;
use rmcp::{transport::stdio, ServiceExt};
use tracing_subscriber::EnvFilter;

use crate::config::Config;
use crate::tools::WalletService;

#[tokio::main]
async fn main() -> ExitCode {
    tracing_subscriber::fmt()
        .with_writer(std::io::stderr)
        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()))
        .init();

    match run().await {
        Ok(()) => ExitCode::SUCCESS,
        Err(e) => {
            tracing::error!("{e:#}");
            ExitCode::FAILURE
        }
    }
}

async fn run() -> Result<()> {
    let cfg = Config::load()?;
    tracing::info!(
        network = ?cfg.network,
        koios = %cfg.koios_base,
        account = cfg.account,
        index = cfg.index,
        data_dir = %cfg.data_dir.display(),
        "aldabra starting"
    );

    // CLI mode flags — all out-of-band, before the MCP transport
    // takes over stdio.
    //
    // `--generate-mnemonic` — print a fresh phrase, exit. No disk write.
    // `--bootstrap`         — paste an existing phrase, encrypt, derive.
    // `--bootstrap-new`     — generate, display, encrypt, derive (one shot).
    // (none)                — load existing, start MCP server.
    let args: Vec<String> = std::env::args().collect();
    let generate_only = args.iter().any(|a| a == "--generate-mnemonic");
    let bootstrap_only = args.iter().any(|a| a == "--bootstrap");
    let bootstrap_new = args.iter().any(|a| a == "--bootstrap-new");

    if generate_only {
        bootstrap::print_fresh_mnemonic()?;
        return Ok(());
    }

    let mnemonic_path = bootstrap::mnemonic_path(&cfg.data_dir);

    // L-2 audit fix: scope `root` to a block so its XPrv drops + wipes
    // as soon as we've extracted the keys we need.
    let (payment_key, stake_key, address) = {
        let root = if bootstrap_new {
            bootstrap::generate_and_save_root_key(&cfg.data_dir)?
        } else if mnemonic_path.exists() {
            bootstrap::load_or_create_root_key(&cfg.data_dir)?
        } else if bootstrap_only {
            bootstrap::load_or_create_root_key(&cfg.data_dir)?
        } else {
            anyhow::bail!(
                "no mnemonic at {}. run `aldabra --bootstrap` (paste existing) \
                 or `aldabra --bootstrap-new` (generate fresh) first.",
                mnemonic_path.display()
            );
        };

        let address = aldabra_core::derive_base_address(
            &root,
            cfg.network,
            cfg.account,
            cfg.index,
        )?;
        let payment_key =
            aldabra_core::derive_payment_key(&root, cfg.account, cfg.index);
        let stake_key = aldabra_core::derive_stake_key(&root, cfg.account);
        (payment_key, stake_key, address)
        // root drops here — XPrv::Drop wipes the 96 bytes
    };
    tracing::info!(%address, "derived base address");

    if bootstrap_only || bootstrap_new {
        eprintln!("aldabra: bootstrap complete. address = {address}");
        return Ok(());
    }

    // Hand off to the MCP server. From this point on stdin/stdout
    // belong to the JSON-RPC transport — no more eprintln-prompting.
    let service = WalletService::new(
        cfg.network,
        address,
        cfg.koios_base,
        payment_key,
        stake_key,
        cfg.max_send_lovelace,
    );
    let server = service
        .serve(stdio())
        .await
        .map_err(|e| anyhow::anyhow!("rmcp serve failed: {e}"))?;
    server
        .waiting()
        .await
        .map_err(|e| anyhow::anyhow!("rmcp wait failed: {e}"))?;
    Ok(())
}