Enum try_runtime_cli::Command

pub enum Command {
    OnRuntimeUpgrade(OnRuntimeUpgradeCmd),
    ExecuteBlock(ExecuteBlockCmd),
    OffchainWorker(OffchainWorkerCmd),
    FollowChain(FollowChainCmd),
}

Possible commands of try-runtime.

Variants

OnRuntimeUpgrade(OnRuntimeUpgradeCmd)

Execute the migrations of the “local runtime”.

This uses a custom runtime api call, namely “TryRuntime_on_runtime_upgrade”.

This always overwrites the wasm code with the local runtime (specified by --chain), to ensure the new migrations are being executed. Re-executing already existing migrations is evidently not very exciting.

ExecuteBlock(ExecuteBlockCmd)

Executes the given block against some state.

Unlike Command::OnRuntimeUpgrade, this command needs two inputs: the state, and the block data. Since the state could be cached (see State::Snap), different flags are provided for both. --block-at and --block-uri, if provided, are only used for fetching the block. For convenience, these flags can be both emitted, if the State::Live is being used.

Note that by default, this command does not overwrite the code, so in wasm execution, the live chain’s code is used. This can be disabled if desired, see ExecuteBlockCmd::overwrite_wasm_code.

Note that if you do overwrite the wasm code, or generally use the local runtime for this, you might

• not be able to decode the block, if the block format has changed.
• quite possibly will get a signature verification failure, since the spec and transaction version are part of the signature’s payload, and if they differ between your local runtime and the remote counterparts, the signatures cannot be verified.
• almost certainly will get a state root mismatch, since, well, you are executing a different state transition function.

To make testing slightly more dynamic, you can disable the state root check by enabling ExecuteBlockCmd::no_check. If you get signature verification errors, you should manually tweak your local runtime’s spec version to fix this.

A subtle detail of execute block is that if you want to execute block 100 of a live chain again, you need to scrape the state of block 99. This is already done automatically if you use State::Live, and the parent hash of the target block is used to scrape the state. If State::Snap is being used, then this needs to be manually taken into consideration.

This does not execute the same runtime api as normal block import do, namely Core_execute_block. Instead, it uses TryRuntime_execute_block, which can optionally skip state-root check (useful for trying a unreleased runtime), and can execute runtime sanity checks as well.

OffchainWorker(OffchainWorkerCmd)

Executes the offchain worker hooks of a given block against some state.

Similar to Command::ExecuteBlock, this command needs two inputs: the state, and the header data. Likewise, --header-at and --header-uri can be filled, or omitted if State::Live is used.

Similar to Command::ExecuteBlock, this command does not overwrite the code, so in wasm execution, the live chain’s code is used. This can be disabled if desired, see OffchainWorkerCmd::overwrite_wasm_code.

This executes the same runtime api as normal block import, namely OffchainWorkerApi_offchain_worker.

FollowChain(FollowChainCmd)

Follow the given chain’s finalized blocks and apply all of its extrinsics.

This is essentially repeated calls to Command::ExecuteBlock, whilst the local runtime is always at use, the state root check is disabled, and the state is persisted between executions.

This allows the behavior of a new runtime to be inspected over a long period of time, with realistic transactions coming as input.

NOTE: this does NOT execute the offchain worker hooks of mirrored blocks. This might be added in the future.

This does not support snapshot states, and can only work with a remote chain. Upon first connections, starts listening for finalized block events. Upon first block notification, it initializes the state from the remote node, and starts applying that block, plus all the blocks that follow, to the same growing state.

Trait Implementations

impl Clone for Command

fn clone(&self) -> Command

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Command

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

Formats the value using the given formatter.

impl FromArgMatches for Command

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<'b>(
    &mut self,
    __clap_arg_matches: &mut ArgMatches
) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Command

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

Append to Command so it can instantiate Self.

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

Append to Command so it can update self.

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand