Struct L1ClientOptions 

pub struct L1ClientOptions {

    pub l1_retry_delay: Duration,
    pub l1_polling_interval: Duration,
    pub l1_blocks_cache_size: NonZeroUsize,
    pub l1_events_channel_capacity: usize,
    pub l1_events_max_block_range: u64,
    pub subscription_timeout: Duration,
    pub l1_frequent_failure_tolerance: Duration,
    pub l1_consecutive_failure_tolerance: usize,
    pub l1_failover_revert: Duration,
    pub l1_rate_limit_delay: Option<Duration>,
    pub l1_ws_provider: Option<Vec<Url>>,
    pub stake_table_update_interval: Duration,
    pub l1_events_max_retry_duration: Duration,
    pub l1_finalized_safety_margin: Option<u64>,
    pub metrics: Arc<Box<dyn Metrics>>,
}

Configuration for an L1 client.

Fields

l1_retry_delay: Duration

Delay when retrying failed L1 queries.

l1_polling_interval: Duration

Request rate when polling L1.

l1_blocks_cache_size: NonZeroUsize

Maximum number of L1 blocks to keep in cache at once.

l1_events_channel_capacity: usize

Number of L1 events to buffer before discarding.

l1_events_max_block_range: u64

Maximum number of L1 blocks that can be scanned for events in a single query.

subscription_timeout: Duration

Maximum time to wait for new heads before considering a stream invalid and reconnecting.

l1_frequent_failure_tolerance: Duration

Fail over to another provider if the current provider fails twice within this window.

l1_consecutive_failure_tolerance: usize

Fail over to another provider if the current provider fails many times in a row, within any time window.

l1_failover_revert: Duration

Revert back to the first provider this duration after failing over.

l1_rate_limit_delay: Option<Duration>

Amount of time to wait after receiving a 429 response before making more L1 RPC requests.

If not set, the general l1-retry-delay will be used.

l1_ws_provider: Option<Vec<Url>>

Separate provider to use for subscription feeds.

Typically this would be a WebSockets endpoint while the main provider uses HTTP.

stake_table_update_interval: Duration

Interval at which the background update loop polls the L1 stake table contract for new events and updates local persistence.

l1_events_max_retry_duration: Duration

Maximum duration to retry fetching L1 events before panicking.

This prevents infinite retries by panicking if the total number of retries exceed the maximum duration. This is helpful in cases where the RPC block range limit or the event return limit is hit, or if there is an outage. In such cases, panicking ensures that the node operator can take action instead of the node getting stuck indefinitely. This is necessary because the stake table is constructed from the fetched events, and is required for node to participate in consensus.

l1_finalized_safety_margin: Option<u64>

A block range which is expected to contain the finalized heads of all L1 provider chains.

If specified, it is assumed that if a block n is known to be finalized according to a certain provider, then any block less than n - L1_FINALIZED_SAFETY_MARGIN is finalized according to any provider. In other words, if we fail over from one provider to another, the second provider will never be lagging the first by more than this margin.

This allows us to quickly query for very old finalized blocks by number. Without this assumption, we always need to verify that a block is finalized by fetching all blocks in a hash chain between the known finalized block and the desired block, recomputing and checking the hashes. This is fine and good for blocks very near the finalized head, but for extremely old blocks it is prohibitively expensive, and these old blocks are extremely unlikely to be unfinalized anyways.

metrics: Arc<Box<dyn Metrics>>

Implementations

impl L1ClientOptions

pub fn with_metrics(self, metrics: &(impl Metrics + ?Sized)) -> Self

Use the given metrics collector to publish metrics related to the L1 client.

pub fn connect(self, urls: Vec<Url>) -> Result<L1Client>

Instantiate an L1Client for a given list of provider Urls.

fn rate_limit_delay(&self) -> Duration

Trait Implementations

impl Args for L1ClientOptions

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 L1ClientOptions

fn clone(&self) -> L1ClientOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CommandFactory for L1ClientOptions

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 L1ClientOptions

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

Formats the value using the given formatter.

impl Default for L1ClientOptions

fn default() -> Self

Returns the “default value” for a type.

impl FromArgMatches for L1ClientOptions

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 L1ClientOptions

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.