drive/

config.rs

//! Drive Configuration File
//!

use dpp::dashcore::Network;
use dpp::fee::epoch::DEFAULT_EPOCHS_PER_ERA;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// Boolean if GroveDB batching consistency verification is enabled by default
pub const DEFAULT_GROVE_BATCHING_CONSISTENCY_VERIFICATION_ENABLED: bool = false;
/// Boolean if GroveDB has_raw in enabled by default
pub const DEFAULT_GROVE_HAS_RAW_ENABLED: bool = true;
/// Boolean if verification of GroveDB should be run on startup
pub const DEFAULT_VERIFY_GROVE_ON_STARTUP: bool = false;
/// The default default query limit
pub const DEFAULT_QUERY_LIMIT: u16 = 100;
/// The default max query limit
pub const DEFAULT_MAX_QUERY_LIMIT: u16 = 100;
/// Default maximum number of contracts in cache
pub const DEFAULT_DATA_CONTRACTS_CACHE_SIZE: u64 = 500;
/// The default length of an epoch in seconds: mainnet's, and the node's `ExecutionConfig`
/// default
pub const DEFAULT_EPOCH_TIME_LENGTH_S: u64 = 788400;

#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
/// Drive configuration struct
pub struct DriveConfig {
    /// Boolean if batching consistency verification is enabled
    #[cfg_attr(
        feature = "serde",
        serde(default = "default_batching_consistency_verification")
    )]
    pub batching_consistency_verification: bool,

    /// Boolean if has_raw is enabled
    #[cfg_attr(feature = "serde", serde(default = "default_has_raw_enabled"))]
    pub has_raw_enabled: bool,

    /// Boolean if GroveDB verification should happen on startup
    #[cfg_attr(
        feature = "serde",
        serde(default = "default_grove_verify_on_startup_enabled")
    )]
    pub grovedb_verify_on_startup: bool,

    /// The default returned count if no limit is set
    #[cfg_attr(
        feature = "serde",
        serde(
            default = "default_default_query_limit",
            deserialize_with = "from_str_or_number"
        )
    )]
    pub default_query_limit: u16,

    /// The default returned count if no limit is set
    #[cfg_attr(
        feature = "serde",
        serde(
            default = "default_epochs_per_era",
            deserialize_with = "from_str_or_number"
        )
    )]
    pub epochs_per_era: u16,

    /// The limit for user defined queries
    #[cfg_attr(
        feature = "serde",
        serde(
            default = "default_max_query_limit",
            deserialize_with = "from_str_or_number"
        )
    )]
    pub max_query_limit: u16,

    /// Default genesis time
    #[cfg_attr(feature = "serde", serde(default))]
    pub default_genesis_time: Option<u64>,

    /// Maximum number of contracts in global cache
    #[cfg_attr(
        feature = "serde",
        serde(
            default = "default_data_contracts_cache_size",
            deserialize_with = "from_str_or_number"
        )
    )]
    pub data_contracts_global_cache_size: u64,

    /// Maximum number of contracts in block candidate cache
    #[cfg_attr(
        feature = "serde",
        serde(
            default = "default_data_contracts_cache_size",
            deserialize_with = "from_str_or_number"
        )
    )]
    pub data_contracts_block_cache_size: u64,

    /// GroveDB visualizer address
    #[cfg(feature = "grovedbg")]
    #[cfg_attr(
        feature = "serde",
        serde(
            default = "default_grovedb_visualizer_address",
            deserialize_with = "from_str_to_socket_address"
        )
    )]
    pub grovedb_visualizer_address: std::net::SocketAddr,

    /// Enable GroveDB visualizer
    #[cfg(feature = "grovedbg")]
    #[cfg_attr(
        feature = "serde",
        serde(default, deserialize_with = "from_str_to_bool")
    )]
    pub grovedb_visualizer_enabled: bool,

    /// The network type
    #[cfg_attr(
        feature = "serde",
        serde(skip_deserializing, default = "DriveConfig::default_network")
    )]
    pub network: Network,

    /// How long an epoch lasts, in seconds. Neither read nor written with the rest of the
    /// config: the node sets it from its execution config's `epoch_time_length_s` when it
    /// opens Drive, so there is one source. Drive reads it only to count the epochs a
    /// document whose type declares a `ttl` has left to live, which its storage fee is paid
    /// out over; the price itself follows the fee schedule's fixed period.
    #[cfg_attr(
        feature = "serde",
        serde(skip, default = "default_epoch_time_length_s")
    )]
    pub epoch_time_length_s: u64,
}

// TODO: some weird envy behavior requires this to exist
#[cfg(all(feature = "serde", feature = "grovedbg"))]
fn from_str_to_bool<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    s.parse().map_err(serde::de::Error::custom)
}

#[cfg(feature = "serde")]
fn from_str_or_number<'de, D, T>(deserializer: D) -> Result<T, D::Error>
where
    D: serde::Deserializer<'de>,
    T: serde::Deserialize<'de> + std::str::FromStr,
    <T as std::str::FromStr>::Err: std::fmt::Display,
{
    use serde::de::Error;

    let s = String::deserialize(deserializer)?;
    s.parse::<T>().map_err(Error::custom)
}

#[cfg(all(feature = "serde", feature = "grovedbg"))]
fn from_str_to_socket_address<'de, D>(deserializer: D) -> Result<std::net::SocketAddr, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    s.parse().map_err(serde::de::Error::custom)
}

const fn default_batching_consistency_verification() -> bool {
    DEFAULT_GROVE_BATCHING_CONSISTENCY_VERIFICATION_ENABLED
}

const fn default_has_raw_enabled() -> bool {
    DEFAULT_GROVE_HAS_RAW_ENABLED
}

const fn default_grove_verify_on_startup_enabled() -> bool {
    DEFAULT_VERIFY_GROVE_ON_STARTUP
}

const fn default_default_query_limit() -> u16 {
    DEFAULT_QUERY_LIMIT
}

const fn default_epochs_per_era() -> u16 {
    DEFAULT_EPOCHS_PER_ERA
}

const fn default_epoch_time_length_s() -> u64 {
    DEFAULT_EPOCH_TIME_LENGTH_S
}

const fn default_max_query_limit() -> u16 {
    DEFAULT_MAX_QUERY_LIMIT
}

const fn default_data_contracts_cache_size() -> u64 {
    DEFAULT_DATA_CONTRACTS_CACHE_SIZE
}

/// The default grovedb visualizer_address
pub fn default_grovedb_visualizer_address() -> std::net::SocketAddr {
    "127.0.0.1:8083".parse().unwrap()
}

impl Default for DriveConfig {
    fn default() -> Self {
        DriveConfig {
            batching_consistency_verification: default_batching_consistency_verification(),
            has_raw_enabled: default_has_raw_enabled(),
            grovedb_verify_on_startup: default_grove_verify_on_startup_enabled(),
            default_query_limit: default_default_query_limit(),
            epochs_per_era: default_epochs_per_era(),
            max_query_limit: default_max_query_limit(),
            default_genesis_time: None,
            data_contracts_global_cache_size: default_data_contracts_cache_size(),
            data_contracts_block_cache_size: default_data_contracts_cache_size(),
            #[cfg(feature = "grovedbg")]
            grovedb_visualizer_address: default_grovedb_visualizer_address(),
            #[cfg(feature = "grovedbg")]
            grovedb_visualizer_enabled: false,
            network: Network::Mainnet,
            epoch_time_length_s: default_epoch_time_length_s(),
        }
    }
}

impl DriveConfig {
    /// The default network type for mainnet
    pub fn default_network() -> Network {
        Network::Mainnet
    }

    /// The default testnet configuration
    pub fn default_testnet() -> Self {
        Self {
            network: Network::Testnet,
            ..Default::default()
        }
    }
}