command.txt

Generic Substrate node implementation in Rust.

Usage: substrate-node [OPTIONS]
       substrate-node <COMMAND>

Commands:
  inspect        Decode given block or extrinsic using current native runtime.
  benchmark      Sub-commands concerned with benchmarking. The pallet benchmarking moved to the `pallet` sub-command
  key            Key management cli utilities
  verify         Verify a signature for a message, provided on STDIN, with a given (public or secret) key
  vanity         Generate a seed that provides a vanity address
  sign           Sign a message, with a given (secret) key
  build-spec     Build a chain specification
  check-block    Validate blocks
  export-blocks  Export blocks
  export-state   Export the state of a given block into a chain spec
  import-blocks  Import blocks
  purge-chain    Remove the whole chain
  revert         Revert the chain to a previous state
  chain-info     Db meta columns information
  help           Print this message or the help of the given subcommand(s)

Options:
      --validator
          Enable validator mode.
          
          The node will be started with the authority role and actively participate in any consensus task that it can (e.g. depending on availability of local keys).

      --no-grandpa
          Disable GRANDPA.
          
          Disables voter when running in validator mode, otherwise disable the GRANDPA observer.

      --rpc-external
          Listen to all RPC interfaces (default: local).
          
          Not all RPC methods are safe to be exposed publicly.
          
          Use an RPC proxy server to filter out dangerous methods. More details: <https://docs.substrate.io/build/remote-procedure-calls/#public-rpc-interfaces>.
          
          Use `--unsafe-rpc-external` to suppress the warning if you understand the risks.

      --unsafe-rpc-external
          Listen to all RPC interfaces.
          
          Same as `--rpc-external`.

      --rpc-methods <METHOD SET>
          RPC methods to expose.
          
          [default: auto]

          Possible values:
          - auto:   Expose every RPC method only when RPC is listening on `localhost`, otherwise serve only safe RPC methods
          - safe:   Allow only a safe subset of RPC methods
          - unsafe: Expose every RPC method (even potentially unsafe ones)

      --rpc-rate-limit <RPC_RATE_LIMIT>
          RPC rate limiting (calls/minute) for each connection.
          
          This is disabled by default.
          
          For example `--rpc-rate-limit 10` will maximum allow 10 calls per minute per connection.

      --rpc-rate-limit-whitelisted-ips <RPC_RATE_LIMIT_WHITELISTED_IPS>...
          Disable RPC rate limiting for certain ip addresses.
          
          Each IP address must be in CIDR notation such as `1.2.3.4/24`.

      --rpc-rate-limit-trust-proxy-headers
          Trust proxy headers for disable rate limiting.
          
          By default the rpc server will not trust headers such `X-Real-IP`, `X-Forwarded-For` and `Forwarded` and this option will make the rpc server to trust these headers.
          
          For instance this may be secure if the rpc server is behind a reverse proxy and that the proxy always sets these headers.

      --rpc-max-request-size <RPC_MAX_REQUEST_SIZE>
          Set the maximum RPC request payload size for both HTTP and WS in megabytes
          
          [default: 15]

      --rpc-max-response-size <RPC_MAX_RESPONSE_SIZE>
          Set the maximum RPC response payload size for both HTTP and WS in megabytes
          
          [default: 15]

      --rpc-max-subscriptions-per-connection <RPC_MAX_SUBSCRIPTIONS_PER_CONNECTION>
          Set the maximum concurrent subscriptions per connection
          
          [default: 1024]

      --rpc-port <PORT>
          Specify JSON-RPC server TCP port

      --rpc-max-connections <COUNT>
          Maximum number of RPC server connections
          
          [default: 100]

      --rpc-message-buffer-capacity-per-connection <RPC_MESSAGE_BUFFER_CAPACITY_PER_CONNECTION>
          The number of messages the RPC server is allowed to keep in memory.
          
          If the buffer becomes full then the server will not process new messages until the connected client start reading the underlying messages.
          
          This applies per connection which includes both JSON-RPC methods calls and subscriptions.
          
          [default: 64]

      --rpc-disable-batch-requests
          Disable RPC batch requests

      --rpc-max-batch-request-len <LEN>
          Limit the max length per RPC batch request

      --rpc-cors <ORIGINS>
          Specify browser *origins* allowed to access the HTTP & WS RPC servers.
          
          A comma-separated list of origins (protocol://domain or special `null` value). Value of `all` will disable origin validation. Default is to allow localhost and
          <https://polkadot.js.org> origins. When running in `--dev` mode the default is to allow all origins.

      --name <NAME>
          The human-readable name for this node.
          
          It's used as network node name.

      --no-telemetry
          Disable connecting to the Substrate telemetry server.
          
          Telemetry is on by default on global chains.

      --telemetry-url <URL VERBOSITY>
          The URL of the telemetry server to connect to.
          
          This flag can be passed multiple times as a means to specify multiple telemetry endpoints. Verbosity levels range from 0-9, with 0 denoting the least verbosity.
          
          Expected format is 'URL VERBOSITY', e.g. `--telemetry-url 'wss://foo/bar 0'`.

      --prometheus-port <PORT>
          Specify Prometheus exporter TCP Port

      --prometheus-external
          Expose Prometheus exporter on all interfaces.
          
          Default is local.

      --no-prometheus
          Do not expose a Prometheus exporter endpoint.
          
          Prometheus metric endpoint is enabled by default.

      --max-runtime-instances <MAX_RUNTIME_INSTANCES>
          The size of the instances cache for each runtime [max: 32].
          
          Values higher than 32 are illegal.
          
          [default: 8]

      --runtime-cache-size <RUNTIME_CACHE_SIZE>
          Maximum number of different runtimes that can be cached
          
          [default: 2]

      --offchain-worker <ENABLED>
          Execute offchain workers on every block
          
          [default: when-authority]

          Possible values:
          - always:         Always have offchain worker enabled
          - never:          Never enable the offchain worker
          - when-authority: Only enable the offchain worker when running as a validator (or collator, if this is a parachain node)

      --enable-offchain-indexing <ENABLE_OFFCHAIN_INDEXING>
          Enable offchain indexing API.
          
          Allows the runtime to write directly to offchain workers DB during block import.
          
          [default: false]
          [possible values: true, false]

      --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. It also disables local peer discovery
          (see --no-mdns and --discover-local)

  -d, --base-path <PATH>
          Specify custom base path

  -l, --log <LOG_PATTERN>...
          Sets a custom logging filter (syntax: `<target>=<level>`).
          
          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>`.
          
          Multiple `<target>=<level>` entries can be specified and separated by a comma.
          
          *Example*: `--log error,sync=debug,grandpa=warn`. Sets Global log level to `error`, sets `sync` target to debug and grandpa target to `warn`.

      --detailed-log-output
          Enable detailed log output.
          
          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 (`--log`).

      --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 which now is deprecated
          - 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

      --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>
          Runtime execution strategy for importing blocks during 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>
          Runtime execution strategy 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>
          Runtime execution strategy for 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>
          Runtime execution strategy for offchain workers

          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>
          Runtime execution strategy when 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`

      --bootnodes <ADDR>...
          Specify a list of bootnodes

      --reserved-nodes <ADDR>...
          Specify a list of reserved node addresses

      --reserved-only
          Whether to only synchronize the chain with reserved nodes.
          
          Also disables automatic peer discovery. TCP connections might still be established with non-reserved nodes. In particular, if you are a validator your node might still
          connect to other validator nodes and collator nodes regardless of whether they are defined as reserved nodes.

      --public-addr <PUBLIC_ADDR>...
          Public address that other nodes will use to connect to this node.
          
          This can be used if there's a proxy in front of this node.

      --listen-addr <LISTEN_ADDR>...
          Listen on this multiaddress.
          
          By default: If `--validator` is passed: `/ip4/0.0.0.0/tcp/<port>` and `/ip6/[::]/tcp/<port>`. Otherwise: `/ip4/0.0.0.0/tcp/<port>/ws` and `/ip6/[::]/tcp/<port>/ws`.

      --port <PORT>
          Specify p2p protocol TCP port

      --no-private-ip
          Always forbid connecting to private IPv4/IPv6 addresses.
          
          The option doesn't apply to addresses passed with `--reserved-nodes` or `--bootnodes`. Enabled by default for chains marked as "live" in their chain specifications.
          
          Address allocation for private networks is specified by [RFC1918](https://tools.ietf.org/html/rfc1918)).

      --allow-private-ip
          Always accept connecting to private IPv4/IPv6 addresses.
          
          Enabled by default for chains marked as "local" in their chain specifications, or when `--dev` is passed.
          
          Address allocation for private networks is specified by [RFC1918](https://tools.ietf.org/html/rfc1918)).

      --out-peers <COUNT>
          Number of outgoing connections we're trying to maintain
          
          [default: 8]

      --in-peers <COUNT>
          Maximum number of inbound full nodes peers
          
          [default: 32]

      --in-peers-light <COUNT>
          Maximum number of inbound light nodes peers
          
          [default: 100]

      --no-mdns
          Disable mDNS discovery (default: true).
          
          By default, the network will use mDNS to discover other nodes on the local network. This disables it. Automatically implied when using --dev.

      --max-parallel-downloads <COUNT>
          Maximum number of peers from which to ask for the same blocks in parallel.
          
          This allows downloading announced blocks from multiple peers. Decrease to save traffic and risk increased latency.
          
          [default: 5]

      --node-key <KEY>
          Secret key to use for p2p networking.
          
          The value is a string that is parsed according to the choice of `--node-key-type` as follows:
          
          - `ed25519`: the value is parsed as a hex-encoded Ed25519 32 byte secret key (64 hex chars)
          
          The value of this option takes precedence over `--node-key-file`.
          
          WARNING: Secrets provided as command-line arguments are easily exposed. Use of this option should be limited to development and testing. To use an externally managed
          secret key, use `--node-key-file` instead.

      --node-key-type <TYPE>
          Crypto primitive to use for p2p networking.
          
          The secret key of the node is obtained as follows:
          
          - If the `--node-key` option is given, the value is parsed as a secret key according to the type. See the documentation for `--node-key`.
          
          - If the `--node-key-file` option is given, the secret key is read from the specified file. See the documentation for `--node-key-file`.
          
          - Otherwise, the secret key is read from a file with a predetermined, type-specific name from the chain-specific network config directory inside the base directory
          specified by `--base-dir`. If this file does not exist, it is created with a newly generated secret key of the chosen type.
          
          The node's secret key determines the corresponding public key and hence the node's peer ID in the context of libp2p.
          
          [default: ed25519]

          Possible values:
          - ed25519: Use ed25519

      --node-key-file <FILE>
          File from which to read the node's secret key to use for p2p networking.
          
          The contents of the file are parsed according to the choice of `--node-key-type` as follows:
          
          - `ed25519`: the file must contain an unencoded 32 byte or hex encoded Ed25519 secret key.
          
          If the file does not exist, it is created with a newly generated secret key of the chosen type.

      --unsafe-force-node-key-generation
          Forces key generation if node-key-file file does not exist.
          
          This is an unsafe feature for production networks, because as an active authority other authorities may depend on your node having a stable identity and they might not
          being able to reach you if your identity changes after entering the active set.
          
          For minimal node downtime if no custom `node-key-file` argument is provided the network-key is usually persisted accross nodes restarts, in the `network` folder from
          directory provided in `--base-path`
          
          Warning!! If you ever run the node with this argument, make sure you remove it for the subsequent restarts.

      --discover-local
          Enable peer discovery on local networks.
          
          By default this option is `true` for `--dev` or when the chain type is `Local`/`Development` and false otherwise.

      --kademlia-disjoint-query-paths
          Require iterative Kademlia DHT queries to use disjoint paths.
          
          Disjoint paths increase resiliency in the presence of potentially adversarial nodes.
          
          See the S/Kademlia paper for more information on the high level design as well as its security improvements.

      --kademlia-replication-factor <KADEMLIA_REPLICATION_FACTOR>
          Kademlia replication factor.
          
          Determines to how many closest peers a record is replicated to.
          
          Discovery mechanism requires successful replication to all `kademlia_replication_factor` peers to consider record successfully put.
          
          [default: 20]

      --ipfs-server
          Join the IPFS network and serve transactions over bitswap protocol

      --sync <SYNC_MODE>
          Blockchain syncing mode.
          
          [default: full]

          Possible values:
          - full:        Full sync. Download and verify all blocks
          - fast:        Download blocks without executing them. Download latest state with proofs
          - fast-unsafe: Download blocks without executing them. Download latest state without proofs
          - warp:        Prove finality and download the latest state

      --max-blocks-per-request <COUNT>
          Maximum number of blocks per request.
          
          Try reducing this number from the default value if you have a slow network connection and observe block requests timing out.
          
          [default: 64]

      --network-backend <NETWORK_BACKEND>
          Network backend used for P2P networking.
          
          litep2p network backend is considered experimental and isn't as stable as the libp2p
          network backend.
          
          [default: libp2p]

          Possible values:
          - libp2p:  Use libp2p for P2P networking
          - litep2p: Use litep2p for P2P networking

      --pool-limit <COUNT>
          Maximum number of transactions in the transaction pool
          
          [default: 8192]

      --pool-kbytes <COUNT>
          Maximum number of kilobytes of all transactions stored in the pool
          
          [default: 20480]

      --tx-ban-seconds <SECONDS>
          How long a transaction is banned for.
          
          If it is considered invalid. Defaults to 1800s.

      --keystore-path <PATH>
          Specify custom keystore path

      --password-interactive
          Use interactive shell for entering the password used by the keystore

      --password <PASSWORD>
          Password used by the keystore.
          
          This allows appending an extra user-defined secret to the seed.

      --password-filename <PATH>
          File that contains the password used by the keystore

      --alice
          Shortcut for `--name Alice --validator`.
          
          Session keys for `Alice` are added to keystore.

      --bob
          Shortcut for `--name Bob --validator`.
          
          Session keys for `Bob` are added to keystore.

      --charlie
          Shortcut for `--name Charlie --validator`.
          
          Session keys for `Charlie` are added to keystore.

      --dave
          Shortcut for `--name Dave --validator`.
          
          Session keys for `Dave` are added to keystore.

      --eve
          Shortcut for `--name Eve --validator`.
          
          Session keys for `Eve` are added to keystore.

      --ferdie
          Shortcut for `--name Ferdie --validator`.
          
          Session keys for `Ferdie` are added to keystore.

      --one
          Shortcut for `--name One --validator`.
          
          Session keys for `One` are added to keystore.

      --two
          Shortcut for `--name Two --validator`.
          
          Session keys for `Two` are added to keystore.

      --force-authoring
          Enable authoring even when offline

      --tmp
          Run a temporary node.
          
          A temporary directory will be created to store the configuration and will be deleted at the end of the process.
          
          Note: the directory is random per process execution. This directory is used as base path which includes: database, node key and keystore.
          
          When `--dev` is given and no explicit `--base-path`, this option is implied.

      --mixnet
          Enable the mixnet service.
          
          This will make the mixnet RPC methods available. If the node is running as a validator, it will also attempt to register and operate as a mixnode.

      --mixnet-session-0-kx-secret <SECRET>
          The mixnet key-exchange secret to use in session 0.
          
          Should be 64 hex characters, giving a 32-byte secret.
          
          WARNING: Secrets provided as command-line arguments are easily exposed. Use of this option should be limited to development and testing.

      --no-hardware-benchmarks
          Disable automatic hardware benchmarks.
          
          By default these benchmarks are automatically ran at startup and measure the CPU speed, the memory bandwidth and the disk speed.
          
          The results are then printed out in the logs, and also sent as part of telemetry, if telemetry is enabled.

      --db-storage-threshold <MiB>
          Required available space on database storage.
          
          If available space for DB storage drops below the given threshold, node will be gracefully terminated.
          
          If `0` is given monitoring will be disabled.
          
          [default: 1024]

      --db-storage-polling-period <SECONDS>
          How often available space is polled
          
          [default: 5]

      --max-past-logs <MAX_PAST_LOGS>
          Maximum number of logs in a query
          
          [default: 10000]

      --fee-history-limit <FEE_HISTORY_LIMIT>
          Maximum fee history cache size
          
          [default: 2048]

      --enable-dev-signer
          

      --target-gas-price <TARGET_GAS_PRICE>
          静态价格 是出块者设置的 The dynamic-fee pallet target gas price set by block author
          
          [default: 1]

      --execute-gas-limit-multiplier <EXECUTE_GAS_LIMIT_MULTIPLIER>
          Maximum allowed gas limit will be `block.gas_limit * execute_gas_limit_multiplier` when using eth_call/eth_estimateGas
          
          [default: 10]

      --eth-log-block-cache <ETH_LOG_BLOCK_CACHE>
          Size in bytes of the LRU cache for block data
          
          [default: 50]

      --eth-statuses-cache <ETH_STATUSES_CACHE>
          Size in bytes of the LRU cache for transactions statuses data
          
          [default: 50]

      --frontier-backend-type <FRONTIER_BACKEND_TYPE>
          Sets the frontier backend type (KeyValue or Sql)
          
          [default: key-value]

          Possible values:
          - key-value: Either RocksDb or ParityDb as per inherited from the global backend settings
          - sql:       Sql database with custom log indexing

      --frontier-sql-backend-pool-size <FRONTIER_SQL_BACKEND_POOL_SIZE>
          [default: 100]

      --frontier-sql-backend-num-ops-timeout <FRONTIER_SQL_BACKEND_NUM_OPS_TIMEOUT>
          Sets the SQL backend's query timeout in number of VM ops
          
          [default: 10000000]

      --frontier-sql-backend-thread-count <FRONTIER_SQL_BACKEND_THREAD_COUNT>
          Sets the SQL backend's auxiliary thread limit
          
          [default: 4]

      --frontier-sql-backend-cache-size <FRONTIER_SQL_BACKEND_CACHE_SIZE>
          Sets the SQL backend's query timeout in number of VM ops. Default value is 200MB
          
          [default: 209715200]

  -h, --help
          Print help (see a summary with '-h')

  -V, --version
          Print version