Struct Config 

pub struct Config {
    pub cache_dir: PathBuf,
    pub ephemeral: bool,
    pub should_backup_non_finalized_state: bool,
    pub delete_old_database: bool,
    pub debug_stop_at_height: Option<u32>,
    pub debug_validity_check_interval: Option<Duration>,
}

Configuration for the state service.

Fields

cache_dir: PathBuf

The root directory for storing cached block data.

If you change this directory, you might also want to change network.cache_dir.

This cache stores permanent blockchain state that can be replicated from the network, including the best chain, blocks, the UTXO set, and other indexes. Any state that can be rolled back is only stored in memory.

The zebra-state cache does not include any private data, such as wallet data.

You can delete the entire cached state directory, but it will impact your node’s readiness and network usage. If you do, Zebra will re-sync from genesis the next time it is launched.

The default directory is platform dependent, based on dirs::cache_dir():

Platform	Value	Example
Linux	$XDG_CACHE_HOME/zebra or $HOME/.cache/zebra	/home/alice/.cache/zebra
macOS	$HOME/Library/Caches/zebra	/Users/Alice/Library/Caches/zebra
Windows	{FOLDERID_LocalAppData}\zebra	C:\Users\Alice\AppData\Local\zebra
Other	std::env::current_dir()/cache/zebra	/cache/zebra

Security

If you are running Zebra with elevated permissions (“root”), create the directory for this file before running Zebra, and make sure the Zebra user account has exclusive access to that directory, and other users can’t modify its parent directories.

Implementation Details

Each state format version and network has a separate state. These states are stored in state/vN/mainnet and state/vN/testnet subdirectories, underneath the cache_dir path, where N is the state format version.

When Zebra’s state format changes, it creates a new state subdirectory for that version, and re-syncs from genesis.

Old state versions are automatically deleted at startup. You can also manually delete old state versions.

ephemeral: bool

Whether to use an ephemeral database.

Ephemeral databases are stored in a temporary directory created using tempfile::tempdir(). They are deleted when Zebra exits successfully. (If Zebra panics or crashes, the ephemeral database won’t be deleted.)

Set to false by default. If this is set to true, cache_dir is ignored.

Ephemeral directories are created in the std::env::temp_dir(). Zebra names each directory after the state version and network, for example: zebra-state-v21-mainnet-XnyGnE.

should_backup_non_finalized_state: bool

Whether to cache non-finalized blocks on disk to be restored when Zebra restarts.

Set to true by default. If this is set to false, Zebra will irrecoverably drop non-finalized blocks when the process exits and will have to re-download them from the network when it restarts, if those blocks are still available in the network.

Note: The non-finalized state will be written to a backup cache once per 5 seconds at most. If blocks are added to the non-finalized state more frequently, the backup may not reflect Zebra’s last non-finalized state before it shut down.

delete_old_database: bool

Whether to delete the old database directories when present.

Set to true by default. If this is set to false, no check for old database versions will be made and nothing will be deleted.

debug_stop_at_height: Option<u32>

Commit blocks to the finalized state up to this height, then exit Zebra.

Set to None by default: Zebra continues syncing indefinitely.

debug_validity_check_interval: Option<Duration>

While Zebra is running, check state validity this often.

Set to None by default: Zebra only checks state format validity on startup and shutdown.

Implementations

impl Config

pub fn db_path( &self, db_kind: impl AsRef<str>, major_version: u64, network: &Network, ) -> PathBuf

Returns the path for the database, based on the kind, major version and network. Each incompatible database format or network gets its own unique path.

pub fn non_finalized_state_backup_dir( &self, network: &Network, ) -> Option<PathBuf>

Returns the path for the non-finalized state backup directory, based on the network. Non-finalized state backup files are encoded in the network protocol format and remain valid across db format upgrades.

pub fn version_file_path( &self, db_kind: impl AsRef<str>, major_version: u64, network: &Network, ) -> PathBuf

Returns the path for the database format minor/patch version file, based on the kind, major version and network.

pub fn ephemeral() -> Config

Returns a config for a temporary database that is deleted when it is dropped.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Config

where Config: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Config

fn eq(&self, other: &Config) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Config

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Config

impl StructuralPartialEq for Config