main.rs

//! ev-dev: one-command local dev chain for ev-reth.
//!
//! Spins up a fully functional Evolve chain with funded accounts,
//! similar to Hardhat Node or Anvil.

#![allow(missing_docs, rustdoc::missing_crate_level_docs)]

mod tui;

use alloy_signer_local::{coins_bip39::English, MnemonicBuilder};
use clap::Parser;
use ev_deployer::{config::DeployConfig, genesis::merge_alloc, output::build_manifest};
use evolve_ev_reth::{
    config::EvolveConfig,
    rpc::txpool::{EvolveTxpoolApiImpl, EvolveTxpoolApiServer},
};
use reth_ethereum_cli::Cli;
use std::{io::Write, path::PathBuf};
use tracing::info;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};

use ev_node::{EvolveArgs, EvolveChainSpecParser, EvolveNode};

#[global_allocator]
static ALLOC: reth_cli_util::allocator::Allocator = reth_cli_util::allocator::new_allocator();

const DEVNET_GENESIS: &str = include_str!("../assets/devnet-genesis.json");
const HARDHAT_MNEMONIC: &str = "test test test test test test test test test test test junk";

fn parse_accounts(s: &str) -> Result<usize, String> {
    let n: usize = s.parse().map_err(|e| format!("{e}"))?;
    if (1..=20).contains(&n) {
        Ok(n)
    } else {
        Err(format!("{n} is not in 1..=20"))
    }
}

/// Local dev chain for ev-reth with pre-funded accounts.
#[derive(Parser, Debug)]
#[command(name = "ev-dev", about = "One-command local Evolve dev chain")]
struct EvDevArgs {
    /// Host to bind HTTP/WS RPC server
    #[arg(long, default_value = "127.0.0.1")]
    host: String,

    /// Port for HTTP/WS RPC server
    #[arg(long, default_value_t = 8545)]
    port: u16,

    /// Block time in seconds (0 = mine on tx)
    #[arg(long, default_value_t = 1)]
    block_time: u64,

    /// Suppress the startup banner
    #[arg(long, default_value_t = false)]
    silent: bool,

    /// Number of accounts to display (1..=20)
    #[arg(long, default_value_t = 10, value_parser = parse_accounts)]
    accounts: usize,

    /// Path to an ev-deployer TOML config to deploy contracts at genesis.
    #[arg(long, value_name = "PATH")]
    deploy_config: Option<PathBuf>,

    /// Launch with terminal UI instead of plain log output
    #[arg(long, default_value_t = false)]
    tui: bool,
}

fn derive_keys(count: usize) -> Vec<(String, String)> {
    (0..count)
        .map(|i| {
            let signer = MnemonicBuilder::<English>::default()
                .phrase(HARDHAT_MNEMONIC)
                .index(i as u32)
                .expect("valid derivation index")
                .build()
                .expect("valid key derivation");
            let address = signer.address();
            let key_bytes = signer.credential().to_bytes();
            (
                format!("{address}"),
                format!("0x{}", alloy_primitives::hex::encode(key_bytes)),
            )
        })
        .collect()
}

fn chain_id_from_genesis() -> u64 {
    let genesis: serde_json::Value =
        serde_json::from_str(DEVNET_GENESIS).expect("valid genesis JSON");
    genesis["config"]["chainId"]
        .as_u64()
        .expect("genesis must have config.chainId")
}

fn print_banner(args: &EvDevArgs, deploy_cfg: Option<&DeployConfig>) {
    let accounts = derive_keys(args.accounts);

    println!();
    println!(r"                       _            ");
    println!(r"                      | |           ");
    println!(r"   _____   _____   __| | _____   __");
    println!(r"  / _ \ \ / /___/ / _` |/ _ \ \ / /");
    println!(r" |  __/\ V /    | (_| |  __/\ V / ");
    println!(r"  \___| \_/      \__,_|\___| \_/  ");
    println!();
    println!("  Evolve Local Development Chain");
    println!("  ==============================");
    println!();
    println!("Chain ID:      {}", chain_id_from_genesis());
    println!("RPC URL:       http://{}:{}", args.host, args.port);
    println!(
        "Block time:    {}",
        if args.block_time == 0 {
            "auto (mine on tx)".to_string()
        } else {
            format!("{}s", args.block_time)
        }
    );
    println!();
    println!("Available Accounts");
    println!("==================");
    for (i, (addr, _)) in accounts.iter().enumerate() {
        println!("({i}) {addr} (1000000 ETH)");
    }
    println!();
    println!("Private Keys");
    println!("==================");
    for (i, (_, key)) in accounts.iter().enumerate() {
        println!("({i}) {key}");
    }
    println!();
    println!("Mnemonic: {HARDHAT_MNEMONIC}");
    println!("Derivation path: m/44'/60'/0'/0/{{index}}");
    println!();

    if let Some(cfg) = deploy_cfg {
        let config_path = args.deploy_config.as_ref().unwrap();
        println!("Genesis Contracts (from {})", config_path.display());
        println!("==================");
        let manifest = build_manifest(cfg);
        if let Some(obj) = manifest.as_object() {
            for (name, addr) in obj {
                println!("  {name:20} {addr}");
            }
        }
        println!();
    }

    println!("WARNING: These accounts and keys are publicly known.");
    println!("Any funds sent to them on mainnet WILL BE LOST.");
    println!();
}

fn build_reth_args(
    dev_args: &EvDevArgs,
    genesis_path: String,
    datadir_path: String,
) -> Vec<String> {
    let mut args = vec![
        "ev-dev".to_string(),
        "node".to_string(),
        "--dev".to_string(),
        "--chain".to_string(),
        genesis_path,
        "--datadir".to_string(),
        datadir_path,
        "--http".to_string(),
        "--http.addr".to_string(),
        dev_args.host.clone(),
        "--http.port".to_string(),
        dev_args.port.to_string(),
        "--http.api".to_string(),
        "eth,net,web3,txpool,debug,trace".to_string(),
        "--http.corsdomain".to_string(),
        "*".to_string(),
        "--ws".to_string(),
        "--ws.addr".to_string(),
        dev_args.host.clone(),
        "--ws.port".to_string(),
        dev_args.port.to_string(),
        "--ws.api".to_string(),
        "eth,net,web3,txpool,debug,trace".to_string(),
        "--disable-discovery".to_string(),
        "--no-persist-peers".to_string(),
        "--port".to_string(),
        "0".to_string(),
    ];

    if dev_args.block_time > 0 {
        args.push("--dev.block-time".to_string());
        args.push(format!("{}s", dev_args.block_time));
    }

    args
}

fn prepare_genesis(
    deploy_cfg: &Option<DeployConfig>,
) -> (tempfile::NamedTempFile, tempfile::TempDir) {
    let genesis_json = if let Some(ref cfg) = deploy_cfg {
        let mut genesis: serde_json::Value =
            serde_json::from_str(DEVNET_GENESIS).expect("valid genesis JSON");
        merge_alloc(cfg, &mut genesis, true).expect("failed to merge deploy config into genesis");
        serde_json::to_string(&genesis).expect("failed to serialize merged genesis")
    } else {
        DEVNET_GENESIS.to_string()
    };

    let mut genesis_file =
        tempfile::NamedTempFile::new().expect("failed to create temp genesis file");
    genesis_file
        .write_all(genesis_json.as_bytes())
        .expect("failed to write genesis");

    let datadir = tempfile::TempDir::new().expect("failed to create temp data dir");

    (genesis_file, datadir)
}

fn load_deploy_config(dev_args: &EvDevArgs) -> Option<DeployConfig> {
    dev_args.deploy_config.as_ref().map(|config_path| {
        let mut cfg = DeployConfig::load(config_path)
            .unwrap_or_else(|e| panic!("failed to load deploy config: {e}"));

        let genesis_chain_id = chain_id_from_genesis();
        if cfg.chain.chain_id != genesis_chain_id {
            eprintln!(
                "WARNING: deploy config chain_id ({}) differs from devnet genesis ({}), overriding to {}",
                cfg.chain.chain_id, genesis_chain_id, genesis_chain_id
            );
            cfg.chain.chain_id = genesis_chain_id;
        }
        cfg
    })
}

fn deploy_contracts_list(deploy_cfg: &Option<DeployConfig>) -> Option<Vec<(String, String)>> {
    deploy_cfg.as_ref().map(|cfg| {
        let manifest = build_manifest(cfg);
        manifest
            .as_object()
            .map(|obj| {
                obj.iter()
                    .map(|(name, addr)| (name.clone(), addr.as_str().unwrap_or("").to_string()))
                    .collect()
            })
            .unwrap_or_default()
    })
}

fn main() {
    reth_cli_util::sigsegv_handler::install();

    if std::env::var_os("RUST_BACKTRACE").is_none() {
        std::env::set_var("RUST_BACKTRACE", "1");
    }

    let dev_args = EvDevArgs::parse();
    let deploy_cfg = load_deploy_config(&dev_args);

    if dev_args.tui {
        run_with_tui(dev_args, deploy_cfg);
    } else {
        run_without_tui(dev_args, deploy_cfg);
    }
}

fn run_without_tui(dev_args: EvDevArgs, deploy_cfg: Option<DeployConfig>) {
    if !dev_args.silent {
        print_banner(&dev_args, deploy_cfg.as_ref());
    }

    let (genesis_file, datadir) = prepare_genesis(&deploy_cfg);
    let genesis_path = genesis_file
        .path()
        .to_str()
        .expect("valid path")
        .to_string();
    let datadir_path = datadir.path().to_str().expect("valid path").to_string();
    let args = build_reth_args(&dev_args, genesis_path, datadir_path);

    let cli = match Cli::<EvolveChainSpecParser, EvolveArgs>::try_parse_from(args) {
        Ok(cli) => cli,
        Err(err) => {
            eprintln!("{err}");
            std::process::exit(2);
        }
    };

    if let Err(err) = cli.run(|builder, _evolve_args| async move {
        info!("=== EV-DEV: Starting local development chain ===");
        let handle = builder
            .node(EvolveNode::new())
            .extend_rpc_modules(move |ctx| {
                let evolve_cfg = EvolveConfig::default();
                let evolve_txpool =
                    EvolveTxpoolApiImpl::new(ctx.pool().clone(), evolve_cfg.max_txpool_bytes);
                ctx.modules.merge_configured(evolve_txpool.into_rpc())?;
                Ok(())
            })
            .launch_with_debug_capabilities()
            .await?;

        info!("=== EV-DEV: Local chain running - RPC ready ===");
        handle.node_exit_future.await
    }) {
        eprintln!("Error: {err:?}");
        std::process::exit(1);
    }
}

fn run_with_tui(dev_args: EvDevArgs, deploy_cfg: Option<DeployConfig>) {
    let (log_tx, log_rx) = tokio::sync::mpsc::channel(10_000);

    // Install our tracing subscriber with the TUI layer BEFORE cli.run().
    // When reth's internal init_tracing calls try_init(), it will find a
    // subscriber already installed and silently skip its own setup.
    let tui_layer = tui::TuiTracingLayer::new(log_tx);
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into());

    tracing_subscriber::registry()
        .with(filter)
        .with(tui_layer)
        .init();

    let chain_id = chain_id_from_genesis();
    let rpc_url = format!("http://{}:{}", dev_args.host, dev_args.port);
    let block_time = dev_args.block_time;
    let accounts = derive_keys(dev_args.accounts);
    let contracts = deploy_contracts_list(&deploy_cfg);

    let (balance_tx, balance_rx) = tokio::sync::mpsc::channel(16);
    let app = tui::App::new(
        chain_id,
        rpc_url.clone(),
        block_time,
        accounts.clone(),
        contracts,
        log_rx,
        balance_rx,
    );

    let (genesis_file, datadir) = prepare_genesis(&deploy_cfg);
    let genesis_path = genesis_file
        .path()
        .to_str()
        .expect("valid path")
        .to_string();
    let datadir_path = datadir.path().to_str().expect("valid path").to_string();
    let args = build_reth_args(&dev_args, genesis_path, datadir_path);

    let cli = match Cli::<EvolveChainSpecParser, EvolveArgs>::try_parse_from(args) {
        Ok(cli) => cli,
        Err(err) => {
            eprintln!("{err}");
            std::process::exit(2);
        }
    };

    if let Err(err) = cli.run(|builder, _evolve_args| async move {
        info!("=== EV-DEV: Starting local development chain (TUI) ===");
        let _handle = builder
            .node(EvolveNode::new())
            .extend_rpc_modules(move |ctx| {
                let evolve_cfg = EvolveConfig::default();
                let evolve_txpool =
                    EvolveTxpoolApiImpl::new(ctx.pool().clone(), evolve_cfg.max_txpool_bytes);
                ctx.modules.merge_configured(evolve_txpool.into_rpc())?;
                Ok(())
            })
            .launch_with_debug_capabilities()
            .await?;

        info!("=== EV-DEV: Local chain running - RPC ready ===");

        tui::spawn_balance_poller(rpc_url, accounts, balance_tx);
        tui::run(app).await?;

        Ok(())
    }) {
        let _ = tui::restore_terminal();
        eprintln!("Error: {err:?}");
        std::process::exit(1);
    }
}