drive_abci/

config.rs

use crate::logging::LogConfigs;
use crate::utils::from_str_or_number;
use crate::{abci::config::AbciConfig, error::Error};
use bincode::{Decode, Encode};
use dpp::dashcore::Network;
use dpp::dashcore_rpc::json::QuorumType;
use dpp::util::deserializer::ProtocolVersion;
use dpp::version::INITIAL_PROTOCOL_VERSION;
use drive::config::{DriveConfig, DEFAULT_EPOCH_TIME_LENGTH_S};
use serde::{de::DeserializeOwned, Deserialize, Deserializer, Serialize};
use std::path::PathBuf;

/// Configuration for Dash Core RPC client used in consensus logic
#[derive(Clone, Debug, Serialize, Deserialize, Default)]
pub struct ConsensusCoreRpcConfig {
    /// Core RPC client hostname or IP address
    #[serde(rename = "core_consensus_json_rpc_host")]
    pub host: String,

    /// Core RPC client port number
    #[serde(
        rename = "core_consensus_json_rpc_port",
        deserialize_with = "from_str_or_number"
    )]
    pub port: u16,

    /// Core RPC client username
    #[serde(rename = "core_consensus_json_rpc_username")]
    pub username: String,

    /// Core RPC client password
    #[serde(rename = "core_consensus_json_rpc_password")]
    pub password: String,
}

impl ConsensusCoreRpcConfig {
    /// Return core address in the `host:port` format.
    pub fn url(&self) -> String {
        format!("{}:{}", self.host, self.port)
    }
}

/// Configuration for Dash Core RPC client used in check tx
#[derive(Clone, Debug, Serialize, Deserialize, Default)]
pub struct CheckTxCoreRpcConfig {
    /// Core RPC client hostname or IP address
    #[serde(rename = "core_check_tx_json_rpc_host")]
    pub host: String,

    /// Core RPC client port number
    #[serde(
        rename = "core_check_tx_json_rpc_port",
        deserialize_with = "from_str_or_number"
    )]
    pub port: u16,

    /// Core RPC client username
    #[serde(rename = "core_check_tx_json_rpc_username")]
    pub username: String,

    /// Core RPC client password
    #[serde(rename = "core_check_tx_json_rpc_password")]
    pub password: String,
}

impl CheckTxCoreRpcConfig {
    /// Return core address in the `host:port` format.
    pub fn url(&self) -> String {
        format!("{}:{}", self.host, self.port)
    }
}

/// Configuration for Dash Core related things
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(default)]
#[derive(Default)]
pub struct CoreConfig {
    /// Core RPC config for consensus
    #[serde(flatten)]
    pub consensus_rpc: ConsensusCoreRpcConfig,
    /// Core RPC config for check tx
    #[serde(flatten)]
    pub check_tx_rpc: CheckTxCoreRpcConfig,
}

/// Configuration of the execution part of Dash Platform.
#[derive(Clone, Debug, Serialize, Deserialize)]
// NOTE: in renames, we use lower_snake_case, because uppercase does not work; see
// https://github.com/softprops/envy/issues/61 and https://github.com/softprops/envy/pull/69
pub struct ExecutionConfig {
    /// Should we use document triggers? Useful to set as `false` for tests
    #[serde(default = "ExecutionConfig::default_use_document_triggers")]
    pub use_document_triggers: bool,

    /// Should we verify sum trees? Useful to set as `false` for tests
    #[serde(default = "ExecutionConfig::default_verify_sum_trees")]
    pub verify_sum_trees: bool,

    /// Should we verify sum trees? Useful to set as `false` for tests
    #[serde(default = "ExecutionConfig::default_verify_token_sum_trees")]
    pub verify_token_sum_trees: bool,

    /// How long in seconds should an epoch last
    /// It might last a lot longer if the chain is halted
    #[serde(
        default = "ExecutionConfig::default_epoch_time_length_s",
        deserialize_with = "from_str_or_number"
    )]
    pub epoch_time_length_s: u64,
}

/// Configuration of Dash Platform.
///
/// All fields in this struct can be configured using environment variables.
/// These variables can also be defined in `.env` file in the current directory
/// or its parents. You can also provide path to the .env file as a command-line argument.
///
/// Environment variables should be renamed to `SCREAMING_SNAKE_CASE`.
/// For example, to define [`verify_sum_trees`], you should set VERIFY_SUM_TREES
/// environment variable:
///
/// ``
/// export VERIFY_SUM_TREES=true
/// ``
///
/// [`verify_sum_trees`]: PlatformConfig::verify_sum_trees
#[derive(Clone, Debug, Serialize)]
// NOTE: in renames, we use lower_snake_case, because uppercase does not work; see
// https://github.com/softprops/envy/issues/61 and https://github.com/softprops/envy/pull/69
pub struct PlatformConfig {
    /// The network type
    pub network: Network,
    /// Drive configuration
    #[serde(flatten)]
    pub drive: DriveConfig,

    /// Dash Core config
    #[serde(flatten)]
    pub core: CoreConfig,

    /// ABCI Application Server config
    #[serde(flatten)]
    pub abci: AbciConfig,

    /// Address to listen for Prometheus connection.
    ///
    /// Optional.
    ///
    /// /// Address should be an URL with scheme `http://`, for example:
    /// - `http://127.0.0.1:29090`
    ///
    /// Port number defaults to [crate::metrics::DEFAULT_PROMETHEUS_PORT].
    pub prometheus_bind_address: Option<String>,

    /// Address to listen for gRPC connection.
    pub grpc_bind_address: String,

    /// Execution config
    #[serde(flatten)]
    pub execution: ExecutionConfig,

    /// The default quorum type
    #[serde(flatten)]
    pub validator_set: ValidatorSetConfig,

    /// Chain lock configuration
    #[serde(flatten)]
    pub chain_lock: ChainLockConfig,

    /// Instant lock configuration
    #[serde(flatten)]
    pub instant_lock: InstantLockConfig,

    // todo: this should probably be coming from Tenderdash config. It's a test only param
    /// Approximately how often are blocks produced
    pub block_spacing_ms: u64,

    /// Path to data storage
    pub db_path: PathBuf,

    /// Path to store rejected / invalid items (like transactions).
    /// Used mainly for debugging.
    ///
    /// If not set, rejected and invalid items will not be stored.
    pub rejections_path: Option<PathBuf>,

    #[cfg(feature = "testing-config")]
    /// This should be None, except in the case of Testing platform
    #[serde(skip)]
    pub testing_configs: PlatformTestConfig,

    /// Enable tokio console (console feature must be enabled)
    pub tokio_console_enabled: bool,

    // TODO: Use from_str_to_socket_address
    /// Tokio console address to connect to
    pub tokio_console_address: String,

    /// Number of seconds to store task information if there is no clients connected
    pub tokio_console_retention_secs: u64,
}

// Define an intermediate struct that mirrors PlatformConfig
#[derive(Deserialize)]
struct PlatformConfigIntermediate {
    /// The network type
    #[serde(
        default = "PlatformConfig::default_network",
        deserialize_with = "from_str_to_network_with_aliases"
    )]
    pub network: Network,
    /// Drive configuration
    #[serde(flatten)]
    pub drive: DriveConfig,
    // Include all other fields
    #[serde(flatten)]
    pub core: CoreConfig,
    #[serde(flatten)]
    pub abci: AbciConfig,
    pub prometheus_bind_address: Option<String>,
    pub grpc_bind_address: String,
    #[serde(flatten)]
    pub execution: ExecutionConfig,
    #[serde(flatten)]
    pub validator_set: ValidatorSetConfig,
    #[serde(flatten)]
    pub chain_lock: ChainLockConfig,
    #[serde(flatten)]
    pub instant_lock: InstantLockConfig,
    pub block_spacing_ms: u64,
    #[serde(default = "PlatformConfig::default_initial_protocol_version")]
    // TODO: Is not using
    #[allow(dead_code)]
    pub initial_protocol_version: ProtocolVersion,
    pub db_path: PathBuf,
    #[serde(default)]
    pub rejections_path: Option<PathBuf>,
    #[cfg(feature = "testing-config")]
    #[serde(skip)]
    pub testing_configs: PlatformTestConfig,
    pub tokio_console_enabled: bool,
    #[serde(default = "PlatformConfig::default_tokio_console_address")]
    pub tokio_console_address: String,
    #[serde(default = "PlatformConfig::default_tokio_console_retention_secs")]
    pub tokio_console_retention_secs: u64,
}

impl<'de> Deserialize<'de> for PlatformConfig {
    fn deserialize<D>(deserializer: D) -> Result<PlatformConfig, D::Error>
    where
        D: Deserializer<'de>,
    {
        // First, deserialize into an intermediate struct
        let mut config = PlatformConfigIntermediate::deserialize(deserializer)?;

        // Set drive.network = network
        config.drive.network = config.network;

        // Convert the intermediate struct into your actual PlatformConfig
        Ok(PlatformConfig {
            network: config.network,
            drive: config.drive,
            // Copy other fields
            core: config.core,
            abci: config.abci,
            prometheus_bind_address: config.prometheus_bind_address,
            grpc_bind_address: config.grpc_bind_address,
            execution: config.execution,
            validator_set: config.validator_set,
            chain_lock: config.chain_lock,
            instant_lock: config.instant_lock,
            block_spacing_ms: config.block_spacing_ms,
            db_path: config.db_path,
            rejections_path: config.rejections_path,
            #[cfg(feature = "testing-config")]
            testing_configs: config.testing_configs,
            tokio_console_enabled: config.tokio_console_enabled,
            tokio_console_address: config.tokio_console_address,
            tokio_console_retention_secs: config.tokio_console_retention_secs,
        })
    }
}

fn from_str_to_network_with_aliases<'de, D>(deserializer: D) -> Result<Network, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let network_name = String::deserialize(deserializer)?;

    match network_name.to_lowercase().as_str() {
        "dash" | "mainnet" | "main" => Ok(Network::Mainnet),
        "local" | "regtest" => Ok(Network::Regtest),
        "testnet" | "test" => Ok(Network::Testnet),
        "devnet" | "dev" => Ok(Network::Devnet),
        _ => Err(serde::de::Error::custom(format!(
            "can't parse network name: unknown network '{network_name}'"
        ))),
    }
}

/// A config suitable for a quorum configuration
pub trait QuorumLikeConfig: Sized {
    /// Quorum type
    fn quorum_type(&self) -> QuorumType;

    /// Quorum size
    fn quorum_size(&self) -> u16;

    /// Quorum DKG interval
    fn quorum_window(&self) -> u32;

    /// Quorum active signers count
    fn quorum_active_signers(&self) -> u16;

    /// Quorum rotation (dip24) or classic
    fn quorum_rotation(&self) -> bool;
}

/// Chain Lock quorum configuration
#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct ValidatorSetConfig {
    /// The quorum type used for verifying chain locks
    #[serde(
        rename = "validator_set_quorum_type",
        serialize_with = "serialize_quorum_type",
        deserialize_with = "deserialize_quorum_type"
    )]
    pub quorum_type: QuorumType,

    /// The quorum size
    #[serde(
        rename = "validator_set_quorum_size",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_size: u16,

    /// The quorum window (DKG interval)
    /// On Mainnet Chain Locks are signed using 400_60: One quorum in every 288 blocks and activeQuorumCount is 4.
    /// On Testnet Chain Locks are signed using 50_60: One quorum in every 24 blocks and activeQuorumCount is 24.
    #[serde(
        rename = "validator_set_quorum_window",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_window: u32,

    /// The number of active signers
    #[serde(
        rename = "validator_set_quorum_active_signers",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_active_signers: u16,

    /// Whether the quorum is rotated DIP24 or classic
    #[serde(
        rename = "validator_set_quorum_rotation",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_rotation: bool,
}

impl Default for ValidatorSetConfig {
    fn default() -> Self {
        // Mainnet
        Self::default_100_67()
    }
}

impl ValidatorSetConfig {
    /// Creates a default config for LLMQ 100 67
    pub fn default_100_67() -> Self {
        Self {
            quorum_type: QuorumType::Llmq100_67,
            quorum_size: 100,
            quorum_window: 24,
            quorum_active_signers: 24,
            quorum_rotation: false,
        }
    }
}

impl QuorumLikeConfig for ValidatorSetConfig {
    fn quorum_type(&self) -> QuorumType {
        self.quorum_type
    }

    fn quorum_size(&self) -> u16 {
        self.quorum_size
    }

    fn quorum_window(&self) -> u32 {
        self.quorum_window
    }

    fn quorum_active_signers(&self) -> u16 {
        self.quorum_active_signers
    }

    fn quorum_rotation(&self) -> bool {
        self.quorum_rotation
    }
}

/// Chain Lock quorum configuration
#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct ChainLockConfig {
    /// The quorum type used for verifying chain locks
    #[serde(
        rename = "chain_lock_quorum_type",
        serialize_with = "serialize_quorum_type",
        deserialize_with = "deserialize_quorum_type"
    )]
    pub quorum_type: QuorumType,

    /// The quorum size
    #[serde(
        rename = "chain_lock_quorum_size",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_size: u16,

    /// The quorum window (DKG interval)
    /// On Mainnet Chain Locks are signed using 400_60: One quorum in every 288 blocks and activeQuorumCount is 4.
    /// On Testnet Chain Locks are signed using 50_60: One quorum in every 24 blocks and activeQuorumCount is 24.
    #[serde(
        rename = "chain_lock_quorum_window",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_window: u32,

    /// The number of active signers
    #[serde(
        rename = "chain_lock_quorum_active_signers",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_active_signers: u16,

    /// Whether the quorum is rotated DIP24 or classic
    #[serde(
        rename = "chain_lock_quorum_rotation",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_rotation: bool,
}

impl Default for ChainLockConfig {
    fn default() -> Self {
        // Mainnet
        Self {
            quorum_type: QuorumType::Llmq400_60,
            quorum_size: 400,
            quorum_window: 24 * 12,
            quorum_active_signers: 4,
            quorum_rotation: false,
        }
    }
}

impl QuorumLikeConfig for ChainLockConfig {
    fn quorum_type(&self) -> QuorumType {
        self.quorum_type
    }

    fn quorum_size(&self) -> u16 {
        self.quorum_size
    }

    fn quorum_window(&self) -> u32 {
        self.quorum_window
    }

    fn quorum_active_signers(&self) -> u16 {
        self.quorum_active_signers
    }

    fn quorum_rotation(&self) -> bool {
        self.quorum_rotation
    }
}

impl ChainLockConfig {
    /// Creates a default config for LLMQ 100 67
    pub fn default_100_67() -> Self {
        Self {
            quorum_type: QuorumType::Llmq100_67,
            quorum_size: 100,
            quorum_window: 24,
            quorum_active_signers: 24,
            quorum_rotation: false,
        }
    }
}

/// Chain Lock quorum configuration
#[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
pub struct InstantLockConfig {
    /// The quorum type used for verifying chain locks
    #[serde(
        rename = "instant_lock_quorum_type",
        serialize_with = "serialize_quorum_type",
        deserialize_with = "deserialize_quorum_type"
    )]
    pub quorum_type: QuorumType,

    /// The quorum size
    #[serde(
        rename = "instant_lock_quorum_size",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_size: u16,

    /// The quorum window (DKG interval)
    /// On Mainnet Chain Locks are signed using 400_60: One quorum in every 288 blocks and activeQuorumCount is 4.
    /// On Testnet Chain Locks are signed using 50_60: One quorum in every 24 blocks and activeQuorumCount is 24.
    #[serde(
        rename = "instant_lock_quorum_window",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_window: u32,

    /// The number of active signers
    #[serde(
        rename = "instant_lock_quorum_active_signers",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_active_signers: u16,

    /// Whether the quorum is rotated DIP24 or classic
    #[serde(
        rename = "instant_lock_quorum_rotation",
        deserialize_with = "from_str_or_number"
    )]
    pub quorum_rotation: bool,
}

impl Default for InstantLockConfig {
    fn default() -> Self {
        // Mainnet
        Self {
            quorum_type: QuorumType::Llmq60_75,
            quorum_active_signers: 32,
            quorum_size: 60,
            quorum_window: 24 * 12,
            quorum_rotation: true,
        }
    }
}

impl InstantLockConfig {
    /// Creates a default config for LLMQ 100 67
    pub fn default_100_67() -> Self {
        Self {
            quorum_type: QuorumType::Llmq100_67,
            quorum_size: 100,
            quorum_window: 24,
            quorum_active_signers: 24,
            quorum_rotation: false,
        }
    }
}

impl QuorumLikeConfig for InstantLockConfig {
    fn quorum_type(&self) -> QuorumType {
        self.quorum_type
    }

    fn quorum_size(&self) -> u16 {
        self.quorum_size
    }

    fn quorum_window(&self) -> u32 {
        self.quorum_window
    }

    fn quorum_active_signers(&self) -> u16 {
        self.quorum_active_signers
    }

    fn quorum_rotation(&self) -> bool {
        self.quorum_rotation
    }
}

fn serialize_quorum_type<S>(quorum_type: &QuorumType, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    serializer.serialize_str(quorum_type.to_string().as_str())
}

fn deserialize_quorum_type<'de, D>(deserializer: D) -> Result<QuorumType, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let quorum_type_name = String::deserialize(deserializer)?;

    let quorum_type = if let Ok(t) = quorum_type_name.trim().parse::<u32>() {
        QuorumType::from(t)
    } else {
        QuorumType::from(quorum_type_name.as_str())
    };

    if quorum_type == QuorumType::UNKNOWN {
        return Err(serde::de::Error::custom(format!(
            "unsupported QUORUM_TYPE: {}",
            quorum_type_name
        )));
    };

    Ok(quorum_type)
}

impl ExecutionConfig {
    fn default_verify_sum_trees() -> bool {
        true
    }

    fn default_verify_token_sum_trees() -> bool {
        true
    }

    fn default_use_document_triggers() -> bool {
        true
    }

    fn default_epoch_time_length_s() -> u64 {
        DEFAULT_EPOCH_TIME_LENGTH_S
    }
}

impl PlatformConfig {
    fn default_initial_protocol_version() -> ProtocolVersion {
        INITIAL_PROTOCOL_VERSION
    }

    fn default_network() -> Network {
        Network::Mainnet
    }

    fn default_tokio_console_address() -> String {
        String::from("127.0.0.1:6669")
    }

    fn default_tokio_console_retention_secs() -> u64 {
        60 * 3
    }
}

/// create new object using values from environment variables
pub trait FromEnv {
    /// create new object using values from environment variables
    fn from_env() -> Result<Self, Error>
    where
        Self: Sized + DeserializeOwned,
    {
        envy::from_env::<Self>().map_err(Error::from)
    }
}

impl FromEnv for PlatformConfig {
    fn from_env() -> Result<Self, Error>
    where
        Self: Sized + DeserializeOwned,
    {
        let mut me = envy::from_env::<Self>().map_err(Error::from)?;
        me.abci.log = LogConfigs::from_env()?;

        Ok(me)
    }
}

impl Default for ExecutionConfig {
    fn default() -> Self {
        Self {
            use_document_triggers: ExecutionConfig::default_use_document_triggers(),
            verify_sum_trees: ExecutionConfig::default_verify_sum_trees(),
            verify_token_sum_trees: ExecutionConfig::default_verify_token_sum_trees(),
            epoch_time_length_s: ExecutionConfig::default_epoch_time_length_s(),
        }
    }
}

impl Default for PlatformConfig {
    fn default() -> Self {
        Self::default_mainnet()
    }
}

/// The platform config
impl PlatformConfig {
    /// The default depending on the network
    pub fn default_for_network(network: Network) -> Self {
        match network {
            Network::Mainnet => Self::default_mainnet(),
            Network::Testnet => Self::default_testnet(),
            Network::Devnet => Self::default_devnet(),
            Network::Regtest => Self::default_local(),
        }
    }

    /// The default local config
    pub fn default_local() -> Self {
        Self {
            network: Network::Regtest,
            validator_set: ValidatorSetConfig {
                quorum_type: QuorumType::LlmqTestPlatform,
                quorum_size: 3,
                quorum_window: 24,
                quorum_active_signers: 2,
                quorum_rotation: false,
            },
            chain_lock: ChainLockConfig {
                quorum_type: QuorumType::LlmqTest,
                quorum_active_signers: 2,
                quorum_size: 3,
                quorum_window: 24,
                quorum_rotation: false,
            },
            instant_lock: InstantLockConfig {
                quorum_type: QuorumType::LlmqTest,
                quorum_active_signers: 2,
                quorum_size: 3,
                quorum_window: 24,
                quorum_rotation: false,
            },
            block_spacing_ms: 5000,
            drive: Default::default(),
            abci: Default::default(),
            core: Default::default(),
            execution: Default::default(),
            db_path: PathBuf::from("/var/lib/dash-platform/data"),
            rejections_path: Some(PathBuf::from("/var/log/dash/rejected")),
            #[cfg(feature = "testing-config")]
            testing_configs: PlatformTestConfig::default(),
            tokio_console_enabled: false,
            tokio_console_address: PlatformConfig::default_tokio_console_address(),
            tokio_console_retention_secs: PlatformConfig::default_tokio_console_retention_secs(),
            prometheus_bind_address: None,
            grpc_bind_address: "127.0.0.1:26670".to_string(),
        }
    }

    /// The default devnet config
    pub fn default_devnet() -> Self {
        Self {
            network: Network::Regtest,
            validator_set: ValidatorSetConfig {
                quorum_type: QuorumType::LlmqDevnetPlatform,
                quorum_size: 12,
                quorum_window: 24,
                quorum_active_signers: 8,
                quorum_rotation: false,
            },
            chain_lock: ChainLockConfig {
                quorum_type: QuorumType::LlmqDevnetPlatform,
                quorum_size: 12,
                quorum_window: 24,
                quorum_active_signers: 8,
                quorum_rotation: false,
            },
            instant_lock: InstantLockConfig {
                quorum_type: QuorumType::LlmqDevnetDip0024,
                quorum_active_signers: 4,
                quorum_size: 8,
                quorum_window: 48,
                quorum_rotation: true,
            },
            block_spacing_ms: 5000,
            drive: Default::default(),
            abci: Default::default(),
            core: Default::default(),
            execution: Default::default(),
            db_path: PathBuf::from("/var/lib/dash-platform/data"),
            rejections_path: Some(PathBuf::from("/var/log/dash/rejected")),
            #[cfg(feature = "testing-config")]
            testing_configs: PlatformTestConfig::default(),
            tokio_console_enabled: false,
            tokio_console_address: PlatformConfig::default_tokio_console_address(),
            tokio_console_retention_secs: PlatformConfig::default_tokio_console_retention_secs(),
            prometheus_bind_address: None,
            grpc_bind_address: "127.0.0.1:26670".to_string(),
        }
    }

    /// The default testnet config
    pub fn default_testnet() -> Self {
        Self {
            network: Network::Testnet,
            validator_set: ValidatorSetConfig {
                quorum_type: QuorumType::Llmq25_67,
                quorum_size: 25,
                quorum_window: 24,
                quorum_active_signers: 24,
                quorum_rotation: false,
            },
            chain_lock: ChainLockConfig {
                quorum_type: QuorumType::Llmq50_60,
                quorum_active_signers: 24,
                quorum_size: 50,
                quorum_window: 24,
                quorum_rotation: false,
            },
            instant_lock: InstantLockConfig {
                quorum_type: QuorumType::Llmq60_75,
                quorum_active_signers: 32,
                quorum_size: 60,
                quorum_window: 24 * 12,
                quorum_rotation: true,
            },
            block_spacing_ms: 5000,
            drive: DriveConfig::default_testnet(),
            abci: Default::default(),
            core: Default::default(),
            execution: Default::default(),
            db_path: PathBuf::from("/var/lib/dash-platform/data"),
            rejections_path: Some(PathBuf::from("/var/log/dash/rejected")),
            #[cfg(feature = "testing-config")]
            testing_configs: PlatformTestConfig::default(),
            prometheus_bind_address: None,
            grpc_bind_address: "127.0.0.1:26670".to_string(),
            tokio_console_enabled: false,
            tokio_console_address: PlatformConfig::default_tokio_console_address(),
            tokio_console_retention_secs: PlatformConfig::default_tokio_console_retention_secs(),
        }
    }

    /// The default mainnet config
    pub fn default_mainnet() -> Self {
        Self {
            network: Network::Mainnet,
            validator_set: ValidatorSetConfig {
                quorum_type: QuorumType::Llmq100_67,
                quorum_size: 100,
                quorum_window: 24,
                quorum_active_signers: 24,
                quorum_rotation: false,
            },
            chain_lock: ChainLockConfig {
                quorum_type: QuorumType::Llmq400_60,
                quorum_active_signers: 4,
                quorum_size: 400,
                quorum_window: 24 * 12,
                quorum_rotation: false,
            },
            instant_lock: InstantLockConfig {
                quorum_type: QuorumType::Llmq60_75,
                quorum_active_signers: 32,
                quorum_size: 60,
                quorum_window: 24 * 12,
                quorum_rotation: true,
            },
            block_spacing_ms: 5000,
            drive: Default::default(),
            abci: Default::default(),
            core: Default::default(),
            execution: Default::default(),
            db_path: PathBuf::from("/var/lib/dash-platform/data"),
            rejections_path: Some(PathBuf::from("/var/log/dash/rejected")),
            #[cfg(feature = "testing-config")]
            testing_configs: PlatformTestConfig::default(),
            prometheus_bind_address: None,
            grpc_bind_address: "127.0.0.1:26670".to_string(),
            tokio_console_enabled: false,
            tokio_console_address: PlatformConfig::default_tokio_console_address(),
            tokio_console_retention_secs: PlatformConfig::default_tokio_console_retention_secs(),
        }
    }
}

/// A step of checkpoint creation, in execution order.
///
/// Names the failing step in checkpoint errors and, with the `testing-config`
/// feature, the step a fault-injection test wants to fail.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CheckpointStep {
    /// Creating the `checkpoints` directory under the database path.
    CreateDirectory,
    /// Taking the GroveDB checkpoint into its own directory.
    CreateCheckpoint,
    /// Writing the platform state file into the checkpoint directory.
    WriteState,
    /// Opening the finished checkpoint database.
    OpenCheckpoint,
}

impl CheckpointStep {
    /// What the step was doing, for error messages.
    pub fn description(self) -> &'static str {
        match self {
            CheckpointStep::CreateDirectory => "trying to create checkpoints directory",
            CheckpointStep::CreateCheckpoint => "trying to create grovedb checkpoint",
            CheckpointStep::WriteState => "trying to write checkpoint platform state",
            CheckpointStep::OpenCheckpoint => "trying to open grovedb checkpoint",
        }
    }
}

#[cfg(feature = "testing-config")]
/// Configs that should only happen during testing
#[derive(Clone, Debug)]
pub struct PlatformTestConfig {
    /// Block signing
    pub block_signing: bool,
    /// Storing of platform state
    pub store_platform_state: bool,
    /// Block signature verification
    pub block_commit_signature_verification: bool,
    /// Disable instant lock signature verification
    pub disable_instant_lock_signature_verification: bool,
    /// Disable checkpoint creation during tests
    pub disable_checkpoints: bool,
    /// Steps to fail on the next checkpoint attempts, one entry per attempt in order,
    /// for fault-injection tests.
    ///
    /// Each attempt consumes the front entry, so `[step]` fails once and the immediate
    /// retry succeeds, while `[step, step]` fails both attempts and the checkpoint is
    /// skipped.
    pub checkpoint_faults:
        std::sync::Arc<std::sync::Mutex<std::collections::VecDeque<CheckpointStep>>>,
}

#[cfg(feature = "testing-config")]
impl PlatformTestConfig {
    /// Much faster config for tests
    pub fn default_minimal_verifications() -> Self {
        Self {
            block_signing: false,
            store_platform_state: false,
            block_commit_signature_verification: false,
            disable_instant_lock_signature_verification: true,
            disable_checkpoints: true,
            checkpoint_faults: Default::default(),
        }
    }
}

#[cfg(feature = "testing-config")]
impl Default for PlatformTestConfig {
    fn default() -> Self {
        Self {
            block_signing: true,
            store_platform_state: true,
            block_commit_signature_verification: true,
            disable_instant_lock_signature_verification: false,
            disable_checkpoints: true,
            checkpoint_faults: Default::default(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::FromEnv;
    use crate::config::{
        ChainLockConfig, ConsensusCoreRpcConfig, CoreConfig, InstantLockConfig, PlatformConfig,
        QuorumLikeConfig, ValidatorSetConfig,
    };
    use crate::logging::LogDestination;
    use dpp::dashcore::Network;
    use dpp::dashcore_rpc::dashcore_rpc_json::QuorumType;
    use std::env;

    #[test]
    fn test_config_from_env() {
        // ABCI log configs are parsed manually, so they deserve separate handling
        // Note that STDOUT is also defined in .env.example, but env var should overwrite it.
        let vectors = &[
            ("STDOUT", "pretty"),
            ("UPPERCASE", "json"),
            ("lowercase", "pretty"),
            ("miXedC4s3", "full"),
            ("123", "compact"),
        ];
        for vector in vectors {
            env::set_var(format!("ABCI_LOG_{}_DESTINATION", vector.0), "bytes");
            env::set_var(format!("ABCI_LOG_{}_FORMAT", vector.0), vector.1);
        }

        let envfile = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(".env.local");

        dotenvy::from_path(envfile.as_path()).expect("cannot load .env file");
        assert_eq!("/tmp/db", env::var("DB_PATH").unwrap());
        assert_eq!("/tmp/rejected", env::var("REJECTIONS_PATH").unwrap());

        let config = super::PlatformConfig::from_env().expect("expected config from env");
        assert!(config.execution.verify_sum_trees);
        assert_ne!(config.validator_set.quorum_type, QuorumType::UNKNOWN);
        for id in vectors {
            matches!(config.abci.log[id.0].destination, LogDestination::Bytes);
        }
    }

    #[test]
    #[ignore]
    //todo: re-enable
    fn test_config_from_testnet_propagates_network() {
        // ABCI log configs are parsed manually, so they deserve separate handling
        // Note that STDOUT is also defined in .env.example, but env var should overwrite it.

        let envfile = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(".env.testnet");

        dotenvy::from_path(envfile.as_path()).expect("cannot load .env file");

        let config = super::PlatformConfig::from_env().expect("expected config from env");
        assert!(config.execution.verify_sum_trees);
        assert_eq!(config.validator_set.quorum_type, QuorumType::Llmq25_67);
        assert_eq!(config.network, config.drive.network);
        assert_eq!(config.network, Network::Testnet);
    }

    // --- `from_str_to_network_with_aliases`: valid aliases and error path ---

    /// Ensures every network alias accepted by the deserializer maps to the
    /// expected `Network`, case-insensitively. This exercises each match arm in
    /// `from_str_to_network_with_aliases`, which is otherwise only called at
    /// most once per integration-test setup.
    #[test]
    fn network_aliases_deserialize_all_variants_case_insensitively() {
        let cases = &[
            ("\"dash\"", Network::Mainnet),
            ("\"DASH\"", Network::Mainnet),
            ("\"MainNet\"", Network::Mainnet),
            ("\"main\"", Network::Mainnet),
            ("\"local\"", Network::Regtest),
            ("\"regtest\"", Network::Regtest),
            ("\"testnet\"", Network::Testnet),
            ("\"TEST\"", Network::Testnet),
            ("\"devnet\"", Network::Devnet),
            ("\"Dev\"", Network::Devnet),
        ];

        for (input, expected) in cases {
            let mut de = serde_json::Deserializer::from_str(input);
            let network = super::from_str_to_network_with_aliases(&mut de)
                .expect("alias should parse successfully");
            assert_eq!(
                &network, expected,
                "input {} should map to {:?}",
                input, expected
            );
        }
    }

    /// Verifies that an unknown network alias produces a clear deserializer error.
    /// This covers the final arm of `from_str_to_network_with_aliases`.
    #[test]
    fn network_alias_unknown_value_returns_custom_error() {
        let mut de = serde_json::Deserializer::from_str("\"nonsense_network\"");
        let err = super::from_str_to_network_with_aliases(&mut de)
            .expect_err("unknown network should fail");
        let msg = err.to_string();
        assert!(
            msg.contains("unknown network") && msg.contains("nonsense_network"),
            "error message should name the offending value, got: {}",
            msg
        );
    }

    // --- `deserialize_quorum_type`: numeric/string/UNKNOWN error path ---

    /// Covers the string-name branch of `deserialize_quorum_type`.
    #[test]
    fn deserialize_quorum_type_accepts_string_names() {
        // All numeric fields use `from_str_or_number`, which requires a JSON
        // string (even for numbers).
        let json = r#"{
            "validator_set_quorum_type": "llmq_25_67",
            "validator_set_quorum_size": "25",
            "validator_set_quorum_window": "24",
            "validator_set_quorum_active_signers": "24",
            "validator_set_quorum_rotation": "false"
        }"#;
        let cfg: ValidatorSetConfig =
            serde_json::from_str(json).expect("quorum type string should deserialize");
        assert_eq!(cfg.quorum_type, QuorumType::Llmq25_67);
    }

    /// Covers the numeric (u32) branch of `deserialize_quorum_type` (a number
    /// serialized as a JSON string still goes through the `parse::<u32>()` path).
    #[test]
    fn deserialize_quorum_type_accepts_numeric_string() {
        let json = r#"{
            "validator_set_quorum_type": "6",
            "validator_set_quorum_size": "25",
            "validator_set_quorum_window": "24",
            "validator_set_quorum_active_signers": "24",
            "validator_set_quorum_rotation": "false"
        }"#;
        let cfg: ValidatorSetConfig =
            serde_json::from_str(json).expect("numeric quorum type should deserialize");
        // QuorumType::from(6) should be a known variant; we only assert it is not UNKNOWN.
        assert_ne!(cfg.quorum_type, QuorumType::UNKNOWN);
    }

    /// Covers the `UNKNOWN` rejection branch of `deserialize_quorum_type`.
    #[test]
    fn deserialize_quorum_type_rejects_unknown_names() {
        let json = r#"{
            "validator_set_quorum_type": "this_is_not_a_quorum",
            "validator_set_quorum_size": "25",
            "validator_set_quorum_window": "24",
            "validator_set_quorum_active_signers": "24",
            "validator_set_quorum_rotation": "false"
        }"#;
        let err = serde_json::from_str::<ValidatorSetConfig>(json)
            .expect_err("unknown quorum type name should fail");
        let msg = err.to_string();
        assert!(
            msg.contains("unsupported") && msg.contains("QUORUM_TYPE"),
            "expected unsupported QUORUM_TYPE error, got: {}",
            msg
        );
    }

    // --- Core RPC URL composition and defaults ---

    /// Exercises `ConsensusCoreRpcConfig::url` formatting.
    #[test]
    fn consensus_core_rpc_url_composes_host_and_port() {
        let cfg = ConsensusCoreRpcConfig {
            host: "node.example".to_string(),
            port: 9998,
            username: "u".to_string(),
            password: "p".to_string(),
        };
        assert_eq!(cfg.url(), "node.example:9998");
    }

    /// Exercises `CheckTxCoreRpcConfig::url` formatting.
    #[test]
    fn check_tx_core_rpc_url_composes_host_and_port() {
        let cfg = super::CheckTxCoreRpcConfig {
            host: "127.0.0.1".to_string(),
            port: 1,
            username: String::new(),
            password: String::new(),
        };
        assert_eq!(cfg.url(), "127.0.0.1:1");
    }

    /// `CoreConfig::default()` should be empty strings and zero port (covers
    /// the auto-derived `Default` with both flattened members).
    #[test]
    fn core_config_default_is_empty() {
        let cfg = CoreConfig::default();
        assert_eq!(cfg.consensus_rpc.host, "");
        assert_eq!(cfg.consensus_rpc.port, 0);
        assert_eq!(cfg.check_tx_rpc.host, "");
        assert_eq!(cfg.check_tx_rpc.port, 0);
    }

    // --- `default_for_network` dispatch, including the catch-all ---

    /// Exercises the `Network::Mainnet`, `Network::Testnet`, `Network::Devnet`,
    /// `Network::Regtest` arms of `default_for_network`.
    #[test]
    fn default_for_network_dispatches_all_known_networks() {
        let mainnet = PlatformConfig::default_for_network(Network::Mainnet);
        assert_eq!(mainnet.network, Network::Mainnet);
        assert_eq!(mainnet.validator_set.quorum_type, QuorumType::Llmq100_67);

        let testnet = PlatformConfig::default_for_network(Network::Testnet);
        assert_eq!(testnet.network, Network::Testnet);
        assert_eq!(testnet.validator_set.quorum_type, QuorumType::Llmq25_67);

        let devnet = PlatformConfig::default_for_network(Network::Devnet);
        // default_devnet currently sets network to Regtest (see impl).
        assert_eq!(devnet.network, Network::Regtest);

        let regtest = PlatformConfig::default_for_network(Network::Regtest);
        assert_eq!(regtest.network, Network::Regtest);
    }

    // --- `ValidatorSetConfig::default_100_67` and QuorumLikeConfig getters ---

    /// Exercises `default_100_67` + every getter in `QuorumLikeConfig` for
    /// `ValidatorSetConfig` - these getters are pure accessors that would
    /// otherwise be uncovered outside the actual consensus path.
    #[test]
    fn validator_set_default_100_67_accessors() {
        let cfg = ValidatorSetConfig::default_100_67();
        assert_eq!(cfg.quorum_type(), QuorumType::Llmq100_67);
        assert_eq!(cfg.quorum_size(), 100);
        assert_eq!(cfg.quorum_window(), 24);
        assert_eq!(cfg.quorum_active_signers(), 24);
        assert!(!cfg.quorum_rotation());
    }

    /// Same but for `ChainLockConfig::default_100_67`.
    #[test]
    fn chain_lock_default_100_67_accessors() {
        let cfg = ChainLockConfig::default_100_67();
        assert_eq!(cfg.quorum_type(), QuorumType::Llmq100_67);
        assert_eq!(cfg.quorum_size(), 100);
        assert_eq!(cfg.quorum_window(), 24);
        assert_eq!(cfg.quorum_active_signers(), 24);
        assert!(!cfg.quorum_rotation());
    }

    /// `ChainLockConfig::default()` is Mainnet LLMQ400_60 - cover all getters.
    #[test]
    fn chain_lock_default_is_llmq_400_60() {
        let cfg = ChainLockConfig::default();
        assert_eq!(cfg.quorum_type(), QuorumType::Llmq400_60);
        assert_eq!(cfg.quorum_size(), 400);
        assert_eq!(cfg.quorum_window(), 24 * 12);
        assert_eq!(cfg.quorum_active_signers(), 4);
        assert!(!cfg.quorum_rotation());
    }

    /// `InstantLockConfig::default()` is DIP24 rotated LLMQ60_75.
    #[test]
    fn instant_lock_default_is_llmq_60_75_rotated() {
        let cfg = InstantLockConfig::default();
        assert_eq!(cfg.quorum_type(), QuorumType::Llmq60_75);
        assert_eq!(cfg.quorum_size(), 60);
        assert_eq!(cfg.quorum_window(), 24 * 12);
        assert_eq!(cfg.quorum_active_signers(), 32);
        assert!(cfg.quorum_rotation());
    }

    /// `InstantLockConfig::default_100_67` is the classic LLMQ variant.
    #[test]
    fn instant_lock_default_100_67_accessors() {
        let cfg = InstantLockConfig::default_100_67();
        assert_eq!(cfg.quorum_type(), QuorumType::Llmq100_67);
        assert_eq!(cfg.quorum_size(), 100);
        assert_eq!(cfg.quorum_window(), 24);
        assert_eq!(cfg.quorum_active_signers(), 24);
        assert!(!cfg.quorum_rotation());
    }

    /// Exercises `PlatformConfig::default()` which delegates to `default_mainnet`.
    #[test]
    fn platform_config_default_is_mainnet() {
        let cfg = PlatformConfig::default();
        assert_eq!(cfg.network, Network::Mainnet);
        assert_eq!(cfg.validator_set.quorum_type, QuorumType::Llmq100_67);
        assert_eq!(cfg.chain_lock.quorum_type, QuorumType::Llmq400_60);
        assert_eq!(cfg.instant_lock.quorum_type, QuorumType::Llmq60_75);
        assert_eq!(cfg.block_spacing_ms, 5000);
    }

    // --- `ExecutionConfig` default values ---

    /// Exercises all four default-provider functions on `ExecutionConfig`.
    #[test]
    fn execution_config_defaults() {
        let cfg = super::ExecutionConfig::default();
        assert!(cfg.verify_sum_trees);
        assert!(cfg.verify_token_sum_trees);
        assert!(cfg.use_document_triggers);
        assert_eq!(cfg.epoch_time_length_s, 788400);
    }

    // --- `serialize_quorum_type` round-trip via Serialize ---

    /// Covers the `serialize_quorum_type` codepath (symmetric pair of the
    /// deserialize tests above).
    #[test]
    fn validator_set_config_serializes_quorum_type_as_string() {
        let cfg = ValidatorSetConfig::default_100_67();
        let json = serde_json::to_string(&cfg).expect("valid serialize");
        // The serialized representation must use the textual form.
        assert!(
            json.contains("llmq_100_67") || json.contains("Llmq100_67"),
            "expected textual quorum type in JSON, got: {}",
            json
        );
    }
}