diff --git a/utils/e2e-tests/bash/fixtures/help.benchmark.block.stdout.txt b/utils/e2e-tests/bash/fixtures/help.benchmark.block.stdout.txt
new file mode 100644
index 000000000..163f84ce2
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.benchmark.block.stdout.txt
@@ -0,0 +1,242 @@
+Benchmark the execution time of historic blocks.
+
+This can be used to verify that blocks do not use more weight than they consumed in their `WeightInfo`. Example:
+
+Let's say you are on a Substrate chain and want to verify that the first 3 blocks did not use more weight than declared which would otherwise be an issue. To test this with a dev node, first create one with a temp directory:
+
+$ substrate --dev -d /tmp/my-dev --execution wasm --wasm-execution compiled
+
+And wait some time to let it produce 3 blocks. Then benchmark them with:
+
+$ substrate benchmark-block --from 1 --to 3 --dev -d /tmp/my-dev --execution wasm --wasm-execution compiled --pruning archive
+
+The output will be similar to this:
+
+Block 1 with 1 tx used 77.34% of its weight ( 5,308,964 of 6,864,645 ns) Block 2 with 1 tx used 77.99% of its weight ( 5,353,992 of 6,864,645 ns) Block 3 with 1 tx used 75.91% of its weight ( 5,305,938 of 6,989,645 ns)
+
+The percent number is important and indicates how much weight was used as compared to the consumed weight. This number should be below 100% for reference hardware.
+
+Usage: humanode-peer benchmark block [OPTIONS] --from <FROM> --to <TO>
+
+Options:
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+      --database <DB>
+          Select database backend to use
+
+          Possible values:
+          - rocksdb:               Facebooks RocksDB
+          - paritydb:              ParityDb. <https://github.com/paritytech/parity-db/>
+          - auto:                  Detect whether there is an existing database. Use it, if there is, if not, create new instance of ParityDb
+          - paritydb-experimental: ParityDb. <https://github.com/paritytech/parity-db/>
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+
+      --wasm-execution <METHOD>
+          Method for executing Wasm runtime code
+          
+          [default: compiled]
+
+          Possible values:
+          - interpreted-i-know-what-i-do: Uses an interpreter
+          - compiled:                     Uses a compiled runtime
+
+      --wasmtime-instantiation-strategy <STRATEGY>
+          The WASM instantiation method to use.
+          
+          Only has an effect when `wasm-execution` is set to `compiled`.
+          
+          The copy-on-write strategies are only supported on Linux. If the copy-on-write variant of a strategy is unsupported the executor will fall back to the non-CoW equivalent.
+          
+          The fastest (and the default) strategy available is `pooling-copy-on-write`.
+          
+          The `legacy-instance-reuse` strategy is deprecated and will be removed in the future. It should only be used in case of issues with the default instantiation strategy.
+          
+          [default: pooling-copy-on-write]
+
+          Possible values:
+          - pooling-copy-on-write:           Pool the instances to avoid initializing everything from scratch on each instantiation. Use copy-on-write memory when possible
+          - recreate-instance-copy-on-write: Recreate the instance from scratch on every instantiation. Use copy-on-write memory when possible
+          - pooling:                         Pool the instances to avoid initializing everything from scratch on each instantiation
+          - recreate-instance:               Recreate the instance from scratch on every instantiation. Very slow
+          - legacy-instance-reuse:           Legacy instance reuse mechanism. DEPRECATED. Will be removed in the future
+
+      --wasm-runtime-overrides <PATH>
+          Specify the path where local WASM runtimes are stored.
+          
+          These runtimes will override on-chain runtimes when the version matches.
+
+      --execution-syncing <STRATEGY>
+          The means of execution used when calling into the runtime for importing blocks as part of an initial sync
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-import-block <STRATEGY>
+          The means of execution used when calling into the runtime for general block import (including locally authored blocks)
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-block-construction <STRATEGY>
+          The means of execution used when calling into the runtime while constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-offchain-worker <STRATEGY>
+          The means of execution used when calling into the runtime while using an off-chain worker
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-other <STRATEGY>
+          The means of execution used when calling into the runtime while not syncing, importing or constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution <STRATEGY>
+          The execution strategy that should be used by all execution contexts
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --trie-cache-size <Bytes>
+          Specify the state cache size.
+          
+          Providing `0` will disable the cache.
+          
+          [default: 67108864]
+
+      --state-cache-size <STATE_CACHE_SIZE>
+          DEPRECATED
+          
+          Switch to `--trie-cache-size`.
+
+      --from <FROM>
+          Number of the first block to consider
+
+      --to <TO>
+          Last block number to consider
+
+      --repeat <REPEAT>
+          Number of times that the benchmark should be repeated for each block
+          
+          [default: 10]
+
+      --enable-trie-cache
+          Enable the Trie cache.
+          
+          This should only be used for performance analysis and not for final results.
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.benchmark.extrinsic.stdout.txt b/utils/e2e-tests/bash/fixtures/help.benchmark.extrinsic.stdout.txt
new file mode 100644
index 000000000..252879f30
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.benchmark.extrinsic.stdout.txt
@@ -0,0 +1,245 @@
+Benchmark the execution time of different extrinsics.
+
+This is calculated by filling a block with a specific extrinsic and executing the block. The result time is then divided by the number of extrinsics in that block.
+
+NOTE: The BlockExecutionWeight is ignored  in this case since it
+
+Usage: humanode-peer benchmark extrinsic [OPTIONS]
+
+Options:
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+      --database <DB>
+          Select database backend to use
+
+          Possible values:
+          - rocksdb:               Facebooks RocksDB
+          - paritydb:              ParityDb. <https://github.com/paritytech/parity-db/>
+          - auto:                  Detect whether there is an existing database. Use it, if there is, if not, create new instance of ParityDb
+          - paritydb-experimental: ParityDb. <https://github.com/paritytech/parity-db/>
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+
+      --wasm-execution <METHOD>
+          Method for executing Wasm runtime code
+          
+          [default: compiled]
+
+          Possible values:
+          - interpreted-i-know-what-i-do: Uses an interpreter
+          - compiled:                     Uses a compiled runtime
+
+      --wasmtime-instantiation-strategy <STRATEGY>
+          The WASM instantiation method to use.
+          
+          Only has an effect when `wasm-execution` is set to `compiled`.
+          
+          The copy-on-write strategies are only supported on Linux. If the copy-on-write variant of a strategy is unsupported the executor will fall back to the non-CoW equivalent.
+          
+          The fastest (and the default) strategy available is `pooling-copy-on-write`.
+          
+          The `legacy-instance-reuse` strategy is deprecated and will be removed in the future. It should only be used in case of issues with the default instantiation strategy.
+          
+          [default: pooling-copy-on-write]
+
+          Possible values:
+          - pooling-copy-on-write:           Pool the instances to avoid initializing everything from scratch on each instantiation. Use copy-on-write memory when possible
+          - recreate-instance-copy-on-write: Recreate the instance from scratch on every instantiation. Use copy-on-write memory when possible
+          - pooling:                         Pool the instances to avoid initializing everything from scratch on each instantiation
+          - recreate-instance:               Recreate the instance from scratch on every instantiation. Very slow
+          - legacy-instance-reuse:           Legacy instance reuse mechanism. DEPRECATED. Will be removed in the future
+
+      --wasm-runtime-overrides <PATH>
+          Specify the path where local WASM runtimes are stored.
+          
+          These runtimes will override on-chain runtimes when the version matches.
+
+      --execution-syncing <STRATEGY>
+          The means of execution used when calling into the runtime for importing blocks as part of an initial sync
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-import-block <STRATEGY>
+          The means of execution used when calling into the runtime for general block import (including locally authored blocks)
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-block-construction <STRATEGY>
+          The means of execution used when calling into the runtime while constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-offchain-worker <STRATEGY>
+          The means of execution used when calling into the runtime while using an off-chain worker
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-other <STRATEGY>
+          The means of execution used when calling into the runtime while not syncing, importing or constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution <STRATEGY>
+          The execution strategy that should be used by all execution contexts
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --trie-cache-size <Bytes>
+          Specify the state cache size.
+          
+          Providing `0` will disable the cache.
+          
+          [default: 67108864]
+
+      --state-cache-size <STATE_CACHE_SIZE>
+          DEPRECATED
+          
+          Switch to `--trie-cache-size`.
+
+      --warmup <WARMUP>
+          Rounds of warmups before measuring
+          
+          [default: 10]
+
+      --repeat <REPEAT>
+          How many times the benchmark should be repeated
+          
+          [default: 100]
+
+      --max-ext-per-block <MAX_EXT_PER_BLOCK>
+          Maximal number of extrinsics that should be put into a block.
+          
+          Only useful for debugging.
+
+      --list
+          List all available pallets and extrinsics.
+          
+          The format is CSV with header `pallet, extrinsic`.
+
+      --pallet <PALLET>
+          Pallet name of the extrinsic to benchmark
+
+      --extrinsic <EXTRINSIC>
+          Extrinsic to benchmark
+
+      --enable-trie-cache
+          Enable the Trie cache.
+          
+          This should only be used for performance analysis and not for final results.
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.benchmark.machine.stdout.txt b/utils/e2e-tests/bash/fixtures/help.benchmark.machine.stdout.txt
new file mode 100644
index 000000000..82b07b34d
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.benchmark.machine.stdout.txt
@@ -0,0 +1,92 @@
+Command to benchmark the hardware.
+
+Runs multiple benchmarks and prints their output to console. Can be used to gauge if the hardware is fast enough to keep up with a chain's requirements. This command must be integrated by the client since the client can set compiler flags which influence the results.
+
+You can use the `--base-path` flag to set a location for the disk benchmarks.
+
+Usage: humanode-peer benchmark machine [OPTIONS]
+
+Options:
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --allow-fail
+          Do not return an error if any check fails.
+          
+          Should only be used for debugging.
+
+      --tolerance <PERCENT>
+          Set a fault tolerance for passing a requirement.
+          
+          10% means that the test would pass even when only 90% score was archived. Can be used to mitigate outliers of the benchmarks.
+          
+          [default: 10]
+
+      --verify-duration <SECONDS>
+          Time limit for the verification benchmark
+          
+          [default: 5]
+
+      --hash-duration <SECONDS>
+          Time limit for the hash function benchmark
+          
+          [default: 5]
+
+      --memory-duration <SECONDS>
+          Time limit for the memory benchmark
+          
+          [default: 5]
+
+      --disk-duration <SECONDS>
+          Time limit for each disk benchmark
+          
+          [default: 5]
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.benchmark.overhead.stdout.txt b/utils/e2e-tests/bash/fixtures/help.benchmark.overhead.stdout.txt
new file mode 100644
index 000000000..464bbe9c3
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.benchmark.overhead.stdout.txt
@@ -0,0 +1,276 @@
+Benchmark the execution overhead per-block and per-extrinsic
+
+Usage: humanode-peer benchmark overhead [OPTIONS]
+
+Options:
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+      --database <DB>
+          Select database backend to use
+
+          Possible values:
+          - rocksdb:               Facebooks RocksDB
+          - paritydb:              ParityDb. <https://github.com/paritytech/parity-db/>
+          - auto:                  Detect whether there is an existing database. Use it, if there is, if not, create new instance of ParityDb
+          - paritydb-experimental: ParityDb. <https://github.com/paritytech/parity-db/>
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+
+      --wasm-execution <METHOD>
+          Method for executing Wasm runtime code
+          
+          [default: compiled]
+
+          Possible values:
+          - interpreted-i-know-what-i-do: Uses an interpreter
+          - compiled:                     Uses a compiled runtime
+
+      --wasmtime-instantiation-strategy <STRATEGY>
+          The WASM instantiation method to use.
+          
+          Only has an effect when `wasm-execution` is set to `compiled`.
+          
+          The copy-on-write strategies are only supported on Linux. If the copy-on-write variant of a strategy is unsupported the executor will fall back to the non-CoW equivalent.
+          
+          The fastest (and the default) strategy available is `pooling-copy-on-write`.
+          
+          The `legacy-instance-reuse` strategy is deprecated and will be removed in the future. It should only be used in case of issues with the default instantiation strategy.
+          
+          [default: pooling-copy-on-write]
+
+          Possible values:
+          - pooling-copy-on-write:           Pool the instances to avoid initializing everything from scratch on each instantiation. Use copy-on-write memory when possible
+          - recreate-instance-copy-on-write: Recreate the instance from scratch on every instantiation. Use copy-on-write memory when possible
+          - pooling:                         Pool the instances to avoid initializing everything from scratch on each instantiation
+          - recreate-instance:               Recreate the instance from scratch on every instantiation. Very slow
+          - legacy-instance-reuse:           Legacy instance reuse mechanism. DEPRECATED. Will be removed in the future
+
+      --wasm-runtime-overrides <PATH>
+          Specify the path where local WASM runtimes are stored.
+          
+          These runtimes will override on-chain runtimes when the version matches.
+
+      --execution-syncing <STRATEGY>
+          The means of execution used when calling into the runtime for importing blocks as part of an initial sync
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-import-block <STRATEGY>
+          The means of execution used when calling into the runtime for general block import (including locally authored blocks)
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-block-construction <STRATEGY>
+          The means of execution used when calling into the runtime while constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-offchain-worker <STRATEGY>
+          The means of execution used when calling into the runtime while using an off-chain worker
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-other <STRATEGY>
+          The means of execution used when calling into the runtime while not syncing, importing or constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution <STRATEGY>
+          The execution strategy that should be used by all execution contexts
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --trie-cache-size <Bytes>
+          Specify the state cache size.
+          
+          Providing `0` will disable the cache.
+          
+          [default: 67108864]
+
+      --state-cache-size <STATE_CACHE_SIZE>
+          DEPRECATED
+          
+          Switch to `--trie-cache-size`.
+
+      --weight-path <WEIGHT_PATH>
+          File or directory to write the *weight* files to.
+          
+          For Substrate this should be `frame/support/src/weights`.
+
+      --metric <WEIGHT_METRIC>
+          Select a specific metric to calculate the final weight output
+          
+          [default: average]
+
+      --mul <WEIGHT_MUL>
+          Multiply the resulting weight with the given factor. Must be positive.
+          
+          Is applied before `weight_add`.
+          
+          [default: 1]
+
+      --add <WEIGHT_ADD>
+          Add the given offset to the resulting weight.
+          
+          Is applied after `weight_mul`.
+          
+          [default: 0]
+
+      --warmup <WARMUP>
+          Rounds of warmups before measuring
+          
+          [default: 10]
+
+      --repeat <REPEAT>
+          How many times the benchmark should be repeated
+          
+          [default: 100]
+
+      --max-ext-per-block <MAX_EXT_PER_BLOCK>
+          Maximal number of extrinsics that should be put into a block.
+          
+          Only useful for debugging.
+
+      --hostname-override <HOSTNAME_OVERRIDE>
+          Manually override the hostname to use
+
+      --hostname-fallback <HOSTNAME_FALLBACK>
+          Specify a fallback hostname if no-one could be detected automatically.
+          
+          Note: This only exists to make the `hostname` function infallible.
+          
+          [default: <UNKNOWN>]
+
+      --cpuname-fallback <CPUNAME_FALLBACK>
+          Specify a fallback CPU name if no-one could be detected automatically.
+          
+          Note: This only exists to make the `cpuname` function infallible.
+          
+          [default: <UNKNOWN>]
+
+      --header <PATH>
+          Add a header to the generated weight output file.
+          
+          Good for adding LICENSE headers.
+
+      --enable-trie-cache
+          Enable the Trie cache.
+          
+          This should only be used for performance analysis and not for final results.
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.benchmark.pallet.stdout.txt b/utils/e2e-tests/bash/fixtures/help.benchmark.pallet.stdout.txt
new file mode 100644
index 000000000..1ce080489
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.benchmark.pallet.stdout.txt
@@ -0,0 +1,214 @@
+Benchmark the extrinsic weight of FRAME Pallets
+
+Usage: humanode-peer benchmark pallet [OPTIONS]
+
+Options:
+  -p, --pallet <PALLET>
+          Select a FRAME Pallet to benchmark, or `*` for all (in which case `extrinsic` must be `*`)
+
+  -e, --extrinsic <EXTRINSIC>
+          Select an extrinsic inside the pallet to benchmark, or `*` for all
+
+  -s, --steps <STEPS>
+          Select how many samples we should take across the variable components
+          
+          [default: 2]
+
+      --low <LOWEST_RANGE_VALUES>
+          Indicates lowest values for each of the component ranges
+
+      --high <HIGHEST_RANGE_VALUES>
+          Indicates highest values for each of the component ranges
+
+  -r, --repeat <REPEAT>
+          Select how many repetitions of this benchmark should run from within the wasm
+          
+          [default: 1]
+
+      --external-repeat <EXTERNAL_REPEAT>
+          Select how many repetitions of this benchmark should run from the client.
+          
+          NOTE: Using this alone may give slower results, but will afford you maximum Wasm memory.
+          
+          [default: 1]
+
+      --json
+          Print the raw results in JSON format
+
+      --json-file <JSON_FILE>
+          Write the raw results in JSON format into the given file
+
+      --no-median-slopes
+          Don't print the median-slopes linear regression analysis
+
+      --no-min-squares
+          Don't print the min-squares linear regression analysis
+
+      --output <OUTPUT>
+          Output the benchmarks to a Rust file at the given path
+
+      --header <HEADER>
+          Add a header file to your outputted benchmarks
+
+      --template <TEMPLATE>
+          Path to Handlebars template file used for outputting benchmark results. (Optional)
+
+      --hostname-override <HOSTNAME_OVERRIDE>
+          Manually override the hostname to use
+
+      --hostname-fallback <HOSTNAME_FALLBACK>
+          Specify a fallback hostname if no-one could be detected automatically.
+          
+          Note: This only exists to make the `hostname` function infallible.
+          
+          [default: <UNKNOWN>]
+
+      --cpuname-fallback <CPUNAME_FALLBACK>
+          Specify a fallback CPU name if no-one could be detected automatically.
+          
+          Note: This only exists to make the `cpuname` function infallible.
+          
+          [default: <UNKNOWN>]
+
+      --output-analysis <OUTPUT_ANALYSIS>
+          Which analysis function to use when outputting benchmarks: * min-squares (default) * median-slopes * max (max of min squares and median slopes for each value)
+
+      --output-pov-analysis <OUTPUT_POV_ANALYSIS>
+          Which analysis function to use when analyzing measured proof sizes
+          
+          [default: median-slopes]
+
+      --default-pov-mode <DEFAULT_POV_MODE>
+          The PoV estimation mode of a benchmark if no `pov_mode` attribute is present
+          
+          [default: max-encoded-len]
+
+          Possible values:
+          - max-encoded-len: Use the maximal encoded length as provided by [`codec::MaxEncodedLen`]
+          - measured:        Measure the accessed value size in the pallet benchmarking and add some trie overhead
+          - ignored:         Do not estimate the PoV size for this storage item or benchmark
+
+      --heap-pages <HEAP_PAGES>
+          Set the heap pages while running benchmarks. If not set, the default value from the client is used
+
+      --no-verify
+          Disable verification logic when running benchmarks
+
+      --extra
+          Display and run extra benchmarks that would otherwise not be needed for weight construction
+
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --execution <STRATEGY>
+          The execution strategy that should be used for benchmarks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --wasm-execution <METHOD>
+          Method for executing Wasm runtime code
+          
+          [default: compiled]
+
+          Possible values:
+          - interpreted-i-know-what-i-do: Uses an interpreter
+          - compiled:                     Uses a compiled runtime
+
+      --wasm-instantiation-strategy <STRATEGY>
+          The WASM instantiation method to use.
+          
+          Only has an effect when `wasm-execution` is set to `compiled`.
+          
+          [default: pooling-copy-on-write]
+
+          Possible values:
+          - pooling-copy-on-write:           Pool the instances to avoid initializing everything from scratch on each instantiation. Use copy-on-write memory when possible
+          - recreate-instance-copy-on-write: Recreate the instance from scratch on every instantiation. Use copy-on-write memory when possible
+          - pooling:                         Pool the instances to avoid initializing everything from scratch on each instantiation
+          - recreate-instance:               Recreate the instance from scratch on every instantiation. Very slow
+          - legacy-instance-reuse:           Legacy instance reuse mechanism. DEPRECATED. Will be removed in the future
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+          
+          [default: 1024]
+
+      --list
+          List the benchmarks that match your query rather than running them.
+          
+          When nothing is provided, we list all benchmarks.
+
+      --no-storage-info
+          If enabled, the storage info is not displayed in the output next to the analysis.
+          
+          This is independent of the storage info appearing in the *output file*. Use a Handlebar template for that purpose.
+
+      --map-size <WORST_CASE_MAP_VALUES>
+          The assumed default maximum size of any `StorageMap`.
+          
+          When the maximum size of a map is not defined by the runtime developer, this value is used as a worst case scenario. It will affect the calculated worst case PoV size for accessing a value in a map, since the PoV will need to include the trie nodes down to the underlying value.
+          
+          [default: 1000000]
+
+      --additional-trie-layers <ADDITIONAL_TRIE_LAYERS>
+          Adjust the PoV estimation by adding additional trie layers to it.
+          
+          This should be set to `log16(n)` where `n` is the number of top-level storage items in the runtime, eg. `StorageMap`s and `StorageValue`s. A value of 2 to 3 is usually sufficient. Each layer will result in an additional 495 bytes PoV per distinct top-level access. Therefore multiple `StorageMap` accesses only suffer from this increase once. The exact number of storage items depends on the runtime and the deployed pallets.
+          
+          [default: 2]
+
+      --json-input <JSON_INPUT>
+          A path to a `.json` file with existing benchmark results generated with `--json` or `--json-file`. When specified the benchmarks are not actually executed, and the data for the analysis is read from this file
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.benchmark.stdout.txt b/utils/e2e-tests/bash/fixtures/help.benchmark.stdout.txt
new file mode 100644
index 000000000..829a3e4db
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.benchmark.stdout.txt
@@ -0,0 +1,16 @@
+Benchmark runtime pallets.
+
+Usage: humanode-peer benchmark <COMMAND>
+
+Commands:
+  pallet     Benchmark the extrinsic weight of FRAME Pallets
+  storage    Benchmark the storage speed of a chain snapshot
+  overhead   Benchmark the execution overhead per-block and per-extrinsic
+  block      Benchmark the execution time of historic blocks
+  machine    Command to benchmark the hardware
+  extrinsic  Benchmark the execution time of different extrinsics
+  help       Print this message or the help of the given subcommand(s)
+
+Options:
+  -h, --help     Print help
+  -V, --version  Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.benchmark.storage.stdout.txt b/utils/e2e-tests/bash/fixtures/help.benchmark.storage.stdout.txt
new file mode 100644
index 000000000..7ba0194ca
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.benchmark.storage.stdout.txt
@@ -0,0 +1,194 @@
+Benchmark the storage speed of a chain snapshot
+
+Usage: humanode-peer benchmark storage [OPTIONS] --state-version <STATE_VERSION>
+
+Options:
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --database <DB>
+          Select database backend to use
+
+          Possible values:
+          - rocksdb:               Facebooks RocksDB
+          - paritydb:              ParityDb. <https://github.com/paritytech/parity-db/>
+          - auto:                  Detect whether there is an existing database. Use it, if there is, if not, create new instance of ParityDb
+          - paritydb-experimental: ParityDb. <https://github.com/paritytech/parity-db/>
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+      --weight-path <WEIGHT_PATH>
+          File or directory to write the *weight* files to.
+          
+          For Substrate this should be `frame/support/src/weights`.
+
+      --metric <WEIGHT_METRIC>
+          Select a specific metric to calculate the final weight output
+          
+          [default: average]
+
+      --mul <WEIGHT_MUL>
+          Multiply the resulting weight with the given factor. Must be positive.
+          
+          Is applied before `weight_add`.
+          
+          [default: 1]
+
+      --add <WEIGHT_ADD>
+          Add the given offset to the resulting weight.
+          
+          Is applied after `weight_mul`.
+          
+          [default: 0]
+
+      --hostname-override <HOSTNAME_OVERRIDE>
+          Manually override the hostname to use
+
+      --hostname-fallback <HOSTNAME_FALLBACK>
+          Specify a fallback hostname if no-one could be detected automatically.
+          
+          Note: This only exists to make the `hostname` function infallible.
+          
+          [default: <UNKNOWN>]
+
+      --cpuname-fallback <CPUNAME_FALLBACK>
+          Specify a fallback CPU name if no-one could be detected automatically.
+          
+          Note: This only exists to make the `cpuname` function infallible.
+          
+          [default: <UNKNOWN>]
+
+      --skip-read
+          Skip the `read` benchmark
+
+      --skip-write
+          Skip the `write` benchmark
+
+      --template-path <TEMPLATE_PATH>
+          Specify the Handlebars template to use for outputting benchmark results
+
+      --header <PATH>
+          Add a header to the generated weight output file.
+          
+          Good for adding LICENSE headers.
+
+      --json-read-path <JSON_READ_PATH>
+          Path to write the raw 'read' results in JSON format to. Can be a file or directory
+
+      --json-write-path <JSON_WRITE_PATH>
+          Path to write the raw 'write' results in JSON format to. Can be a file or directory
+
+      --warmups <WARMUPS>
+          Rounds of warmups before measuring
+          
+          [default: 1]
+
+      --state-version <STATE_VERSION>
+          The `StateVersion` to use. Substrate `--dev` should use `V1` and Polkadot `V0`. Selecting the wrong version can corrupt the DB
+
+      --trie-cache-size <Bytes>
+          Trie cache size in bytes.
+          
+          Providing `0` will disable the cache.
+          
+          [default: 67108864]
+
+      --enable-trie-cache
+          Enable the Trie cache.
+          
+          This should only be used for performance analysis and not for final results.
+
+      --include-child-trees
+          Include child trees in benchmark
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.check-block.stdout.txt b/utils/e2e-tests/bash/fixtures/help.check-block.stdout.txt
new file mode 100644
index 000000000..c170dc4d1
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.check-block.stdout.txt
@@ -0,0 +1,219 @@
+Validate blocks
+
+Usage: humanode-peer check-block [OPTIONS] <HASH or NUMBER>
+
+Arguments:
+  <HASH or NUMBER>
+          Block hash or number
+
+Options:
+      --default-heap-pages <COUNT>
+          The default number of 64KB pages to ever allocate for Wasm execution.
+          
+          Don't alter this unless you know what you're doing.
+
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+      --database <DB>
+          Select database backend to use
+
+          Possible values:
+          - rocksdb:               Facebooks RocksDB
+          - paritydb:              ParityDb. <https://github.com/paritytech/parity-db/>
+          - auto:                  Detect whether there is an existing database. Use it, if there is, if not, create new instance of ParityDb
+          - paritydb-experimental: ParityDb. <https://github.com/paritytech/parity-db/>
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+
+      --wasm-execution <METHOD>
+          Method for executing Wasm runtime code
+          
+          [default: compiled]
+
+          Possible values:
+          - interpreted-i-know-what-i-do: Uses an interpreter
+          - compiled:                     Uses a compiled runtime
+
+      --wasmtime-instantiation-strategy <STRATEGY>
+          The WASM instantiation method to use.
+          
+          Only has an effect when `wasm-execution` is set to `compiled`.
+          
+          The copy-on-write strategies are only supported on Linux. If the copy-on-write variant of a strategy is unsupported the executor will fall back to the non-CoW equivalent.
+          
+          The fastest (and the default) strategy available is `pooling-copy-on-write`.
+          
+          The `legacy-instance-reuse` strategy is deprecated and will be removed in the future. It should only be used in case of issues with the default instantiation strategy.
+          
+          [default: pooling-copy-on-write]
+
+          Possible values:
+          - pooling-copy-on-write:           Pool the instances to avoid initializing everything from scratch on each instantiation. Use copy-on-write memory when possible
+          - recreate-instance-copy-on-write: Recreate the instance from scratch on every instantiation. Use copy-on-write memory when possible
+          - pooling:                         Pool the instances to avoid initializing everything from scratch on each instantiation
+          - recreate-instance:               Recreate the instance from scratch on every instantiation. Very slow
+          - legacy-instance-reuse:           Legacy instance reuse mechanism. DEPRECATED. Will be removed in the future
+
+      --wasm-runtime-overrides <PATH>
+          Specify the path where local WASM runtimes are stored.
+          
+          These runtimes will override on-chain runtimes when the version matches.
+
+      --execution-syncing <STRATEGY>
+          The means of execution used when calling into the runtime for importing blocks as part of an initial sync
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-import-block <STRATEGY>
+          The means of execution used when calling into the runtime for general block import (including locally authored blocks)
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-block-construction <STRATEGY>
+          The means of execution used when calling into the runtime while constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-offchain-worker <STRATEGY>
+          The means of execution used when calling into the runtime while using an off-chain worker
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-other <STRATEGY>
+          The means of execution used when calling into the runtime while not syncing, importing or constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution <STRATEGY>
+          The execution strategy that should be used by all execution contexts
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --trie-cache-size <Bytes>
+          Specify the state cache size.
+          
+          Providing `0` will disable the cache.
+          
+          [default: 67108864]
+
+      --state-cache-size <STATE_CACHE_SIZE>
+          DEPRECATED
+          
+          Switch to `--trie-cache-size`.
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.export-blocks.stdout.txt b/utils/e2e-tests/bash/fixtures/help.export-blocks.stdout.txt
new file mode 100644
index 000000000..fa68fbf08
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.export-blocks.stdout.txt
@@ -0,0 +1,127 @@
+Export blocks
+
+Usage: humanode-peer export-blocks [OPTIONS] [OUTPUT]
+
+Arguments:
+  [OUTPUT]
+          Output file name or stdout if unspecified
+
+Options:
+      --from <BLOCK>
+          Specify starting block number.
+          
+          Default is 1.
+
+      --to <BLOCK>
+          Specify last block number.
+          
+          Default is best block.
+
+      --binary
+          Use binary output rather than JSON
+
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+      --database <DB>
+          Select database backend to use
+
+          Possible values:
+          - rocksdb:               Facebooks RocksDB
+          - paritydb:              ParityDb. <https://github.com/paritytech/parity-db/>
+          - auto:                  Detect whether there is an existing database. Use it, if there is, if not, create new instance of ParityDb
+          - paritydb-experimental: ParityDb. <https://github.com/paritytech/parity-db/>
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.export-embedded-runtime.stdout.txt b/utils/e2e-tests/bash/fixtures/help.export-embedded-runtime.stdout.txt
new file mode 100644
index 000000000..962776d00
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.export-embedded-runtime.stdout.txt
@@ -0,0 +1,8 @@
+Export the runtime WASM code embedded in this binary
+
+Usage: humanode-peer export-embedded-runtime [OPTIONS]
+
+Options:
+  -o, --out <OUT>  Specify the output path
+  -h, --help       Print help
+  -V, --version    Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.export-state.stdout.txt b/utils/e2e-tests/bash/fixtures/help.export-state.stdout.txt
new file mode 100644
index 000000000..44406fde6
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.export-state.stdout.txt
@@ -0,0 +1,114 @@
+Export the state of a given block into a chain spec
+
+Usage: humanode-peer export-state [OPTIONS] [HASH or NUMBER]
+
+Arguments:
+  [HASH or NUMBER]
+          Block hash or number
+
+Options:
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+      --database <DB>
+          Select database backend to use
+
+          Possible values:
+          - rocksdb:               Facebooks RocksDB
+          - paritydb:              ParityDb. <https://github.com/paritytech/parity-db/>
+          - auto:                  Detect whether there is an existing database. Use it, if there is, if not, create new instance of ParityDb
+          - paritydb-experimental: ParityDb. <https://github.com/paritytech/parity-db/>
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.frontier-db.stdout.txt b/utils/e2e-tests/bash/fixtures/help.frontier-db.stdout.txt
new file mode 100644
index 000000000..31440d8d0
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.frontier-db.stdout.txt
@@ -0,0 +1,123 @@
+Db meta columns information
+
+Usage: humanode-peer frontier-db [OPTIONS] --key <KEY> <OPERATION> <COLUMN>
+
+Arguments:
+  <OPERATION>
+          Specify the operation to perform.
+          
+          Can be one of `create | read | update | delete`.
+          
+          [possible values: create, read, update, delete]
+
+  <COLUMN>
+          Specify the column to query.
+          
+          Can be one of `meta | block | transaction`.
+          
+          [possible values: meta, block, transaction]
+
+Options:
+  -k, --key <KEY>
+          Specify the key to either read or write
+
+      --value <VALUE>
+          Specify the value to write.
+          
+          - When `Some`, path to file. - When `None`, read from stdin.
+          
+          In any case, payload must be serializable to a known type.
+
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.import-blocks.stdout.txt b/utils/e2e-tests/bash/fixtures/help.import-blocks.stdout.txt
new file mode 100644
index 000000000..e575fc3d6
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.import-blocks.stdout.txt
@@ -0,0 +1,222 @@
+Import blocks
+
+Usage: humanode-peer import-blocks [OPTIONS] [INPUT]
+
+Arguments:
+  [INPUT]
+          Input file or stdin if unspecified
+
+Options:
+      --default-heap-pages <COUNT>
+          The default number of 64KB pages to ever allocate for Wasm execution.
+          
+          Don't alter this unless you know what you're doing.
+
+      --binary
+          Try importing blocks from binary format rather than JSON
+
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+      --database <DB>
+          Select database backend to use
+
+          Possible values:
+          - rocksdb:               Facebooks RocksDB
+          - paritydb:              ParityDb. <https://github.com/paritytech/parity-db/>
+          - auto:                  Detect whether there is an existing database. Use it, if there is, if not, create new instance of ParityDb
+          - paritydb-experimental: ParityDb. <https://github.com/paritytech/parity-db/>
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+
+      --wasm-execution <METHOD>
+          Method for executing Wasm runtime code
+          
+          [default: compiled]
+
+          Possible values:
+          - interpreted-i-know-what-i-do: Uses an interpreter
+          - compiled:                     Uses a compiled runtime
+
+      --wasmtime-instantiation-strategy <STRATEGY>
+          The WASM instantiation method to use.
+          
+          Only has an effect when `wasm-execution` is set to `compiled`.
+          
+          The copy-on-write strategies are only supported on Linux. If the copy-on-write variant of a strategy is unsupported the executor will fall back to the non-CoW equivalent.
+          
+          The fastest (and the default) strategy available is `pooling-copy-on-write`.
+          
+          The `legacy-instance-reuse` strategy is deprecated and will be removed in the future. It should only be used in case of issues with the default instantiation strategy.
+          
+          [default: pooling-copy-on-write]
+
+          Possible values:
+          - pooling-copy-on-write:           Pool the instances to avoid initializing everything from scratch on each instantiation. Use copy-on-write memory when possible
+          - recreate-instance-copy-on-write: Recreate the instance from scratch on every instantiation. Use copy-on-write memory when possible
+          - pooling:                         Pool the instances to avoid initializing everything from scratch on each instantiation
+          - recreate-instance:               Recreate the instance from scratch on every instantiation. Very slow
+          - legacy-instance-reuse:           Legacy instance reuse mechanism. DEPRECATED. Will be removed in the future
+
+      --wasm-runtime-overrides <PATH>
+          Specify the path where local WASM runtimes are stored.
+          
+          These runtimes will override on-chain runtimes when the version matches.
+
+      --execution-syncing <STRATEGY>
+          The means of execution used when calling into the runtime for importing blocks as part of an initial sync
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-import-block <STRATEGY>
+          The means of execution used when calling into the runtime for general block import (including locally authored blocks)
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-block-construction <STRATEGY>
+          The means of execution used when calling into the runtime while constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-offchain-worker <STRATEGY>
+          The means of execution used when calling into the runtime while using an off-chain worker
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution-other <STRATEGY>
+          The means of execution used when calling into the runtime while not syncing, importing or constructing blocks
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --execution <STRATEGY>
+          The execution strategy that should be used by all execution contexts
+
+          Possible values:
+          - native:           Execute with native build (if available, WebAssembly otherwise)
+          - wasm:             Only execute with the WebAssembly build
+          - both:             Execute with both native (where available) and WebAssembly builds
+          - native-else-wasm: Execute with the native build if possible; if it fails, then execute with WebAssembly
+
+      --trie-cache-size <Bytes>
+          Specify the state cache size.
+          
+          Providing `0` will disable the cache.
+          
+          [default: 67108864]
+
+      --state-cache-size <STATE_CACHE_SIZE>
+          DEPRECATED
+          
+          Switch to `--trie-cache-size`.
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.purge-chain.stdout.txt b/utils/e2e-tests/bash/fixtures/help.purge-chain.stdout.txt
new file mode 100644
index 000000000..f5ba424eb
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.purge-chain.stdout.txt
@@ -0,0 +1,71 @@
+Remove the whole chain
+
+Usage: humanode-peer purge-chain [OPTIONS]
+
+Options:
+  -y
+          Skip interactive prompt by answering yes automatically
+
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --database <DB>
+          Select database backend to use
+
+          Possible values:
+          - rocksdb:               Facebooks RocksDB
+          - paritydb:              ParityDb. <https://github.com/paritytech/parity-db/>
+          - auto:                  Detect whether there is an existing database. Use it, if there is, if not, create new instance of ParityDb
+          - paritydb-experimental: ParityDb. <https://github.com/paritytech/parity-db/>
+
+      --db-cache <MiB>
+          Limit the memory the database cache can use
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.revert.stdout.txt b/utils/e2e-tests/bash/fixtures/help.revert.stdout.txt
new file mode 100644
index 000000000..1cf2f173e
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.revert.stdout.txt
@@ -0,0 +1,104 @@
+Revert the chain to a previous state
+
+Usage: humanode-peer revert [OPTIONS] [NUM]
+
+Arguments:
+  [NUM]
+          Number of blocks to revert
+          
+          [default: 256]
+
+Options:
+      --chain <CHAIN_SPEC>
+          Specify the chain specification.
+          
+          It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file with the chainspec (such as one exported by the `build-spec` subcommand).
+
+      --dev
+          Specify the development chain.
+          
+          This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`, `--alice`, and `--tmp` flags, unless explicitly overridden.
+
+  -d, --base-path <PATH>
+          Specify custom base path
+
+  -l, --log <LOG_PATTERN>...
+          Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+          
+          Log levels (least to most verbose) are error, warn, info, debug, and trace. By default, all targets log `info`. The global log level can be set with `-l<level>`.
+
+      --detailed-log-output
+          Enable detailed log output.
+          
+          This includes displaying the log target, log level and thread name.
+          
+          This is automatically enabled when something is logged with any higher level than `info`.
+
+      --disable-log-color
+          Disable log color output
+
+      --enable-log-reloading
+          Enable feature to dynamically update and reload the log filter.
+          
+          Be aware that enabling this feature can lead to a performance decrease up to factor six or more. Depending on the global logging level the performance decrease changes.
+          
+          The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this option not being set.
+
+      --tracing-targets <TARGETS>
+          Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`
+
+      --tracing-receiver <RECEIVER>
+          Receiver to process tracing messages
+          
+          [default: log]
+
+          Possible values:
+          - log: Output the tracing records using the log
+
+      --state-pruning <PRUNING_MODE>
+          Specify the state pruning mode.
+          
+          This mode specifies when the block's state (ie, storage) should be pruned (ie, removed) from the database.
+          
+          This setting can only be set on the first creation of the database. Every subsequent run will load the pruning mode from the database and will error if the stored mode doesn't match this CLI value. It is fine to drop this CLI flag for subsequent runs.
+          
+          Possible values:
+          
+          - archive:
+          
+          Keep the state of all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only the state of finalized blocks.
+          
+          - number
+          
+          Keep the state of the last number of finalized blocks.
+          
+          [default: 256]
+
+      --blocks-pruning <PRUNING_MODE>
+          Specify the blocks pruning mode.
+          
+          This mode specifies when the block's body (including justifications) should be pruned (ie, removed) from the database.
+          
+          Possible values: - 'archive'
+          
+          Keep all blocks.
+          
+          - 'archive-canonical'
+          
+          Keep only finalized blocks.
+          
+          - number
+          
+          Keep the last `number` of finalized blocks.
+          
+          [default: archive-canonical]
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
diff --git a/utils/e2e-tests/bash/fixtures/help.try-runtime.stdout.txt b/utils/e2e-tests/bash/fixtures/help.try-runtime.stdout.txt
new file mode 100644
index 000000000..81bd6a35c
--- /dev/null
+++ b/utils/e2e-tests/bash/fixtures/help.try-runtime.stdout.txt
@@ -0,0 +1,7 @@
+Try some command against runtime state. Note: `try-runtime` feature must be enabled
+
+Usage: humanode-peer try-runtime
+
+Options:
+  -h, --help     Print help
+  -V, --version  Print version
diff --git a/utils/e2e-tests/bash/tests/base/help.sh b/utils/e2e-tests/bash/tests/base/help.sh
index e69dadab2..e393530ed 100755
--- a/utils/e2e-tests/bash/tests/base/help.sh
+++ b/utils/e2e-tests/bash/tests/base/help.sh
@@ -39,6 +39,23 @@ SUBCOMMANDS=(
   "key inspect"
   "key inspect-node-key"
   "key insert"
+  "build-spec"
+  "check-block"
+  "export-blocks"
+  "export-state"
+  "import-blocks"
+  "purge-chain"
+  "revert"
+  "benchmark"
+  "benchmark pallet"
+  "benchmark storage"
+  "benchmark overhead"
+  "benchmark block"
+  "benchmark machine"
+  "benchmark extrinsic"
+  "frontier-db"
+  "export-embedded-runtime"
+  "try-runtime"
 )
 
 for SUBCOMMAND in "${SUBCOMMANDS[@]}"; do