Struct Options 

pub struct Options {

    pub orchestrator_url: Url,
    pub cdn_endpoint: String,
    pub cliquenet_bind_address: NetAddr,
    pub libp2p_bind_address: String,
    pub libp2p_heartbeat_interval: Duration,
    pub libp2p_history_gossip: usize,
    pub libp2p_history_length: usize,
    pub libp2p_mesh_n: usize,
    pub libp2p_mesh_n_high: usize,
    pub libp2p_mesh_n_low: usize,
    pub libp2p_mesh_outbound_min: usize,
    pub libp2p_max_ihave_length: usize,
    pub libp2p_max_ihave_messages: usize,
    pub libp2p_published_message_ids_cache_time: Duration,
    pub libp2p_iwant_followup_time: Duration,
    pub libp2p_max_messages_per_rpc: Option<usize>,
    pub libp2p_gossip_retransmission: u32,
    pub libp2p_flood_publish: bool,
    pub libp2p_duplicate_cache_time: Duration,
    pub libp2p_fanout_ttl: Duration,
    pub libp2p_heartbeat_initial_delay: Duration,
    pub libp2p_gossip_factor: f64,
    pub libp2p_gossip_lazy: usize,
    pub libp2p_max_gossip_transmit_size: usize,
    pub libp2p_max_direct_transmit_size: u64,
    pub public_api_url: Option<Url>,
    pub libp2p_advertise_address: String,
    pub libp2p_bootstrap_nodes: Option<Vec<Multiaddr>>,
    pub builder_urls: Vec<Url>,
    pub state_relay_server_url: Url,
    pub genesis_file: PathBuf,
    pub key_set: KeySetOptions,
    modules: Vec<String>,
    pub l1_provider_url: Vec<Url>,
    pub l1_options: L1ClientOptions,
    pub is_da: bool,
    pub state_peers: Vec<Url>,
    pub config_peers: Option<Vec<Url>>,
    pub catchup_backoff: BackoffParams,
    pub catchup_base_timeout: Duration,
    pub local_catchup_timeout: Duration,
    pub logging: Config,
    pub identity: Identity,
    pub proposal_fetcher_config: ProposalFetcherConfig,
}

Fields

orchestrator_url: Url

URL of the HotShot orchestrator.

cdn_endpoint: String

The socket address of the HotShot CDN’s main entry point (the marshal) in IP:port form

cliquenet_bind_address: NetAddr

The address to bind to for cliquenet (in host:port | ip:port form)

libp2p_bind_address: String

The address to bind to for Libp2p (in host:port form)

libp2p_heartbeat_interval: Duration

Time between each Libp2p heartbeat

libp2p_history_gossip: usize

Number of past heartbeats to gossip about on Libp2p

libp2p_history_length: usize

Number of heartbeats to keep in the Libp2p memcache

libp2p_mesh_n: usize

Target number of peers for the Libp2p mesh network

libp2p_mesh_n_high: usize

Maximum number of peers in the Libp2p mesh network before removing some

libp2p_mesh_n_low: usize

Minimum number of peers in the Libp2p mesh network before adding more

libp2p_mesh_outbound_min: usize

Minimum number of outbound Libp2p peers in the mesh network before adding more

libp2p_max_ihave_length: usize

The maximum number of messages to include in a Libp2p IHAVE message

libp2p_max_ihave_messages: usize

The maximum number of IHAVE messages to accept from a Libp2p peer within a heartbeat

libp2p_published_message_ids_cache_time: Duration

Libp2p published message ids time cache duration

libp2p_iwant_followup_time: Duration

Time to wait for a Libp2p message requested through IWANT following an IHAVE advertisement

libp2p_max_messages_per_rpc: Option<usize>

The maximum number of Libp2p messages we will process in a given RPC

libp2p_gossip_retransmission: u32

How many times we will allow a Libp2p peer to request the same message id through IWANT gossip before we start ignoring them

libp2p_flood_publish: bool

If enabled newly created messages will always be sent to all peers that are subscribed to the topic and have a good enough score

libp2p_duplicate_cache_time: Duration

The time period that Libp2p message hashes are stored in the cache

libp2p_fanout_ttl: Duration

Time to live for Libp2p fanout peers

libp2p_heartbeat_initial_delay: Duration

Initial delay in each Libp2p heartbeat

libp2p_gossip_factor: f64

How many Libp2p peers we will emit gossip to at each heartbeat

libp2p_gossip_lazy: usize

Minimum number of Libp2p peers to emit gossip to during a heartbeat

libp2p_max_gossip_transmit_size: usize

The maximum number of bytes we will send in a single Libp2p gossip message

libp2p_max_direct_transmit_size: u64

The maximum number of bytes we will send in a single Libp2p direct message

public_api_url: Option<Url>

The URL we advertise to other nodes as being for our public API. Should be supplied in http://host:port form.

libp2p_advertise_address: String

The address we advertise to other nodes as being a Libp2p endpoint. Should be supplied in host:port form.

libp2p_bootstrap_nodes: Option<Vec<Multiaddr>>

A comma-separated list of Libp2p multiaddresses to use as bootstrap nodes.

Overrides those loaded from the HotShot config.

builder_urls: Vec<Url>

The URL of the builders to use for submitting transactions

state_relay_server_url: Url

URL of the Light Client State Relay Server

genesis_file: PathBuf

Path to TOML file containing genesis state.

key_set: KeySetOptions

modules: Vec<String>

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 –

l1_provider_url: Vec<Url>

Url we will use for RPC communication with L1.

l1_options: L1ClientOptions

Configuration for the L1 client.

is_da: bool

Whether or not we are a DA node.

state_peers: Vec<Url>

Peer nodes use to fetch missing state

config_peers: Option<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.

catchup_backoff: BackoffParams

Exponential backoff for fetching missing state from peers.

catchup_base_timeout: Duration

Base timeout for catchup requests to peers.

This is the initial per peer timeout for HTTP requests during state catchup

local_catchup_timeout: Duration

Timeout for local catchup provider requests.

If a local provider (e.g. database) takes longer than this, the node falls back to remote providers so it can still vote within the current view.

logging: Config

identity: Identity

proposal_fetcher_config: ProposalFetcherConfig

Implementations

impl Options

pub fn modules(&self) -> Modules

Trait Implementations

impl Args for Options

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl Clone for Options

fn clone(&self) -> Options

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CommandFactory for Options

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl Debug for Options

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

Formats the value using the given formatter.

impl FromArgMatches for Options

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Options

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.