espresso_node/

options.rs

#![allow(clippy::needless_lifetimes)]

use core::fmt::Display;
use std::{
    cmp::Ordering,
    collections::HashSet,
    fmt::{self, Formatter},
    iter::once,
    num::NonZeroU64,
    path::PathBuf,
    time::Duration,
};

use anyhow::Context;
use clap::{Args, FromArgMatches, Parser, error::ErrorKind};
use derivative::Derivative;
use espresso_telemetry::TelemetryOptions;
use espresso_types::{BackoffParams, L1ClientOptions, parse_duration};
use espresso_utils::logging;
use hotshot_types::addr::NetAddr;
use light_client::{
    state::LightClientOptions,
    storage::{LightClientDbOptions, LightClientSqliteOptions},
};
use serde::Serialize;
use url::Url;

use crate::{
    CatchupParams, api,
    follower::{FollowerOptions, FollowerParams},
    genesis::{Genesis, GenesisSource},
    keyset::KeySetOptions,
    persistence,
    proposal_fetcher::ProposalFetcherConfig,
};

// This options struct is a bit unconventional. The sequencer has multiple optional modules which
// can be added, in any combination, to the service. These include, for example, the API server.
// Each of these modules has its own options, which are all required if the module is added but can
// be omitted otherwise. Clap doesn't have a good way to handle "grouped" arguments like this (they
// have something called an argument group, but it's different). Sub-commands do exactly this, but
// you can't have multiple sub-commands in a single command.
//
// What we do, then, is take the optional modules as if they were sub-commands, but we use a Clap
// `raw` argument to collect all the module commands and their options into a single string. This
// string is then parsed manually (using a secondary Clap `Parser`, the `SequencerModule` type) when
// the user calls `modules()`.
//
// One slightly unfortunate consequence of this is that the auto-generated help documentation for
// `SequencerModule` is not included in the help for this top-level type. Users can still get at the
// help for individual modules by passing `help` as a subcommand, as in
// `sequencer [options] -- help` or `sequencer [options] -- help <module>`. This means that IT IS
// BEST NOT TO ADD REQUIRED ARGUMENTS TO THIS TYPE, since the required arguments will be required
// even if the user is only asking for help on a module. Try to give every argument on this type a
// default value, even if it is a bit arbitrary.
#[derive(Parser, Clone, Derivative)]
#[derivative(Debug(bound = ""))]
#[command(version = build_version())]
pub struct Options {
    /// URL of the HotShot orchestrator.
    #[clap(
        short,
        long,
        env = "ESPRESSO_NODE_ORCHESTRATOR_URL",
        default_value = "http://localhost:8080"
    )]
    #[derivative(Debug(format_with = "Display::fmt"))]
    pub orchestrator_url: Url,

    /// The address to bind to for cliquenet (in `host:port` | `ip:port` form)
    #[clap(
        long,
        env = "ESPRESSO_NODE_CLIQUENET_BIND_ADDRESS",
        default_value = "0.0.0.0:9977",
        value_parser = parse_bind_addr
    )]
    pub cliquenet_bind_address: NetAddr,

    /// The address to advertise to other nodes for cliquenet (in `host:port` | `ip:port` form).
    ///
    /// Only used for orchestrator-based setup (test networks). On real networks the address
    /// must be registered in the stake table contract instead.
    #[clap(
        long,
        env = "ESPRESSO_NODE_CLIQUENET_ADVERTISE_ADDRESS",
        value_parser = parse_advertise_addr
    )]
    pub cliquenet_advertise_address: Option<NetAddr>,

    /// The URL we advertise to other nodes as being for our public API.
    /// Should be supplied in `http://host:port` form.
    #[clap(long, env = "ESPRESSO_NODE_PUBLIC_API_URL")]
    pub public_api_url: Option<Url>,

    /// The URL of the builders to use for submitting transactions
    #[clap(long, env = "ESPRESSO_BUILDER_URLS", value_delimiter = ',')]
    pub builder_urls: Vec<Url>,

    /// URL of the Light Client State Relay Server
    #[clap(
        long,
        env = "ESPRESSO_STATE_RELAY_SERVER_URL",
        default_value = "http://localhost:8083"
    )]
    #[derivative(Debug(format_with = "Display::fmt"))]
    pub state_relay_server_url: Url,

    /// Location of the TOML file containing genesis state.
    ///
    /// Accepts a plain filesystem path or an `http(s)://` URL.
    #[clap(
        long,
        name = "GENESIS_FILE",
        env = "ESPRESSO_NODE_GENESIS_FILE",
        default_value = "/genesis/demo-ff.toml"
    )]
    pub genesis_file: GenesisSource,

    #[clap(flatten)]
    pub key_set: KeySetOptions,

    /// Add optional modules to the service.
    ///
    /// Modules are added by specifying the name of the module followed by it's arguments, as in
    ///
    /// sequencer [options] -- api --port 3000
    ///
    /// to run the API module with port 3000.
    ///
    /// To see a list of available modules and their arguments, use
    ///
    /// sequencer -- help
    ///
    /// Multiple modules can be specified, provided they are separated by --
    #[clap(raw = true)]
    modules: Vec<String>,

    /// Url we will use for RPC communication with L1.
    #[clap(
        long,
        env = "ESPRESSO_L1_PROVIDER",
        default_value = "http://localhost:8545",
        value_delimiter = ',',
        num_args = 1..,
    )]
    #[derivative(Debug = "ignore")]
    pub l1_provider_url: Vec<Url>,

    /// Configuration for the L1 client.
    #[clap(flatten)]
    pub l1_options: L1ClientOptions,

    /// Whether or not we are a DA node.
    #[clap(long, env = "ESPRESSO_NODE_IS_DA", action)]
    pub is_da: bool,

    /// Peer nodes use to fetch missing state
    #[clap(long, env = "ESPRESSO_NODE_STATE_PEERS", value_delimiter = ',')]
    #[derivative(Debug(format_with = "fmt_urls"))]
    pub state_peers: Vec<Url>,

    /// Peer nodes use to fetch missing config
    ///
    /// Typically, the network-wide config is fetched from the orchestrator on startup and then
    /// persisted and loaded from local storage each time the node restarts. However, if the
    /// persisted config is missing when the node restarts (for example, the node is being migrated
    /// to new persistent storage), it can instead be fetched directly from a peer.
    #[clap(long, env = "ESPRESSO_NODE_CONFIG_PEERS", value_delimiter = ',')]
    #[derivative(Debug(format_with = "fmt_opt_urls"))]
    pub config_peers: Option<Vec<Url>>,

    /// Exponential backoff for fetching missing state from peers.
    #[clap(flatten)]
    pub catchup_backoff: BackoffParams,

    /// Base timeout for catchup requests to peers.
    ///
    /// This is the initial per peer timeout for HTTP requests during state catchup
    #[clap(long, env = "ESPRESSO_NODE_CATCHUP_BASE_TIMEOUT", default_value = "2s", value_parser = parse_duration)]
    pub catchup_base_timeout: Duration,

    /// Timeout for local catchup provider requests.
    ///
    /// Remote providers are queried concurrently; this bounds the wait on a slow local provider
    /// (e.g. database) once remote providers have failed.
    #[clap(long, env = "ESPRESSO_NODE_LOCAL_CATCHUP_TIMEOUT", default_value = "5s", value_parser = parse_duration)]
    pub local_catchup_timeout: Duration,

    /// HTTP catchup starts this long after request-response, if request-response is registered.
    #[clap(long, env = "ESPRESSO_NODE_HTTP_CATCHUP_DELAY", default_value = "2s", value_parser = parse_duration)]
    pub http_catchup_delay: Duration,

    /// Per-step timeout for the startup stake-table catchup walk.
    ///
    /// Bounds a single `wait_for_stake_table` call during `bootstrap_epoch_window`. The
    /// underlying peer leaf fetch is bounded to 3 attempts, so exceeding this means a slow
    /// or unresponsive peer set, not a retry loop. Exceeding it terminates the walk but
    /// does not cancel the catchup task, which is a detached `tokio::spawn` bounded by its
    /// own `DEFAULT_CATCHUP_TIMEOUT` watchdog.
    #[clap(long, env = "ESPRESSO_NODE_BOOTSTRAP_EPOCH_CATCHUP_TIMEOUT", default_value = "30s", value_parser = parse_duration)]
    pub bootstrap_epoch_catchup_timeout: Duration,

    /// How long a leader waits before proposing a block with no transactions in it.
    #[clap(long, env = "ESPRESSO_NODE_EMPTY_BLOCK_DELAY", default_value = "500ms", value_parser = parse_duration)]
    pub empty_block_delay: Duration,

    /// Directory for the leader-event trace `leader_trace_node{N}.csv`. Disabled when unset.
    /// Use local disk: a slow flush blocks consensus.
    #[clap(long, env = "ESPRESSO_NODE_LEADER_TRACE_DIR", hide = true)]
    pub leader_trace_dir: Option<PathBuf>,

    #[clap(flatten)]
    pub logging: logging::Config,

    #[clap(flatten)]
    pub identity: Identity,

    #[clap(flatten)]
    pub telemetry: TelemetryOptions,

    #[clap(flatten)]
    pub proposal_fetcher_config: ProposalFetcherConfig,
}

impl Options {
    pub fn modules(&self) -> Modules {
        ModuleArgs(self.modules.clone()).parse()
    }

    /// `--config-peers` is left unset for `init_follower_node` to default it to the upstreams.
    pub fn follower_params(
        &self,
        follower: &Follower,
        query: &api::options::Query,
        light_client_db: LightClientDbOptions,
    ) -> anyhow::Result<FollowerParams> {
        let light_client_genesis = match &follower.light_client_genesis {
            Some(path) => {
                let toml = std::fs::read_to_string(path)
                    .with_context(|| format!("reading light client genesis {}", path.display()))?;
                Some(
                    toml::from_str(&toml).with_context(|| {
                        format!("parsing light client genesis {}", path.display())
                    })?,
                )
            },
            None => None,
        };
        let state_peers = if self.state_peers.is_empty() {
            query.peers.clone()
        } else {
            self.state_peers.clone()
        };
        Ok(FollowerParams {
            upstreams: query.peers.clone(),
            config_peers: self.config_peers.clone(),
            catchup: CatchupParams {
                state_peers,
                backoff: self.catchup_backoff,
                base_timeout: self.catchup_base_timeout,
                local_timeout: self.local_catchup_timeout,
                http_delay: self.http_catchup_delay,
            },
            bootstrap_epoch_catchup_timeout: self.bootstrap_epoch_catchup_timeout,
            options: FollowerOptions {
                poll_interval: follower.poll_interval,
                max_blocks_per_poll: follower.max_blocks_per_poll,
                light_client: query.light_client.clone(),
                light_client_db,
                light_client_genesis,
            },
        })
    }
}

/// Parse an address to bind to, and check that it is well-formed, so that a mistyped
/// host fails at startup rather than when the first peer cannot reach us.
fn parse_bind_addr(s: &str) -> Result<NetAddr, String> {
    let addr = s.parse::<NetAddr>().map_err(|e| e.to_string())?;
    addr.validate().map_err(|e| e.to_string())?;
    Ok(addr)
}

/// As [`parse_bind_addr`], and the port has to be one a peer can connect to. A listener
/// may ask for an ephemeral port, an advertised address cannot: an address written
/// without a port is port 0.
fn parse_advertise_addr(s: &str) -> Result<NetAddr, String> {
    let addr = parse_bind_addr(s)?;
    if addr.port() == 0 {
        return Err("port 0 is not a port a peer can connect to".to_string());
    }
    Ok(addr)
}

/// Identity represents identifying information concerning the sequencer node.
/// This information is used to populate relevant information in the metrics
/// endpoint.  This information will also potentially be scraped and displayed
/// in a public facing dashboard.
#[derive(Parser, Clone, Derivative, Serialize)]
#[derivative(Debug(bound = ""))]
pub struct Identity {
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_COUNTRY_CODE")]
    pub country_code: Option<String>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_LATITUDE")]
    pub latitude: Option<f64>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_LONGITUDE")]
    pub longitude: Option<f64>,

    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_NODE_NAME")]
    pub node_name: Option<String>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_NODE_DESCRIPTION")]
    pub node_description: Option<String>,

    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_COMPANY_NAME")]
    pub company_name: Option<String>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_COMPANY_WEBSITE")]
    pub company_website: Option<Url>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_OPERATING_SYSTEM", default_value = std::env::consts::OS)]
    pub operating_system: Option<String>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_NODE_TYPE", default_value = get_default_node_type())]
    pub node_type: Option<String>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_NETWORK_TYPE")]
    pub network_type: Option<String>,

    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_ICON_14x14_1x")]
    pub icon_14x14_1x: Option<Url>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_ICON_14x14_2x")]
    pub icon_14x14_2x: Option<Url>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_ICON_14x14_3x")]
    pub icon_14x14_3x: Option<Url>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_ICON_24x24_1x")]
    pub icon_24x24_1x: Option<Url>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_ICON_24x24_2x")]
    pub icon_24x24_2x: Option<Url>,
    #[clap(long, env = "ESPRESSO_NODE_IDENTITY_ICON_24x24_3x")]
    pub icon_24x24_3x: Option<Url>,
}

/// get_default_node_type returns the current public facing binary name and
/// version of this program.
fn get_default_node_type() -> String {
    format!("espresso-sequencer {}", env!("CARGO_PKG_VERSION"))
}

fn build_version() -> String {
    let info = espresso_utils::build_info!();
    format!(
        "{}\nfeatures: {}",
        info.clap_version(),
        env!("VERGEN_CARGO_FEATURES"),
    )
}

// The Debug implementation for Url is noisy, we just want to see the URL
fn fmt_urls(v: &[Url], fmt: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
    write!(
        fmt,
        "{:?}",
        v.iter().map(|i| i.to_string()).collect::<Vec<_>>()
    )
}

fn fmt_opt_urls(
    v: &Option<Vec<Url>>,
    fmt: &mut std::fmt::Formatter,
) -> Result<(), std::fmt::Error> {
    match v {
        Some(urls) => {
            write!(fmt, "Some(")?;
            fmt_urls(urls, fmt)?;
            write!(fmt, ")")?;
        },
        None => {
            write!(fmt, "None")?;
        },
    }
    Ok(())
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Ratio {
    pub numerator: u64,
    pub denominator: u64,
}

impl From<Ratio> for (u64, u64) {
    fn from(r: Ratio) -> Self {
        (r.numerator, r.denominator)
    }
}

impl Display for Ratio {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(f, "{}:{}", self.numerator, self.denominator)
    }
}

impl PartialOrd for Ratio {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Ratio {
    fn cmp(&self, other: &Self) -> Ordering {
        (self.numerator * other.denominator).cmp(&(other.numerator * self.denominator))
    }
}

#[derive(Clone, Debug)]
struct ModuleArgs(Vec<String>);

impl ModuleArgs {
    fn parse(&self) -> Modules {
        match self.try_parse() {
            Ok(modules) => modules,
            Err(err) => err.exit(),
        }
    }

    fn try_parse(&self) -> Result<Modules, clap::Error> {
        let mut modules = Modules::default();
        let mut curr = self.0.clone();
        let mut provided = Default::default();

        while !curr.is_empty() {
            // The first argument (the program name) is used only for help generation. We include a
            // `--` so that the generated usage will look like `sequencer -- <command>` which is the
            // way these commands must be invoked due to the use of `raw` arguments.
            let module = SequencerModule::try_parse_from(
                once("sequencer --").chain(curr.iter().map(|s| s.as_str())),
            )?;
            match module {
                SequencerModule::Storage(m) => {
                    curr = m.add(&mut modules.storage_fs, &mut provided)?
                },
                SequencerModule::StorageFs(m) => {
                    curr = m.add(&mut modules.storage_fs, &mut provided)?
                },
                SequencerModule::StorageSql(m) => {
                    curr = m.add(&mut modules.storage_sql, &mut provided)?
                },
                SequencerModule::Http(m) => curr = m.add(&mut modules.http, &mut provided)?,
                SequencerModule::Query(m) => curr = m.add(&mut modules.query, &mut provided)?,
                SequencerModule::Submit(m) => curr = m.add(&mut modules.submit, &mut provided)?,
                SequencerModule::Status(m) => curr = m.add(&mut modules.status, &mut provided)?,
                SequencerModule::Catchup(m) => curr = m.add(&mut modules.catchup, &mut provided)?,
                SequencerModule::Config(m) => curr = m.add(&mut modules.config, &mut provided)?,
                SequencerModule::HotshotEvents(m) => {
                    curr = m.add(&mut modules.hotshot_events, &mut provided)?
                },
                SequencerModule::Explorer(m) => {
                    curr = m.add(&mut modules.explorer, &mut provided)?
                },
                SequencerModule::LightClient(m) => {
                    curr = m.add(&mut modules.light_client, &mut provided)?
                },
                SequencerModule::Follower(m) => {
                    curr = m.add(&mut modules.follower, &mut provided)?
                },
            }
        }
        if modules.follower.is_some() {
            validate_follower_modules(&modules)?;
        }

        Ok(modules)
    }
}

fn validate_follower_modules(modules: &Modules) -> Result<(), clap::Error> {
    if modules
        .query
        .as_ref()
        .is_none_or(|query| query.peers.is_empty())
    {
        return Err(clap::Error::raw(
            ErrorKind::MissingRequiredArgument,
            "module follower verifies the chain from the query module's peers: set --peers \
             (ESPRESSO_NODE_API_PEERS)",
        ));
    }
    Ok(())
}

trait ModuleInfo: Args + FromArgMatches {
    const NAME: &'static str;
    fn requires() -> Vec<&'static str>;
}

macro_rules! module {
    ($name:expr, $opt:ty $(,requires: $($req:expr),*)?) => {
        impl ModuleInfo for $opt {
            const NAME: &'static str = $name;

            fn requires() -> Vec<&'static str> {
                vec![$($($req),*)?]
            }
        }
    };
}

module!("storage-fs", persistence::fs::Options);
module!("storage-sql", persistence::sql::Options);
module!("http", api::options::Http);
module!("query", api::options::Query, requires: "http");
module!("submit", api::options::Submit, requires: "http");
module!("status", api::options::Status, requires: "http");
module!("catchup", api::options::Catchup, requires: "http");
module!("config", api::options::Config, requires: "http");
module!("hotshot-events", api::options::HotshotEvents, requires: "http");
module!("explorer", api::options::Explorer, requires: "http", "storage-sql");
module!("light-client", api::options::LightClient, requires: "http", "storage-sql");
module!("follower", Follower, requires: "storage-sql", "http", "query");

#[derive(Clone, Debug, Args)]
struct Module<Options: ModuleInfo> {
    #[clap(flatten)]
    options: Box<Options>,

    /// Add more optional modules.
    #[clap(raw = true)]
    modules: Vec<String>,
}

impl<Options: ModuleInfo> Module<Options> {
    /// Add this as an optional module. Return the next optional module args.
    fn add(
        self,
        options: &mut Option<Options>,
        provided: &mut HashSet<&'static str>,
    ) -> Result<Vec<String>, clap::Error> {
        if options.is_some() {
            return Err(clap::Error::raw(
                ErrorKind::TooManyValues,
                format!("optional module {} can only be started once", Options::NAME),
            ));
        }
        for req in Options::requires() {
            if !provided.contains(&req) {
                return Err(clap::Error::raw(
                    ErrorKind::MissingRequiredArgument,
                    format!("module {} is missing required module {req}", Options::NAME),
                ));
            }
        }
        *options = Some(*self.options);
        provided.insert(Options::NAME);
        Ok(self.modules)
    }
}

#[derive(Clone, Debug, Parser)]
enum SequencerModule {
    /// Run an HTTP server.
    ///
    /// The basic HTTP server comes with healthcheck and version endpoints. Add additional endpoints
    /// by enabling additional modules:
    /// * query: add query service endpoints
    /// * submit: add transaction submission endpoints
    Http(Module<api::options::Http>),
    /// Alias for storage-fs.
    Storage(Module<persistence::fs::Options>),
    /// Use the file system for persistent storage.
    StorageFs(Module<persistence::fs::Options>),
    /// Use a Postgres database for persistent storage.
    StorageSql(Module<persistence::sql::Options>),
    /// Run the query API module.
    ///
    /// This module requires the http module to be started.
    Query(Module<api::options::Query>),
    /// Run the transaction submission API module.
    ///
    /// This module requires the http module to be started.
    Submit(Module<api::options::Submit>),
    /// Run the status API module.
    ///
    /// This module requires the http module to be started.
    Status(Module<api::options::Status>),
    /// Run the state catchup API module.
    ///
    /// This module requires the http module to be started.
    Catchup(Module<api::options::Catchup>),
    /// Run the config API module.
    Config(Module<api::options::Config>),

    /// Run the hotshot events API module.
    ///
    /// This module requires the http module to be started.
    HotshotEvents(Module<api::options::HotshotEvents>),
    /// Run the explorer API module.
    ///
    /// This module requires the http and storage-sql modules to be started.
    Explorer(Module<api::options::Explorer>),
    /// Deprecated and ignored: the light client API is served by every node running the query
    /// module with storage-sql.
    ///
    /// This module requires the http and storage-sql modules to be started.
    LightClient(Module<api::options::LightClient>),
    /// Follow the chain through the light client instead of running consensus.
    ///
    /// Every block served is verified against finality proofs from the query module's peers
    /// (`--peers`, `ESPRESSO_NODE_API_PEERS`), which `--state-peers` and `--config-peers` default
    /// to. The node never joins consensus and needs no staking keys, orchestrator or cliquenet.
    ///
    /// This module requires the storage-sql, http and query modules to be started.
    Follower(Module<Follower>),
}

#[derive(Clone, Debug, Default)]
pub struct Modules {
    pub storage_fs: Option<persistence::fs::Options>,
    pub storage_sql: Option<persistence::sql::Options>,
    pub http: Option<api::options::Http>,
    pub query: Option<api::options::Query>,
    pub submit: Option<api::options::Submit>,
    pub status: Option<api::options::Status>,
    pub catchup: Option<api::options::Catchup>,
    pub config: Option<api::options::Config>,
    pub hotshot_events: Option<api::options::HotshotEvents>,
    pub explorer: Option<api::options::Explorer>,
    pub light_client: Option<api::options::LightClient>,
    pub follower: Option<Follower>,
}

/// Options for the follower module.
#[derive(Parser, Clone, Debug)]
pub struct Follower {
    /// How often to poll the upstreams for new blocks.
    #[clap(long, env = "ESPRESSO_NODE_FOLLOWER_POLL_INTERVAL", default_value = "1s", value_parser = parse_duration)]
    pub poll_interval: Duration,

    /// The most blocks ingested per poll; older heights are backfilled by the query service.
    #[clap(
        long,
        env = "ESPRESSO_NODE_FOLLOWER_MAX_BLOCKS_PER_POLL",
        default_value = "10"
    )]
    pub max_blocks_per_poll: u64,

    /// TOML file with the light client genesis to trust.
    ///
    /// Derived from the network config fetched from `--config-peers` when unset. Pin a reviewed
    /// file to stop trusting those peers for the root of trust.
    #[clap(long, env = "ESPRESSO_NODE_LIGHT_CLIENT_GENESIS")]
    pub light_client_genesis: Option<PathBuf>,
}

#[derive(Clone, Debug, Serialize)]
pub struct PublicNodeConfig {
    pub orchestrator_url: Url,
    pub cliquenet_bind_address: NetAddr,
    pub cliquenet_advertise_address: Option<NetAddr>,
    pub public_api_url: Option<Url>,
    pub builder_urls: Vec<Url>,
    pub state_relay_server_url: Url,
    pub state_peers: Vec<Url>,
    pub config_peers: Option<Vec<Url>>,
    pub is_da: bool,
    pub genesis_file: GenesisSource,
    pub genesis: Genesis,
    pub identity: Identity,
    pub catchup_base_timeout: Duration,
    pub local_catchup_timeout: Duration,
    pub http_catchup_delay: Duration,
    pub bootstrap_epoch_catchup_timeout: Duration,
    pub catchup_backoff: BackoffParams,
    /// Unset on a validator.
    pub follower: Option<FollowerConfig>,
    pub proposal_fetcher: ProposalFetcherConfig,
    pub l1: L1Tuning,
    pub l1_provider_count: usize,
    pub l1_ws_provider_count: usize,
    pub storage: StorageConfig,
    pub modules: ApiModulesConfig,
}

#[derive(Clone, Copy, Debug, Serialize, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum StorageBackend {
    Sql,
    Fs,
    FsDefault,
}

#[derive(Clone, Debug, Serialize)]
pub struct StorageConfig {
    /// Active backend.
    pub backend: StorageBackend,
    pub fs: Option<FsStorageConfig>,
    pub sql: Option<SqlStorageConfig>,
}

#[derive(Clone, Debug, Serialize)]
pub struct FsStorageConfig {
    pub path: PathBuf,
    pub consensus_view_retention: u64,
}

#[derive(Clone, Debug, Serialize)]
pub struct SqlStorageConfig {
    pub prune: bool,
    pub archive: bool,
    pub archive_state_min_retention: u64,
    pub archive_full_state: bool,
    pub lightweight: bool,
    pub disable_proactive_fetching: bool,
    pub fetch_rate_limit: Option<usize>,
    pub active_fetch_delay: Option<Duration>,
    pub chunk_fetch_delay: Option<Duration>,
    pub sync_status_chunk_size: Option<usize>,
    pub sync_status_ttl: Option<Duration>,
    pub proactive_scan_chunk_size: Option<usize>,
    pub proactive_scan_interval: Option<Duration>,
    pub idle_connection_timeout: Duration,
    pub connection_timeout: Duration,
    pub slow_statement_threshold: Duration,
    pub statement_timeout: Duration,
    pub min_connections: u32,
    pub max_connections: u32,
    pub query_min_connections: Option<u32>,
    pub query_max_connections: Option<u32>,
    pub pruning: PruningView,
    pub consensus_pruning: ConsensusPruningView,
}

#[derive(Clone, Debug, Serialize)]
pub struct PruningView {
    pub pruning_threshold: Option<u64>,
    pub minimum_retention: Option<Duration>,
    pub target_retention: Option<Duration>,
    pub batch_size: Option<u64>,
    pub max_usage: Option<u16>,
    pub interval: Option<Duration>,
    pub pages: Option<u64>,
}

#[derive(Clone, Debug, Serialize)]
pub struct ConsensusPruningView {
    pub target_retention: u64,
    pub minimum_retention: u64,
    pub target_usage: u64,
}

#[derive(Clone, Debug, Serialize)]
pub struct ApiModulesConfig {
    pub http: Option<HttpConfig>,
    pub query: Option<QueryConfig>,
    pub submit: bool,
    pub status: bool,
    pub catchup: bool,
    pub config: bool,
    pub hotshot_events: bool,
    pub explorer: bool,
    pub light_client: bool,
}

#[derive(Clone, Debug, Serialize)]
pub struct HttpConfig {
    pub port: u16,
    pub max_connections: Option<usize>,
    pub tonic_port: Option<u16>,
}

#[derive(Clone, Debug, Serialize)]
pub struct FollowerConfig {
    pub poll_interval: Duration,
    pub max_blocks_per_poll: u64,
}

impl From<&Follower> for FollowerConfig {
    fn from(o: &Follower) -> Self {
        Self {
            poll_interval: o.poll_interval,
            max_blocks_per_poll: o.max_blocks_per_poll,
        }
    }
}

#[derive(Clone, Debug, Serialize)]
pub struct QueryConfig {
    pub peers: Vec<Url>,
    pub light_client: LightClientOptions,
    pub light_client_db: LightClientSqliteOptions,
}

impl From<&persistence::sql::PruningOptions> for PruningView {
    fn from(o: &persistence::sql::PruningOptions) -> Self {
        Self {
            pruning_threshold: o.pruning_threshold,
            minimum_retention: o.minimum_retention,
            target_retention: o.target_retention,
            batch_size: o.batch_size,
            max_usage: o.max_usage,
            interval: o.interval,
            pages: o.pages,
        }
    }
}

impl From<&persistence::sql::ConsensusPruningOptions> for ConsensusPruningView {
    fn from(o: &persistence::sql::ConsensusPruningOptions) -> Self {
        Self {
            target_retention: o.target_retention,
            minimum_retention: o.minimum_retention,
            target_usage: o.target_usage,
        }
    }
}

impl From<&persistence::sql::Options> for SqlStorageConfig {
    fn from(o: &persistence::sql::Options) -> Self {
        Self {
            prune: o.prune,
            archive: o.archive,
            archive_state_min_retention: o.archive_state_min_retention,
            archive_full_state: o.archive_full_state,
            lightweight: o.lightweight,
            disable_proactive_fetching: o.disable_proactive_fetching,
            fetch_rate_limit: o.fetch_rate_limit,
            active_fetch_delay: o.active_fetch_delay,
            chunk_fetch_delay: o.chunk_fetch_delay,
            sync_status_chunk_size: o.sync_status_chunk_size,
            sync_status_ttl: o.sync_status_ttl,
            proactive_scan_chunk_size: o.proactive_scan_chunk_size,
            proactive_scan_interval: o.proactive_scan_interval,
            idle_connection_timeout: o.idle_connection_timeout,
            connection_timeout: o.connection_timeout,
            slow_statement_threshold: o.slow_statement_threshold,
            statement_timeout: o.statement_timeout,
            min_connections: o.min_connections,
            max_connections: o.max_connections,
            // SQLite shares one pool between consensus and queries, so these do not apply.
            query_min_connections: o.query_min_connections.filter(|_| !o.embedded_db),
            query_max_connections: o.query_max_connections.filter(|_| !o.embedded_db),
            pruning: PruningView::from(&o.pruning),
            consensus_pruning: ConsensusPruningView::from(&o.consensus_pruning),
        }
    }
}

impl From<&persistence::fs::Options> for FsStorageConfig {
    fn from(o: &persistence::fs::Options) -> Self {
        Self {
            path: o.path.clone(),
            consensus_view_retention: o.consensus_view_retention,
        }
    }
}

impl From<&api::options::Http> for HttpConfig {
    fn from(o: &api::options::Http) -> Self {
        Self {
            port: o.port,
            max_connections: o.max_connections,
            tonic_port: o.tonic_port,
        }
    }
}

impl From<&api::options::Query> for QueryConfig {
    fn from(o: &api::options::Query) -> Self {
        Self {
            peers: o.peers.clone(),
            light_client: o.light_client.clone(),
            light_client_db: o.sqlite_light_client_db(),
        }
    }
}

impl From<&Modules> for ApiModulesConfig {
    fn from(m: &Modules) -> Self {
        Self {
            http: m.http.as_ref().map(HttpConfig::from),
            query: m.query.as_ref().map(QueryConfig::from),
            submit: m.submit.is_some(),
            status: m.status.is_some(),
            catchup: m.catchup.is_some(),
            config: m.config.is_some(),
            hotshot_events: m.hotshot_events.is_some(),
            explorer: m.explorer.is_some(),
            light_client: m.query.is_some() && m.storage_sql.is_some(),
        }
    }
}

#[derive(Clone, Debug, Serialize)]
pub struct L1Tuning {
    pub retry_delay: Duration,
    pub polling_interval: Duration,
    pub wait_refresh_interval: Duration,
    pub wait_refresh_timeout: Duration,
    pub request_timeout: Duration,
    pub blocks_cache_size: usize,
    pub events_channel_capacity: usize,
    pub events_max_block_range: u64,
    pub subscription_timeout: Duration,
    pub frequent_failure_tolerance: Duration,
    pub consecutive_failure_tolerance: usize,
    pub failover_revert: Duration,
    pub rate_limit_delay: Option<Duration>,
    pub stake_table_update_interval: Duration,
    pub events_max_retry_duration: Duration,
    pub finalized_safety_margin: Option<NonZeroU64>,
}

impl From<&L1ClientOptions> for L1Tuning {
    fn from(o: &L1ClientOptions) -> Self {
        Self {
            retry_delay: o.l1_retry_delay,
            polling_interval: o.l1_polling_interval,
            wait_refresh_interval: o.l1_wait_refresh_interval,
            wait_refresh_timeout: o.l1_wait_refresh_timeout,
            request_timeout: o.l1_request_timeout,
            blocks_cache_size: o.l1_blocks_cache_size.get(),
            events_channel_capacity: o.l1_events_channel_capacity,
            events_max_block_range: o.l1_events_max_block_range,
            subscription_timeout: o.subscription_timeout,
            frequent_failure_tolerance: o.l1_frequent_failure_tolerance,
            consecutive_failure_tolerance: o.l1_consecutive_failure_tolerance,
            failover_revert: o.l1_failover_revert,
            rate_limit_delay: o.l1_rate_limit_delay,
            stake_table_update_interval: o.stake_table_update_interval,
            events_max_retry_duration: o.l1_events_max_retry_duration,
            finalized_safety_margin: o.l1_finalized_safety_margin.blocks(),
        }
    }
}

impl PublicNodeConfig {
    pub fn new(opt: &Options, modules: &Modules, genesis: &Genesis) -> Self {
        let storage = if let Some(sql) = modules.storage_sql.as_ref() {
            StorageConfig {
                backend: StorageBackend::Sql,
                fs: None,
                sql: Some(SqlStorageConfig::from(sql)),
            }
        } else if let Some(fs) = modules.storage_fs.as_ref() {
            StorageConfig {
                backend: StorageBackend::Fs,
                fs: Some(FsStorageConfig::from(fs)),
                sql: None,
            }
        } else {
            let fs = persistence::fs::Options::try_parse_from(std::iter::empty::<String>()).ok();
            StorageConfig {
                backend: StorageBackend::FsDefault,
                fs: fs.as_ref().map(FsStorageConfig::from),
                sql: None,
            }
        };

        Self {
            orchestrator_url: opt.orchestrator_url.clone(),
            cliquenet_bind_address: opt.cliquenet_bind_address.clone(),
            cliquenet_advertise_address: opt.cliquenet_advertise_address.clone(),
            public_api_url: opt.public_api_url.clone(),
            builder_urls: opt.builder_urls.clone(),
            state_relay_server_url: opt.state_relay_server_url.clone(),
            state_peers: opt.state_peers.clone(),
            config_peers: opt.config_peers.clone(),
            is_da: opt.is_da,
            genesis_file: opt.genesis_file.clone(),
            genesis: genesis.clone(),
            identity: opt.identity.clone(),
            catchup_base_timeout: opt.catchup_base_timeout,
            local_catchup_timeout: opt.local_catchup_timeout,
            http_catchup_delay: opt.http_catchup_delay,
            bootstrap_epoch_catchup_timeout: opt.bootstrap_epoch_catchup_timeout,
            catchup_backoff: opt.catchup_backoff,
            follower: modules.follower.as_ref().map(FollowerConfig::from),
            proposal_fetcher: opt.proposal_fetcher_config,
            l1: L1Tuning::from(&opt.l1_options),
            l1_provider_count: opt.l1_provider_url.len(),
            l1_ws_provider_count: opt
                .l1_options
                .l1_ws_provider
                .as_ref()
                .map(|v| v.len())
                .unwrap_or(0),
            storage,
            modules: ApiModulesConfig::from(modules),
        }
    }
}

#[cfg(test)]
pub(crate) mod tests {
    use alloy::primitives::{Address, B256, U256};
    use espresso_types::{
        FeeAccount, GenesisHeader, L1BlockInfo, PubKey, SeqTypes, Timestamp, Upgrade, UpgradeMode,
        UpgradeType, ViewBasedUpgrade, v0_3::ChainConfig,
    };
    use espresso_utils::ser::FromStringOrInteger;
    use hotshot_types::{
        PeerConfig, VersionedDaCommittee, light_client::StateKeyPair, stake_table::StakeTableEntry,
        traits::signature_key::SignatureKey, x25519,
    };
    use tagged_base64::TaggedBase64;
    use vbs::version::Version;

    use super::*;
    use crate::genesis::{L1Finalized, StakeTableConfig};

    #[test]
    fn test_build_version() {
        let version = build_version();
        for field in [
            "describe:",
            "rev:",
            "modified:",
            "branch:",
            "commit-timestamp:",
            "debug:",
            "os:",
            "arch:",
            "features:",
        ] {
            assert!(version.contains(field), "missing {field}: {version}");
        }
        assert!(
            version.contains("debug: true"),
            "expected debug build in test: {version}"
        );
        assert!(
            version.contains("testing"),
            "expected testing in features: {version}"
        );
    }

    /// Build a minimal `Options` for tests, using freshly generated keys and the supplied extra args.
    pub(crate) fn parse_options_with(extra: &[&str]) -> Options {
        let (_, priv_key) = PubKey::generated_from_seed_indexed([0; 32], 0);
        let state_key = StateKeyPair::generate_from_seed_indexed([0; 32], 0);
        let x25519_kp = x25519::Keypair::generate().unwrap();

        let priv_staking = priv_key.to_tagged_base64().expect("valid key").to_string();
        let priv_state = state_key
            .sign_key_ref()
            .to_tagged_base64()
            .expect("valid key")
            .to_string();
        let priv_x25519 = TaggedBase64::try_from(x25519_kp.secret_key())
            .expect("valid key")
            .to_string();

        let mut args: Vec<String> = vec![
            "sequencer".into(),
            "--private-staking-key".into(),
            priv_staking,
            "--private-state-key".into(),
            priv_state,
            "--private-x25519-key".into(),
            priv_x25519,
        ];
        args.extend(extra.iter().map(|s| s.to_string()));

        Options::parse_from(args)
    }

    /// A `Genesis` with every field populated (both upgrade modes, DA committee) so the
    /// `/config/runtime` snapshot documents the full response shape.
    pub(crate) fn test_genesis() -> Genesis {
        let chain_config = ChainConfig {
            chain_id: 999999999.into(),
            max_block_size: 3000.into(),
            base_fee: 1.into(),
            fee_recipient: FeeAccount::default(),
            fee_contract: Some(Address::from([0x11; 20])),
            stake_table_contract: Some(Address::from([0x22; 20])),
        };
        let peer = PeerConfig::<SeqTypes> {
            stake_table_entry: StakeTableEntry {
                stake_key: PubKey::generated_from_seed_indexed([0; 32], 0).0,
                stake_amount: U256::from(1),
            },
            state_ver_key: StateKeyPair::generate_from_seed_indexed([0; 32], 0).ver_key(),
            connect_info: None,
        };
        Genesis {
            base_version: Version { major: 0, minor: 4 },
            upgrade_version: Version { major: 0, minor: 5 },
            genesis_version: Version { major: 0, minor: 2 },
            epoch_height: Some(40000),
            drb_difficulty: Some(25000000000),
            drb_upgrade_difficulty: Some(25000000000),
            epoch_start_block: Some(10960201),
            stake_table_capacity: Some(200),
            chain_config,
            stake_table: StakeTableConfig { capacity: 200 },
            accounts: Default::default(),
            l1_finalized: L1Finalized::Block(L1BlockInfo {
                number: 21116303,
                timestamp: U256::from(1700000000),
                hash: B256::from([0x44; 32]),
            }),
            header: GenesisHeader {
                timestamp: Timestamp::from_integer(123456).unwrap(),
                chain_config,
            },
            upgrades: [(
                Version { major: 0, minor: 5 },
                Upgrade {
                    mode: UpgradeMode::View(ViewBasedUpgrade {
                        start_proposing_view: 100,
                        stop_proposing_view: 200,
                        start_voting_view: Some(1),
                        stop_voting_view: Some(300),
                    }),
                    upgrade_type: UpgradeType::EpochReward { chain_config },
                },
            )]
            .into_iter()
            .collect(),
            da_committees: Some(vec![VersionedDaCommittee {
                start_version: Version { major: 0, minor: 6 },
                start_epoch: 10,
                committee: vec![peer],
            }]),
        }
    }

    #[test]
    fn public_node_config_no_secrets() {
        let opt = parse_options_with(&[
            "--l1-provider-url",
            "https://user:pass@example.invalid/v2/SECRET_API_KEY,https://example2.invalid/key2",
            "--cliquenet-bind-address",
            "127.0.0.1:9999",
            "--state-peers",
            "https://peer1.test,https://peer2.test",
        ]);
        let modules = opt.modules();

        let cfg = PublicNodeConfig::new(&opt, &modules, &test_genesis());
        let json = serde_json::to_string(&cfg).unwrap();
        let json_lc = json.to_lowercase();

        assert!(
            json.contains("127.0.0.1:9999"),
            "CLI override missing from JSON: {json}"
        );
        assert!(
            !json.contains("SECRET_API_KEY"),
            "L1 API key leaked into JSON: {json}"
        );
        assert!(
            !json.contains("user:pass"),
            "L1 URL userinfo leaked into JSON: {json}"
        );
        assert!(
            !json.contains("example.invalid"),
            "L1 host leaked into JSON: {json}"
        );
        assert!(
            !json.contains("example2.invalid"),
            "second L1 host leaked into JSON: {json}"
        );
        assert!(
            json.contains("\"l1_provider_count\":2"),
            "missing l1_provider_count: {json}"
        );
        assert!(
            !json.contains("\"uri\""),
            "DB URI key leaked into JSON: {json}"
        );
        assert!(
            !json.contains("postgres://"),
            "DB connection string leaked into JSON: {json}"
        );

        const FORBIDDEN: &[&str] = &[
            "private", "mnemonic", "secret", "x25519", "key_file", "seed", "password",
        ];
        for token in FORBIDDEN {
            assert!(
                !json_lc.contains(token),
                "forbidden token '{token}' leaked into JSON: {json}"
            );
        }

        assert!(
            json.contains("peer1.test") && json.contains("peer2.test"),
            "state_peers missing from JSON: {json}"
        );
    }

    #[test]
    fn public_node_config_optionals() {
        let opt = parse_options_with(&[]);
        let modules = opt.modules();

        let cfg = PublicNodeConfig::new(&opt, &modules, &test_genesis());

        assert!(
            cfg.cliquenet_advertise_address.is_none(),
            "expected no advertise address: {:?}",
            cfg.cliquenet_advertise_address
        );
        assert!(
            cfg.config_peers.is_none(),
            "expected no config peers: {:?}",
            cfg.config_peers
        );
        assert_eq!(cfg.l1_ws_provider_count, 0);
        assert_eq!(cfg.storage.backend, StorageBackend::FsDefault);
        assert!(cfg.storage.fs.is_none());
        assert!(cfg.storage.sql.is_none());
        assert!(!cfg.modules.submit);
        assert!(cfg.modules.http.is_none());
        assert!(cfg.modules.query.is_none());

        let value: serde_json::Value = serde_json::to_value(&cfg).unwrap();
        assert_eq!(
            value["cliquenet_advertise_address"],
            serde_json::Value::Null
        );
        assert_eq!(value["config_peers"], serde_json::Value::Null);
        assert_eq!(value["public_api_url"], serde_json::Value::Null);
    }

    #[test]
    fn follower_params_default_peers() {
        let peers = ["http://a.test", "http://b.test"].map(|url| url.parse::<Url>().unwrap());
        let query = api::options::Query {
            peers: peers.to_vec(),
            ..Default::default()
        };
        let follower = Follower::try_parse_from(["follower"]).unwrap();

        let opt = parse_options_with(&[]);
        let params = opt
            .follower_params(&follower, &query, Default::default())
            .unwrap();
        assert_eq!(params.upstreams, peers);
        assert_eq!(params.catchup.state_peers, peers);
        assert!(
            params.config_peers.is_none(),
            "config peers are defaulted by init_follower_node"
        );

        let opt = parse_options_with(&[
            "--state-peers",
            "http://c.test",
            "--config-peers",
            "http://d.test",
        ]);
        let params = opt
            .follower_params(&follower, &query, Default::default())
            .unwrap();
        assert_eq!(params.upstreams, peers);
        assert_eq!(
            params.catchup.state_peers,
            ["http://c.test".parse::<Url>().unwrap()]
        );
        assert_eq!(
            params.config_peers,
            Some(vec!["http://d.test".parse::<Url>().unwrap()])
        );
    }

    #[test]
    fn follower_module_requirements() {
        let parse = |modules: &[&str]| {
            let mut args = vec![];
            for module in modules {
                args.push("--".to_string());
                args.extend(module.split(' ').map(String::from));
            }
            // Drop the leading `--`, as `Options` does.
            ModuleArgs(args.split_off(1)).try_parse()
        };
        let modules = parse(&[
            "storage-sql",
            "http",
            "query --peers http://a.test",
            "follower",
        ])
        .expect("sql storage, http and query with peers suffice");
        assert!(modules.follower.is_some());
        parse(&[
            "storage-sql",
            "http",
            "query --peers http://a.test",
            "submit",
            "catchup",
            "config",
            "light-client",
            "explorer",
            "follower",
        ])
        .expect("the other modules are allowed");
        assert!(
            parse(&[
                "storage-fs --path /tmp/follower",
                "http",
                "query --peers http://a.test",
                "follower",
            ])
            .is_err(),
            "fs storage cannot serve merklized state"
        );
        assert!(
            parse(&["storage-sql", "http", "follower"]).is_err(),
            "the query module is required"
        );
        assert!(
            parse(&["storage-sql", "http", "query", "follower"]).is_err(),
            "the query module's peers are the upstreams"
        );
    }

    #[test]
    fn light_client_db_defaults_under_storage_path() {
        fn lc_path(storage_path: Option<&str>, lc_path: Option<&str>) -> Option<PathBuf> {
            let query = api::options::Query {
                storage_path: storage_path.map(PathBuf::from),
                light_client_db: LightClientSqliteOptions {
                    lc_path: lc_path.map(PathBuf::from),
                    ..Default::default()
                },
                ..Default::default()
            };
            query.sqlite_light_client_db().lc_path
        }
        assert_eq!(
            lc_path(Some("/store/espresso"), None),
            Some(PathBuf::from("/store/espresso/light-client/lc.db"))
        );
        assert_eq!(
            lc_path(Some("/store/espresso"), Some("/store/lc")),
            Some(PathBuf::from("/store/lc"))
        );
        assert_eq!(lc_path(None, None), None);
    }

    // Document the JSON shape of GET /config/runtime.
    #[test]
    fn config_node_response_snapshot() {
        let opt = parse_options_with(&[
            "--orchestrator-url",
            "http://orchestrator.example:8080",
            "--cliquenet-bind-address",
            "0.0.0.0:9977",
            "--cliquenet-advertise-address",
            "node1.example:9977",
            "--public-api-url",
            "http://node1.example:24000",
            "--builder-urls",
            "http://builder.example:31004",
            "--state-relay-server-url",
            "http://relay.example:8083",
            "--state-peers",
            "https://peer1.example,https://peer2.example",
            "--config-peers",
            "https://peer1.example",
            "--is-da",
            "--genesis-file",
            "/path/to/genesis.toml",
            "--l1-provider-url",
            "https://eth.example",
            "--country-code",
            "US",
            "--node-name",
            "Snapshot Node",
            // Pin host-dependent identity defaults so the snapshot is portable.
            "--operating-system",
            "linux",
            "--node-type",
            "espresso-sequencer 0.0.0",
            "--",
            "storage-sql",
            "--prune",
            "--pruning-threshold",
            "1000000000000",
            "--",
            "http",
            "--port",
            "24000",
            "--",
            "query",
            "--peers",
            "http://peer.example:24000",
            "--",
            "config",
        ]);
        let modules = opt.modules();

        let cfg = PublicNodeConfig::new(&opt, &modules, &test_genesis());

        insta::assert_yaml_snapshot!("config_node_response_postgres", cfg);
    }

    #[test]
    fn public_node_config_includes_pruning() {
        let opt = parse_options_with(&[
            "--cliquenet-bind-address",
            "127.0.0.1:1",
            "--",
            "storage-sql",
            "--prune",
            "--pruning-threshold",
            "1000000000000",
        ]);
        let modules = opt.modules();

        let cfg = PublicNodeConfig::new(&opt, &modules, &test_genesis());
        let json = serde_json::to_string(&cfg).unwrap();

        assert_eq!(cfg.storage.backend, StorageBackend::Sql);
        assert!(
            json.contains("\"prune\":true"),
            "expected prune:true in JSON: {json}"
        );
        assert!(
            json.contains("pruning_threshold"),
            "expected pruning_threshold in JSON: {json}"
        );
        assert!(
            json.contains("1000000000000"),
            "expected pruning threshold value in JSON: {json}"
        );
        assert!(
            json.contains("\"consensus_pruning\""),
            "expected consensus_pruning object in JSON: {json}"
        );
        assert!(
            json.contains("\"pruning\""),
            "expected pruning object in JSON: {json}"
        );
        assert!(
            json.contains("\"target_retention\":302000"),
            "expected consensus_pruning target_retention default in JSON: {json}"
        );
        assert!(
            json.contains("\"minimum_retention\":130000"),
            "expected consensus_pruning minimum_retention default in JSON: {json}"
        );
        assert!(
            json.contains("\"target_usage\":1000000000"),
            "expected consensus_pruning target_usage default in JSON: {json}"
        );
        assert!(
            !json.contains("\"uri\""),
            "DB URI key leaked into JSON: {json}"
        );
        assert!(
            !json.contains("postgres://"),
            "DB connection string leaked into JSON: {json}"
        );
    }
}