Struct InitStateCommand

pub struct InitStateCommand<C: ChainSpecParser> {
    pub env: EnvironmentArgs<C>,
    pub state: PathBuf,
    pub without_evm: bool,
    pub header: Option<PathBuf>,
    pub total_difficulty: Option<String>,
    pub header_hash: Option<String>,
}

Initializes the database with the genesis block.

Fields

env: EnvironmentArgs<C>

state: PathBuf

JSONL file with state dump.

Must contain accounts in following format, additional account fields are ignored. Must also contain { “root”: <state-root> } as first line. { “balance”: “<balance>”, “nonce”: <nonce>, “code”: “<bytecode>”, “storage”: { “<key>”: “<value>”, .. }, “address”: “<address>”, }

Allows init at a non-genesis block. Caution! Blocks must be manually imported up until and including the non-genesis block to init chain at. See ‘import’ command.

without_evm: bool

Specifies whether to initialize the state without relying on EVM historical data.

When enabled, and before inserting the state, it creates a dummy chain up to the last EVM block specified. It then, appends the first block provided block.

• Note: Do not import receipts and blocks beforehand, or this will fail or be ignored.

header: Option<PathBuf>

Header file containing the header in an RLP encoded format.

total_difficulty: Option<String>

Total difficulty of the header.

header_hash: Option<String>

Hash of the header.

Implementations

impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> InitStateCommand<C>

pub async fn execute<N>(self) -> Result<()>

where N: CliNodeTypes<ChainSpec = C::ChainSpec, Primitives: NodePrimitives<BlockHeader = Header>>,

Execute the init command

Trait Implementations

impl<C: ChainSpecParser> Args for InitStateCommand<C>

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<C: ChainSpecParser> CommandFactory for InitStateCommand<C>

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<C: Debug + ChainSpecParser> Debug for InitStateCommand<C>

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

Formats the value using the given formatter.

impl<C: ChainSpecParser> FromArgMatches for InitStateCommand<C>

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<C: ChainSpecParser> Parser for InitStateCommand<C>

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.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 240 bytes