Struct RunCmd

pub struct RunCmd {

    pub base: RunCmd,
    pub dev_service: bool,
    pub experimental_block_import_strategy: bool,
    pub legacy_block_import_strategy: bool,
    pub lazy_loading_remote_rpc: Option<Url>,
    pub lazy_loading_block: Option<H256>,
    pub lazy_loading_state_overrides: Option<PathBuf>,
    pub lazy_loading_runtime_override: Option<PathBuf>,
    pub lazy_loading_delay_between_requests: u32,
    pub lazy_loading_max_retries_per_request: u32,
    pub sealing: Sealing,
    pub ethapi: Vec<EthApi>,
    pub ethapi_max_permits: u32,
    pub ethapi_trace_max_count: u32,
    pub ethapi_trace_cache_duration: u64,
    pub eth_log_block_cache: usize,
    pub eth_statuses_cache: usize,
    pub frontier_backend_type: FrontierBackendType,
    pub frontier_sql_backend_pool_size: u32,
    pub frontier_sql_backend_num_ops_timeout: u32,
    pub frontier_sql_backend_thread_count: u32,
    pub frontier_sql_backend_cache_size: u64,
    pub tracing_raw_max_memory_usage: usize,
    pub max_past_logs: u32,
    pub max_block_range: u32,
    pub force_moonbase: bool,
    pub force_moonriver: bool,
    pub parachain_id: Option<u32>,
    pub fee_history_limit: u64,
    pub no_hardware_benchmarks: bool,
    pub no_prometheus_prefix: bool,
    pub block_authoring_duration: Duration,
    pub nimbus_full_pov: bool,
    pub max_pov_percentage: u32,
    pub authoring: AuthoringPolicy,
    pub export_pov_to_path: Option<PathBuf>,
}

Fields

base: RunCmd

dev_service: bool

Enable the development service to run without a backing relay chain

experimental_block_import_strategy: bool

No-op Deprecated in: https://github.com/moonbeam-foundation/moonbeam/pull/3204

legacy_block_import_strategy: bool

Enable the legacy block import strategy

lazy_loading_remote_rpc: Option<Url>

Specifies the URL used to fetch chain data via RPC.

The URL should point to the RPC endpoint of the chain being forked. Ensure that the RPC has sufficient rate limits to handle the expected load.

lazy_loading_block: Option<H256>

Optional parameter to specify the block hash for lazy loading.

This parameter allows the user to specify a block hash from which to start loading data.

If not provided, the latest block will be used.

lazy_loading_state_overrides: Option<PathBuf>

Optional parameter to specify state overrides during lazy loading.

This parameter allows the user to provide a path to a file containing state overrides. The file can contain any custom state modifications that should be applied.

lazy_loading_runtime_override: Option<PathBuf>

Optional parameter to specify a runtime override when starting the lazy loading.

If not provided, it will fetch the runtime from the block being forked.

lazy_loading_delay_between_requests: u32

The delay (in milliseconds) between RPC requests when using lazy loading.

This parameter controls the amount of time (in milliseconds) to wait between consecutive RPC requests. This can help manage request rate and avoid overwhelming the server.

The default value is 100 milliseconds.

lazy_loading_max_retries_per_request: u32

The maximum number of retries for an RPC request when using lazy loading.

The default value is 10 retries.

sealing: Sealing

When blocks should be sealed in the dev service.

Options are “instant”, “manual”, or timer interval in milliseconds

ethapi: Vec<EthApi>

Public authoring identity to be inserted in the author inherent This is not currently used, but we may want a way to use it in the dev service. Enable EVM tracing module on a non-authority node.

ethapi_max_permits: u32

Number of concurrent tracing tasks. Meant to be shared by both “debug” and “trace” modules.

ethapi_trace_max_count: u32

Maximum number of trace entries a single request of trace_filter is allowed to return. A request asking for more or an unbounded one going over this limit will both return an error.

ethapi_trace_cache_duration: u64

Duration (in seconds) after which the cache of trace_filter for a given block will be discarded.

eth_log_block_cache: usize

Size in bytes of the LRU cache for block data.

eth_statuses_cache: usize

Size in bytes of the LRU cache for transactions statuses data.

frontier_backend_type: FrontierBackendType

Sets the frontier backend type (KeyValue or Sql)

frontier_sql_backend_pool_size: u32

frontier_sql_backend_num_ops_timeout: u32

Sets the SQL backend’s query timeout in number of VM ops.

frontier_sql_backend_thread_count: u32

Sets the SQL backend’s auxiliary thread limit.

frontier_sql_backend_cache_size: u64

Sets the SQL backend’s cache size in bytes. Default value is 200MB.

tracing_raw_max_memory_usage: usize

Size in bytes of data a raw tracing request is allowed to use. Bound the size of memory, stack and storage data.

max_past_logs: u32

Maximum number of logs in a query.

max_block_range: u32

Maximum block range to query logs from.

force_moonbase: bool

Force using Moonbase native runtime.

force_moonriver: bool

Force using Moonriver native runtime.

parachain_id: Option<u32>

Id of the parachain this collator collates for.

fee_history_limit: u64

Maximum fee history cache size.

no_hardware_benchmarks: bool

Disable automatic hardware benchmarks.

By default these benchmarks are automatically ran at startup and measure the CPU speed, the memory bandwidth and the disk speed.

The results are then printed out in the logs, and also sent as part of telemetry, if telemetry is enabled.

no_prometheus_prefix: bool

Removes moonbeam prefix from Prometheus metrics

block_authoring_duration: Duration

Maximum duration in milliseconds to produce a block

nimbus_full_pov: bool

Enable full proof-of-validation mode for Nimbus (deprecated, use –max-pov-percentage instead)

max_pov_percentage: u32

Maximum percentage of POV size to use (0-100)

authoring: AuthoringPolicy

Authoring style to use.

export_pov_to_path: Option<PathBuf>

Export all PoVs build by this collator to the given folder.

This is useful for debugging issues that are occurring while validating these PoVs on the relay chain.

Implementations

impl RunCmd

pub fn new_rpc_config(&self) -> RpcConfig

Methods from Deref<Target = RunCmd>

pub fn normalize(&self) -> NormalizedRunCmd

Create a [NormalizedRunCmd] which merges the collator cli argument into validator to have only one.

pub fn collator_options(&self) -> CollatorOptions

Create [CollatorOptions] representing options only relevant to parachain collator nodes

Trait Implementations

impl Args for RunCmd

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 CommandFactory for RunCmd

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 RunCmd

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

Formats the value using the given formatter.

impl Deref for RunCmd

type Target = RunCmd

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl FromArgMatches for RunCmd

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 RunCmd

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.