mirror of
https://github.com/pezkuwichain/pez-solochain-template.git
synced 2026-04-21 22:37:56 +00:00
Update template triggered by workflow_dispatch
This commit is contained in:
Template Bot
Generated
+10230
File diff suppressed because it is too large
Load Diff
+57
@@ -0,0 +1,57 @@
|
||||
[workspace.package]
|
||||
license = "MIT-0"
|
||||
authors = ["Parity Technologies <admin@parity.io>"]
|
||||
homepage = "https://substrate.io"
|
||||
repository = "https://github.com/paritytech/polkadot-sdk-solochain-template.git"
|
||||
edition = "2021"
|
||||
|
||||
[workspace]
|
||||
members = [
|
||||
"node",
|
||||
"pallets/template",
|
||||
"runtime",
|
||||
]
|
||||
resolver = "2"
|
||||
|
||||
[workspace.lints.rust]
|
||||
suspicious_double_ref_op = { level = "allow", priority = 2 }
|
||||
|
||||
[workspace.lints.clippy]
|
||||
all = { level = "allow", priority = 0 }
|
||||
correctness = { level = "warn", priority = 1 }
|
||||
complexity = { level = "warn", priority = 1 }
|
||||
if-same-then-else = { level = "allow", priority = 2 }
|
||||
zero-prefixed-literal = { level = "allow", priority = 2 } # 00_1000_000
|
||||
type_complexity = { level = "allow", priority = 2 } # raison d'etre
|
||||
nonminimal-bool = { level = "allow", priority = 2 } # maybe
|
||||
borrowed-box = { level = "allow", priority = 2 } # Reasonable to fix this one
|
||||
too-many-arguments = { level = "allow", priority = 2 } # (Turning this on would lead to)
|
||||
needless-lifetimes = { level = "allow", priority = 2 } # generated code
|
||||
unnecessary_cast = { level = "allow", priority = 2 } # Types may change
|
||||
identity-op = { level = "allow", priority = 2 } # One case where we do 0 +
|
||||
useless_conversion = { level = "allow", priority = 2 } # Types may change
|
||||
unit_arg = { level = "allow", priority = 2 } # stylistic
|
||||
option-map-unit-fn = { level = "allow", priority = 2 } # stylistic
|
||||
bind_instead_of_map = { level = "allow", priority = 2 } # stylistic
|
||||
erasing_op = { level = "allow", priority = 2 } # E.g. 0 * DOLLARS
|
||||
eq_op = { level = "allow", priority = 2 } # In tests we test equality.
|
||||
while_immutable_condition = { level = "allow", priority = 2 } # false positives
|
||||
needless_option_as_deref = { level = "allow", priority = 2 } # false positives
|
||||
derivable_impls = { level = "allow", priority = 2 } # false positives
|
||||
stable_sort_primitive = { level = "allow", priority = 2 } # prefer stable sort
|
||||
extra-unused-type-parameters = { level = "allow", priority = 2 } # stylistic
|
||||
default_constructed_unit_structs = { level = "allow", priority = 2 } # stylistic
|
||||
|
||||
[workspace.dependencies]
|
||||
polkavm = "0.9.3"
|
||||
polkavm-linker = "0.9.2"
|
||||
polkavm-derive = "0.9.1"
|
||||
log = { version = "0.4.20", default-features = false }
|
||||
quote = { version = "1.0.33" }
|
||||
serde = { version = "1.0.197", default-features = false }
|
||||
serde-big-array = { version = "0.3.2" }
|
||||
serde_derive = { version = "1.0.117" }
|
||||
serde_json = { version = "1.0.114", default-features = false }
|
||||
serde_yaml = { version = "0.9" }
|
||||
syn = { version = "2.0.50" }
|
||||
thiserror = { version = "1.0.48" }
|
||||
@@ -0,0 +1,16 @@
|
||||
MIT No Attribution
|
||||
|
||||
Copyright Parity Technologies (UK) Ltd.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
||||
software and associated documentation files (the "Software"), to deal in the Software
|
||||
without restriction, including without limitation the rights to use, copy, modify,
|
||||
merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
@@ -0,0 +1,225 @@
|
||||
# Substrate Node Template
|
||||
|
||||
A fresh [Substrate](https://substrate.io/) node, ready for hacking :rocket:
|
||||
|
||||
A standalone version of this template is available for each release of Polkadot
|
||||
in the [Substrate Developer Hub Parachain
|
||||
Template](https://github.com/substrate-developer-hub/substrate-parachain-template/)
|
||||
repository. The parachain template is generated directly at each Polkadot
|
||||
release branch from the [Node Template in
|
||||
Substrate](https://github.com/paritytech/polkadot-sdk/tree/master/substrate/bin/node-template)
|
||||
upstream
|
||||
|
||||
It is usually best to use the stand-alone version to start a new project. All
|
||||
bugs, suggestions, and feature requests should be made upstream in the
|
||||
[Substrate](https://github.com/paritytech/polkadot-sdk/tree/master/substrate)
|
||||
repository.
|
||||
|
||||
## Getting Started
|
||||
|
||||
Depending on your operating system and Rust version, there might be additional
|
||||
packages required to compile this template. Check the
|
||||
[Install](https://docs.substrate.io/install/) instructions for your platform for
|
||||
the most common dependencies. Alternatively, you can use one of the [alternative
|
||||
installation](#alternatives-installations) options.
|
||||
|
||||
### Build
|
||||
|
||||
Use the following command to build the node without launching it:
|
||||
|
||||
```sh
|
||||
cargo build --release
|
||||
```
|
||||
|
||||
### Embedded Docs
|
||||
|
||||
After you build the project, you can use the following command to explore its
|
||||
parameters and subcommands:
|
||||
|
||||
```sh
|
||||
./target/release/node-template -h
|
||||
```
|
||||
|
||||
You can generate and view the [Rust
|
||||
Docs](https://doc.rust-lang.org/cargo/commands/cargo-doc.html) for this template
|
||||
with this command:
|
||||
|
||||
```sh
|
||||
cargo +nightly doc --open
|
||||
```
|
||||
|
||||
### Single-Node Development Chain
|
||||
|
||||
The following command starts a single-node development chain that doesn't
|
||||
persist state:
|
||||
|
||||
```sh
|
||||
./target/release/node-template --dev
|
||||
```
|
||||
|
||||
To purge the development chain's state, run the following command:
|
||||
|
||||
```sh
|
||||
./target/release/node-template purge-chain --dev
|
||||
```
|
||||
|
||||
To start the development chain with detailed logging, run the following command:
|
||||
|
||||
```sh
|
||||
RUST_BACKTRACE=1 ./target/release/node-template -ldebug --dev
|
||||
```
|
||||
|
||||
Development chains:
|
||||
|
||||
- Maintain state in a `tmp` folder while the node is running.
|
||||
- Use the **Alice** and **Bob** accounts as default validator authorities.
|
||||
- Use the **Alice** account as the default `sudo` account.
|
||||
- Are preconfigured with a genesis state (`/node/src/chain_spec.rs`) that
|
||||
includes several prefunded development accounts.
|
||||
|
||||
|
||||
To persist chain state between runs, specify a base path by running a command
|
||||
similar to the following:
|
||||
|
||||
```sh
|
||||
// Create a folder to use as the db base path
|
||||
$ mkdir my-chain-state
|
||||
|
||||
// Use of that folder to store the chain state
|
||||
$ ./target/release/node-template --dev --base-path ./my-chain-state/
|
||||
|
||||
// Check the folder structure created inside the base path after running the chain
|
||||
$ ls ./my-chain-state
|
||||
chains
|
||||
$ ls ./my-chain-state/chains/
|
||||
dev
|
||||
$ ls ./my-chain-state/chains/dev
|
||||
db keystore network
|
||||
```
|
||||
|
||||
### Connect with Polkadot-JS Apps Front-End
|
||||
|
||||
After you start the node template locally, you can interact with it using the
|
||||
hosted version of the [Polkadot/Substrate
|
||||
Portal](https://polkadot.js.org/apps/#/explorer?rpc=ws://localhost:9944)
|
||||
front-end by connecting to the local node endpoint. A hosted version is also
|
||||
available on [IPFS (redirect) here](https://dotapps.io/) or [IPNS (direct)
|
||||
here](ipns://dotapps.io/?rpc=ws%3A%2F%2F127.0.0.1%3A9944#/explorer). You can
|
||||
also find the source code and instructions for hosting your own instance on the
|
||||
[`polkadot-js/apps`](https://github.com/polkadot-js/apps) repository.
|
||||
|
||||
### Multi-Node Local Testnet
|
||||
|
||||
If you want to see the multi-node consensus algorithm in action, see [Simulate a
|
||||
network](https://docs.substrate.io/tutorials/build-a-blockchain/simulate-network/).
|
||||
|
||||
## Template Structure
|
||||
|
||||
A Substrate project such as this consists of a number of components that are
|
||||
spread across a few directories.
|
||||
|
||||
### Node
|
||||
|
||||
A blockchain node is an application that allows users to participate in a
|
||||
blockchain network. Substrate-based blockchain nodes expose a number of
|
||||
capabilities:
|
||||
|
||||
- Networking: Substrate nodes use the [`libp2p`](https://libp2p.io/) networking
|
||||
stack to allow the nodes in the network to communicate with one another.
|
||||
- Consensus: Blockchains must have a way to come to
|
||||
[consensus](https://docs.substrate.io/fundamentals/consensus/) on the state of
|
||||
the network. Substrate makes it possible to supply custom consensus engines
|
||||
and also ships with several consensus mechanisms that have been built on top
|
||||
of [Web3 Foundation
|
||||
research](https://research.web3.foundation/en/latest/polkadot/NPoS/index.html).
|
||||
- RPC Server: A remote procedure call (RPC) server is used to interact with
|
||||
Substrate nodes.
|
||||
|
||||
There are several files in the `node` directory. Take special note of the
|
||||
following:
|
||||
|
||||
- [`chain_spec.rs`](./node/src/chain_spec.rs): A [chain
|
||||
specification](https://docs.substrate.io/build/chain-spec/) is a source code
|
||||
file that defines a Substrate chain's initial (genesis) state. Chain
|
||||
specifications are useful for development and testing, and critical when
|
||||
architecting the launch of a production chain. Take note of the
|
||||
`development_config` and `testnet_genesis` functions,. These functions are
|
||||
used to define the genesis state for the local development chain
|
||||
configuration. These functions identify some [well-known
|
||||
accounts](https://docs.substrate.io/reference/command-line-tools/subkey/) and
|
||||
use them to configure the blockchain's initial state.
|
||||
- [`service.rs`](./node/src/service.rs): This file defines the node
|
||||
implementation. Take note of the libraries that this file imports and the
|
||||
names of the functions it invokes. In particular, there are references to
|
||||
consensus-related topics, such as the [block finalization and
|
||||
forks](https://docs.substrate.io/fundamentals/consensus/#finalization-and-forks)
|
||||
and other [consensus
|
||||
mechanisms](https://docs.substrate.io/fundamentals/consensus/#default-consensus-models)
|
||||
such as Aura for block authoring and GRANDPA for finality.
|
||||
|
||||
|
||||
### Runtime
|
||||
|
||||
In Substrate, the terms "runtime" and "state transition function" are analogous.
|
||||
Both terms refer to the core logic of the blockchain that is responsible for
|
||||
validating blocks and executing the state changes they define. The Substrate
|
||||
project in this repository uses
|
||||
[FRAME](https://docs.substrate.io/learn/runtime-development/#frame) to construct
|
||||
a blockchain runtime. FRAME allows runtime developers to declare domain-specific
|
||||
logic in modules called "pallets". At the heart of FRAME is a helpful [macro
|
||||
language](https://docs.substrate.io/reference/frame-macros/) that makes it easy
|
||||
to create pallets and flexibly compose them to create blockchains that can
|
||||
address [a variety of needs](https://substrate.io/ecosystem/projects/).
|
||||
|
||||
Review the [FRAME runtime implementation](./runtime/src/lib.rs) included in this
|
||||
template and note the following:
|
||||
|
||||
- This file configures several pallets to include in the runtime. Each pallet
|
||||
configuration is defined by a code block that begins with `impl
|
||||
$PALLET_NAME::Config for Runtime`.
|
||||
- The pallets are composed into a single runtime by way of the
|
||||
[`construct_runtime!`](https://paritytech.github.io/substrate/master/frame_support/macro.construct_runtime.html)
|
||||
macro, which is part of the [core FRAME pallet
|
||||
library](https://docs.substrate.io/reference/frame-pallets/#system-pallets).
|
||||
|
||||
### Pallets
|
||||
|
||||
The runtime in this project is constructed using many FRAME pallets that ship
|
||||
with [the Substrate
|
||||
repository](https://github.com/paritytech/polkadot-sdk/tree/master/substrate/frame) and a
|
||||
template pallet that is [defined in the
|
||||
`pallets`](./pallets/template/src/lib.rs) directory.
|
||||
|
||||
A FRAME pallet is comprised of a number of blockchain primitives, including:
|
||||
|
||||
- Storage: FRAME defines a rich set of powerful [storage
|
||||
abstractions](https://docs.substrate.io/build/runtime-storage/) that makes it
|
||||
easy to use Substrate's efficient key-value database to manage the evolving
|
||||
state of a blockchain.
|
||||
- Dispatchables: FRAME pallets define special types of functions that can be
|
||||
invoked (dispatched) from outside of the runtime in order to update its state.
|
||||
- Events: Substrate uses
|
||||
[events](https://docs.substrate.io/build/events-and-errors/) to notify users
|
||||
of significant state changes.
|
||||
- Errors: When a dispatchable fails, it returns an error.
|
||||
|
||||
Each pallet has its own `Config` trait which serves as a configuration interface
|
||||
to generically define the types and parameters it depends on.
|
||||
|
||||
## Alternatives Installations
|
||||
|
||||
Instead of installing dependencies and building this source directly, consider
|
||||
the following alternatives.
|
||||
|
||||
### Nix
|
||||
|
||||
Install [nix](https://nixos.org/) and
|
||||
[nix-direnv](https://github.com/nix-community/nix-direnv) for a fully
|
||||
plug-and-play experience for setting up the development environment. To get all
|
||||
the correct dependencies, activate direnv `direnv allow`.
|
||||
|
||||
### Docker
|
||||
|
||||
Please follow the [Substrate Docker instructions
|
||||
here](https://github.com/paritytech/polkadot-sdk/blob/master/substrate/docker/README.md) to
|
||||
build the Docker container with the Substrate Node Template binary.
|
||||
@@ -0,0 +1,218 @@
|
||||
# Installation
|
||||
|
||||
This guide is for reference only, please check the latest information on getting started with Substrate [here](https://docs.substrate.io/main-docs/install/).
|
||||
|
||||
This page will guide you through the **2 steps** needed to prepare a computer for **Substrate** development. Since
|
||||
Substrate is built with [the Rust programming language](https://www.rust-lang.org/), the first thing you will need to do
|
||||
is prepare the computer for Rust development - these steps will vary based on the computer's operating system. Once Rust
|
||||
is configured, you will use its toolchains to interact with Rust projects; the commands for Rust's toolchains will be
|
||||
the same for all supported, Unix-based operating systems.
|
||||
|
||||
## Build dependencies
|
||||
|
||||
Substrate development is easiest on Unix-based operating systems like macOS or Linux. The examples in the [Substrate
|
||||
Docs](https://docs.substrate.io) use Unix-style terminals to demonstrate how to interact with Substrate from the command
|
||||
line.
|
||||
|
||||
### Ubuntu/Debian
|
||||
|
||||
Use a terminal shell to execute the following commands:
|
||||
|
||||
```bash
|
||||
sudo apt update
|
||||
# May prompt for location information
|
||||
sudo apt install -y git clang curl libssl-dev llvm libudev-dev
|
||||
```
|
||||
|
||||
### Arch Linux
|
||||
|
||||
Run these commands from a terminal:
|
||||
|
||||
```bash
|
||||
pacman -Syu --needed --noconfirm curl git clang
|
||||
```
|
||||
|
||||
### Fedora
|
||||
|
||||
Run these commands from a terminal:
|
||||
|
||||
```bash
|
||||
sudo dnf update
|
||||
sudo dnf install clang curl git openssl-devel
|
||||
```
|
||||
|
||||
### OpenSUSE
|
||||
|
||||
Run these commands from a terminal:
|
||||
|
||||
```bash
|
||||
sudo zypper install clang curl git openssl-devel llvm-devel libudev-devel
|
||||
```
|
||||
|
||||
### macOS
|
||||
|
||||
> **Apple M1 ARM** If you have an Apple M1 ARM system on a chip, make sure that you have Apple Rosetta 2 installed
|
||||
> through `softwareupdate --install-rosetta`. This is only needed to run the `protoc` tool during the build. The build
|
||||
> itself and the target binaries would remain native.
|
||||
|
||||
Open the Terminal application and execute the following commands:
|
||||
|
||||
```bash
|
||||
# Install Homebrew if necessary https://brew.sh/
|
||||
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
|
||||
|
||||
# Make sure Homebrew is up-to-date, install openssl
|
||||
brew update
|
||||
brew install openssl
|
||||
```
|
||||
|
||||
### Windows
|
||||
|
||||
**_PLEASE NOTE:_** Native Windows development of Substrate is _not_ very well supported! It is _highly_
|
||||
recommended to use [Windows Subsystem Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10)
|
||||
(WSL) and follow the instructions for [Ubuntu/Debian](#ubuntudebian).
|
||||
Please refer to the separate
|
||||
[guide for native Windows development](https://docs.substrate.io/main-docs/install/windows/).
|
||||
|
||||
## Rust developer environment
|
||||
|
||||
This guide uses <https://rustup.rs> installer and the `rustup` tool to manage the Rust toolchain. First install and
|
||||
configure `rustup`:
|
||||
|
||||
```bash
|
||||
# Install
|
||||
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
|
||||
# Configure
|
||||
source ~/.cargo/env
|
||||
```
|
||||
|
||||
Configure the Rust toolchain to default to the latest stable version, add nightly and the nightly wasm target:
|
||||
|
||||
```bash
|
||||
rustup default stable
|
||||
rustup update
|
||||
rustup update nightly
|
||||
rustup target add wasm32-unknown-unknown --toolchain nightly
|
||||
```
|
||||
|
||||
## Test your set-up
|
||||
|
||||
Now the best way to ensure that you have successfully prepared a computer for Substrate development is to follow the
|
||||
steps in [our first Substrate tutorial](https://docs.substrate.io/tutorials/v3/create-your-first-substrate-chain/).
|
||||
|
||||
## Troubleshooting Substrate builds
|
||||
|
||||
Sometimes you can't get the Substrate node template to compile out of the box. Here are some tips to help you work
|
||||
through that.
|
||||
|
||||
### Rust configuration check
|
||||
|
||||
To see what Rust toolchain you are presently using, run:
|
||||
|
||||
```bash
|
||||
rustup show
|
||||
```
|
||||
|
||||
This will show something like this (Ubuntu example) output:
|
||||
|
||||
```text
|
||||
Default host: x86_64-unknown-linux-gnu
|
||||
rustup home: /home/user/.rustup
|
||||
|
||||
installed toolchains
|
||||
--------------------
|
||||
|
||||
stable-x86_64-unknown-linux-gnu (default)
|
||||
nightly-2020-10-06-x86_64-unknown-linux-gnu
|
||||
nightly-x86_64-unknown-linux-gnu
|
||||
|
||||
installed targets for active toolchain
|
||||
--------------------------------------
|
||||
|
||||
wasm32-unknown-unknown
|
||||
x86_64-unknown-linux-gnu
|
||||
|
||||
active toolchain
|
||||
----------------
|
||||
|
||||
stable-x86_64-unknown-linux-gnu (default)
|
||||
rustc 1.50.0 (cb75ad5db 2021-02-10)
|
||||
```
|
||||
|
||||
As you can see above, the default toolchain is stable, and the `nightly-x86_64-unknown-linux-gnu` toolchain as well as
|
||||
its `wasm32-unknown-unknown` target is installed. You also see that `nightly-2020-10-06-x86_64-unknown-linux-gnu` is
|
||||
installed, but is not used unless explicitly defined as illustrated in the [specify your nightly
|
||||
version](#specifying-nightly-version) section.
|
||||
|
||||
### WebAssembly compilation
|
||||
|
||||
Substrate uses [WebAssembly](https://webassembly.org) (Wasm) to produce portable blockchain runtimes. You will need to
|
||||
configure your Rust compiler to use [`nightly` builds](https://doc.rust-lang.org/book/appendix-07-nightly-rust.html) to
|
||||
allow you to compile Substrate runtime code to the Wasm target.
|
||||
|
||||
> There are upstream issues in Rust that need to be resolved before all of Substrate can use the stable Rust toolchain.
|
||||
> [This is our tracking issue](https://github.com/paritytech/substrate/issues/1252) if you're curious as to why and how
|
||||
> this will be resolved.
|
||||
|
||||
#### Latest nightly for Substrate `master`
|
||||
|
||||
Developers who are building Substrate _itself_ should always use the latest bug-free versions of Rust stable and
|
||||
nightly. This is because the Substrate codebase follows the tip of Rust nightly, which means that changes in Substrate
|
||||
often depend on upstream changes in the Rust nightly compiler. To ensure your Rust compiler is always up to date, you
|
||||
should run:
|
||||
|
||||
```bash
|
||||
rustup update
|
||||
rustup update nightly
|
||||
rustup target add wasm32-unknown-unknown --toolchain nightly
|
||||
```
|
||||
|
||||
> NOTE: It may be necessary to occasionally rerun `rustup update` if a change in the upstream Substrate codebase depends
|
||||
> on a new feature of the Rust compiler. When you do this, both your nightly and stable toolchains will be pulled to the
|
||||
> most recent release, and for nightly, it is generally _not_ expected to compile WASM without error (although it very
|
||||
> often does). Be sure to [specify your nightly version](#specifying-nightly-version) if you get WASM build errors from
|
||||
> `rustup` and [downgrade nightly as needed](#downgrading-rust-nightly).
|
||||
|
||||
#### Rust nightly toolchain
|
||||
|
||||
If you want to guarantee that your build works on your computer as you update Rust and other dependencies, you should
|
||||
use a specific Rust nightly version that is known to be compatible with the version of Substrate they are using; this
|
||||
version will vary from project to project and different projects may use different mechanisms to communicate this
|
||||
version to developers. For instance, the Polkadot client specifies this information in its [release
|
||||
notes](https://github.com/paritytech/polkadot-sdk/releases).
|
||||
|
||||
```bash
|
||||
# Specify the specific nightly toolchain in the date below:
|
||||
rustup install nightly-<yyyy-MM-dd>
|
||||
```
|
||||
|
||||
#### Wasm toolchain
|
||||
|
||||
Now, configure the nightly version to work with the Wasm compilation target:
|
||||
|
||||
```bash
|
||||
rustup target add wasm32-unknown-unknown --toolchain nightly-<yyyy-MM-dd>
|
||||
```
|
||||
|
||||
### Specifying nightly version
|
||||
|
||||
Use the `WASM_BUILD_TOOLCHAIN` environment variable to specify the Rust nightly version a Substrate project should use
|
||||
for Wasm compilation:
|
||||
|
||||
```bash
|
||||
WASM_BUILD_TOOLCHAIN=nightly-<yyyy-MM-dd> cargo build --release
|
||||
```
|
||||
|
||||
> Note that this only builds _the runtime_ with the specified nightly. The rest of project will be compiled with **your
|
||||
> default toolchain**, i.e. the latest installed stable toolchain.
|
||||
|
||||
### Downgrading Rust nightly
|
||||
|
||||
If your computer is configured to use the latest Rust nightly and you would like to downgrade to a specific nightly
|
||||
version, follow these steps:
|
||||
|
||||
```bash
|
||||
rustup uninstall nightly
|
||||
rustup install nightly-<yyyy-MM-dd>
|
||||
rustup target add wasm32-unknown-unknown --toolchain nightly-<yyyy-MM-dd>
|
||||
```
|
||||
@@ -0,0 +1,9 @@
|
||||
# Env setup
|
||||
|
||||
Special files for setting up an environment to work with the template:
|
||||
|
||||
- `rust-toolchain.toml` when working with `rustup`.
|
||||
- `flake.nix` when working with `nix`.
|
||||
|
||||
These files will be copied by the installer script to the main directory. They are
|
||||
put into this special directory to not interfere with the normal CI.
|
||||
Generated
+43
@@ -0,0 +1,43 @@
|
||||
{
|
||||
"nodes": {
|
||||
"flake-utils": {
|
||||
"locked": {
|
||||
"lastModified": 1678901627,
|
||||
"narHash": "sha256-U02riOqrKKzwjsxc/400XnElV+UtPUQWpANPlyazjH0=",
|
||||
"owner": "numtide",
|
||||
"repo": "flake-utils",
|
||||
"rev": "93a2b84fc4b70d9e089d029deacc3583435c2ed6",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "numtide",
|
||||
"repo": "flake-utils",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs": {
|
||||
"locked": {
|
||||
"lastModified": 1679262748,
|
||||
"narHash": "sha256-DQCrrAFrkxijC6haUzOC5ZoFqpcv/tg2WxnyW3np1Cc=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "60c1d71f2ba4c80178ec84523c2ca0801522e0a6",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "NixOS",
|
||||
"ref": "nixos-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"root": {
|
||||
"inputs": {
|
||||
"flake-utils": "flake-utils",
|
||||
"nixpkgs": "nixpkgs"
|
||||
}
|
||||
}
|
||||
},
|
||||
"root": "root",
|
||||
"version": 7
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
{
|
||||
inputs = {
|
||||
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
|
||||
flake-utils.url = "github:numtide/flake-utils";
|
||||
};
|
||||
|
||||
outputs = { self, nixpkgs, flake-utils, ... }: flake-utils.lib.eachDefaultSystem (system:
|
||||
let
|
||||
pkgs = import nixpkgs { inherit system; };
|
||||
in
|
||||
{
|
||||
devShells.default = pkgs.mkShell {
|
||||
packages = with pkgs; [
|
||||
rustup
|
||||
clang
|
||||
protobuf
|
||||
];
|
||||
|
||||
LIBCLANG_PATH = "${pkgs.libclang.lib}/lib";
|
||||
};
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
[toolchain]
|
||||
channel = "stable"
|
||||
components = [
|
||||
"cargo",
|
||||
"clippy",
|
||||
"rust-analyzer",
|
||||
"rust-src",
|
||||
"rust-std",
|
||||
"rustc",
|
||||
"rustc-dev",
|
||||
"rustfmt",
|
||||
]
|
||||
targets = ["wasm32-unknown-unknown"]
|
||||
profile = "minimal"
|
||||
@@ -0,0 +1,81 @@
|
||||
[package]
|
||||
name = "solochain-template-node"
|
||||
description = "A solochain node template built with Substrate, part of Polkadot Sdk. (polkadot v1.9.0)"
|
||||
version = "0.1.0"
|
||||
license = "MIT-0"
|
||||
authors.workspace = true
|
||||
homepage.workspace = true
|
||||
repository.workspace = true
|
||||
edition.workspace = true
|
||||
publish = false
|
||||
|
||||
build = "build.rs"
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
targets = ["x86_64-unknown-linux-gnu"]
|
||||
|
||||
[dependencies]
|
||||
clap = { version = "4.5.1", features = ["derive"] }
|
||||
futures = { version = "0.3.21", features = ["thread-pool"] }
|
||||
serde_json = { workspace = true, default-features = true }
|
||||
jsonrpsee = { version = "0.22", features = ["server"] }
|
||||
sc-cli = { version = "0.39.0" }
|
||||
sp-core = { version = "31.0.0" }
|
||||
sc-executor = { version = "0.35.0" }
|
||||
sc-network = { version = "0.37.0" }
|
||||
sc-service = { version = "0.38.0" }
|
||||
sc-telemetry = { version = "17.0.0" }
|
||||
sc-transaction-pool = { version = "31.0.0" }
|
||||
sc-transaction-pool-api = { version = "31.0.0" }
|
||||
sc-offchain = { version = "32.0.0" }
|
||||
sc-consensus-aura = { version = "0.37.0" }
|
||||
sp-consensus-aura = { version = "0.35.0" }
|
||||
sc-consensus = { version = "0.36.0" }
|
||||
sc-consensus-grandpa = { version = "0.22.0" }
|
||||
sp-consensus-grandpa = { version = "16.0.0" }
|
||||
sc-client-api = { version = "31.0.0" }
|
||||
sc-rpc-api = { version = "0.36.0" }
|
||||
sc-basic-authorship = { version = "0.37.0" }
|
||||
sp-runtime = { version = "34.0.0" }
|
||||
sp-io = { version = "33.0.0" }
|
||||
sp-timestamp = { version = "29.0.0" }
|
||||
sp-inherents = { version = "29.0.0" }
|
||||
sp-keyring = { version = "34.0.0" }
|
||||
sp-api = { version = "29.0.0" }
|
||||
sp-blockchain = { version = "31.0.0" }
|
||||
sp-block-builder = { version = "29.0.0" }
|
||||
frame-system = { version = "31.0.0" }
|
||||
pallet-transaction-payment = { version = "31.0.0", default-features = false }
|
||||
pallet-transaction-payment-rpc = { version = "33.0.0" }
|
||||
substrate-frame-rpc-system = { version = "31.0.0" }
|
||||
frame-benchmarking-cli = { version = "35.0.1" }
|
||||
solochain-template-runtime = { version = "0.1.0", path = "../runtime" }
|
||||
|
||||
# CLI-specific dependencies
|
||||
try-runtime-cli = { version = "0.41.0", optional = true }
|
||||
|
||||
[build-dependencies]
|
||||
substrate-build-script-utils = { version = "11.0.0" }
|
||||
|
||||
[features]
|
||||
default = []
|
||||
# Dependencies that are only required if runtime benchmarking should be build.
|
||||
runtime-benchmarks = [
|
||||
"frame-benchmarking-cli/runtime-benchmarks",
|
||||
"frame-system/runtime-benchmarks",
|
||||
"sc-service/runtime-benchmarks",
|
||||
"solochain-template-runtime/runtime-benchmarks",
|
||||
"sp-runtime/runtime-benchmarks",
|
||||
]
|
||||
# Enable features that allow the runtime to be tried and debugged. Name might be subject to change
|
||||
# in the near future.
|
||||
try-runtime = [
|
||||
"frame-system/try-runtime",
|
||||
"pallet-transaction-payment/try-runtime",
|
||||
"solochain-template-runtime/try-runtime",
|
||||
"sp-runtime/try-runtime",
|
||||
"try-runtime-cli/try-runtime",
|
||||
]
|
||||
@@ -0,0 +1,7 @@
|
||||
use substrate_build_script_utils::{generate_cargo_keys, rerun_if_git_head_changed};
|
||||
|
||||
fn main() {
|
||||
generate_cargo_keys();
|
||||
|
||||
rerun_if_git_head_changed();
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
//! Setup code for [`super::command`] which would otherwise bloat that module.
|
||||
//!
|
||||
//! Should only be used for benchmarking as it may break in other contexts.
|
||||
|
||||
use crate::service::FullClient;
|
||||
|
||||
use runtime::{AccountId, Balance, BalancesCall, SystemCall};
|
||||
use sc_cli::Result;
|
||||
use sc_client_api::BlockBackend;
|
||||
use solochain_template_runtime as runtime;
|
||||
use sp_core::{Encode, Pair};
|
||||
use sp_inherents::{InherentData, InherentDataProvider};
|
||||
use sp_keyring::Sr25519Keyring;
|
||||
use sp_runtime::{OpaqueExtrinsic, SaturatedConversion};
|
||||
|
||||
use std::{sync::Arc, time::Duration};
|
||||
|
||||
/// Generates extrinsics for the `benchmark overhead` command.
|
||||
///
|
||||
/// Note: Should only be used for benchmarking.
|
||||
pub struct RemarkBuilder {
|
||||
client: Arc<FullClient>,
|
||||
}
|
||||
|
||||
impl RemarkBuilder {
|
||||
/// Creates a new [`Self`] from the given client.
|
||||
pub fn new(client: Arc<FullClient>) -> Self {
|
||||
Self { client }
|
||||
}
|
||||
}
|
||||
|
||||
impl frame_benchmarking_cli::ExtrinsicBuilder for RemarkBuilder {
|
||||
fn pallet(&self) -> &str {
|
||||
"system"
|
||||
}
|
||||
|
||||
fn extrinsic(&self) -> &str {
|
||||
"remark"
|
||||
}
|
||||
|
||||
fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
|
||||
let acc = Sr25519Keyring::Bob.pair();
|
||||
let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
|
||||
self.client.as_ref(),
|
||||
acc,
|
||||
SystemCall::remark { remark: vec![] }.into(),
|
||||
nonce,
|
||||
)
|
||||
.into();
|
||||
|
||||
Ok(extrinsic)
|
||||
}
|
||||
}
|
||||
|
||||
/// Generates `Balances::TransferKeepAlive` extrinsics for the benchmarks.
|
||||
///
|
||||
/// Note: Should only be used for benchmarking.
|
||||
pub struct TransferKeepAliveBuilder {
|
||||
client: Arc<FullClient>,
|
||||
dest: AccountId,
|
||||
value: Balance,
|
||||
}
|
||||
|
||||
impl TransferKeepAliveBuilder {
|
||||
/// Creates a new [`Self`] from the given client.
|
||||
pub fn new(client: Arc<FullClient>, dest: AccountId, value: Balance) -> Self {
|
||||
Self { client, dest, value }
|
||||
}
|
||||
}
|
||||
|
||||
impl frame_benchmarking_cli::ExtrinsicBuilder for TransferKeepAliveBuilder {
|
||||
fn pallet(&self) -> &str {
|
||||
"balances"
|
||||
}
|
||||
|
||||
fn extrinsic(&self) -> &str {
|
||||
"transfer_keep_alive"
|
||||
}
|
||||
|
||||
fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
|
||||
let acc = Sr25519Keyring::Bob.pair();
|
||||
let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
|
||||
self.client.as_ref(),
|
||||
acc,
|
||||
BalancesCall::transfer_keep_alive { dest: self.dest.clone().into(), value: self.value }
|
||||
.into(),
|
||||
nonce,
|
||||
)
|
||||
.into();
|
||||
|
||||
Ok(extrinsic)
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a transaction using the given `call`.
|
||||
///
|
||||
/// Note: Should only be used for benchmarking.
|
||||
pub fn create_benchmark_extrinsic(
|
||||
client: &FullClient,
|
||||
sender: sp_core::sr25519::Pair,
|
||||
call: runtime::RuntimeCall,
|
||||
nonce: u32,
|
||||
) -> runtime::UncheckedExtrinsic {
|
||||
let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed");
|
||||
let best_hash = client.chain_info().best_hash;
|
||||
let best_block = client.chain_info().best_number;
|
||||
|
||||
let period = runtime::BlockHashCount::get()
|
||||
.checked_next_power_of_two()
|
||||
.map(|c| c / 2)
|
||||
.unwrap_or(2) as u64;
|
||||
let extra: runtime::SignedExtra = (
|
||||
frame_system::CheckNonZeroSender::<runtime::Runtime>::new(),
|
||||
frame_system::CheckSpecVersion::<runtime::Runtime>::new(),
|
||||
frame_system::CheckTxVersion::<runtime::Runtime>::new(),
|
||||
frame_system::CheckGenesis::<runtime::Runtime>::new(),
|
||||
frame_system::CheckEra::<runtime::Runtime>::from(sp_runtime::generic::Era::mortal(
|
||||
period,
|
||||
best_block.saturated_into(),
|
||||
)),
|
||||
frame_system::CheckNonce::<runtime::Runtime>::from(nonce),
|
||||
frame_system::CheckWeight::<runtime::Runtime>::new(),
|
||||
pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
|
||||
);
|
||||
|
||||
let raw_payload = runtime::SignedPayload::from_raw(
|
||||
call.clone(),
|
||||
extra.clone(),
|
||||
(
|
||||
(),
|
||||
runtime::VERSION.spec_version,
|
||||
runtime::VERSION.transaction_version,
|
||||
genesis_hash,
|
||||
best_hash,
|
||||
(),
|
||||
(),
|
||||
(),
|
||||
),
|
||||
);
|
||||
let signature = raw_payload.using_encoded(|e| sender.sign(e));
|
||||
|
||||
runtime::UncheckedExtrinsic::new_signed(
|
||||
call,
|
||||
sp_runtime::AccountId32::from(sender.public()).into(),
|
||||
runtime::Signature::Sr25519(signature),
|
||||
extra,
|
||||
)
|
||||
}
|
||||
|
||||
/// Generates inherent data for the `benchmark overhead` command.
|
||||
///
|
||||
/// Note: Should only be used for benchmarking.
|
||||
pub fn inherent_benchmark_data() -> Result<InherentData> {
|
||||
let mut inherent_data = InherentData::new();
|
||||
let d = Duration::from_millis(0);
|
||||
let timestamp = sp_timestamp::InherentDataProvider::new(d.into());
|
||||
|
||||
futures::executor::block_on(timestamp.provide_inherent_data(&mut inherent_data))
|
||||
.map_err(|e| format!("creating inherent data: {:?}", e))?;
|
||||
Ok(inherent_data)
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
use sc_service::ChainType;
|
||||
use solochain_template_runtime::{AccountId, RuntimeGenesisConfig, Signature, WASM_BINARY};
|
||||
use sp_consensus_aura::sr25519::AuthorityId as AuraId;
|
||||
use sp_consensus_grandpa::AuthorityId as GrandpaId;
|
||||
use sp_core::{sr25519, Pair, Public};
|
||||
use sp_runtime::traits::{IdentifyAccount, Verify};
|
||||
|
||||
// The URL for the telemetry server.
|
||||
// const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/";
|
||||
|
||||
/// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type.
|
||||
pub type ChainSpec = sc_service::GenericChainSpec<RuntimeGenesisConfig>;
|
||||
|
||||
/// Generate a crypto pair from seed.
|
||||
pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
|
||||
TPublic::Pair::from_string(&format!("//{}", seed), None)
|
||||
.expect("static values are valid; qed")
|
||||
.public()
|
||||
}
|
||||
|
||||
type AccountPublic = <Signature as Verify>::Signer;
|
||||
|
||||
/// Generate an account ID from seed.
|
||||
pub fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> AccountId
|
||||
where
|
||||
AccountPublic: From<<TPublic::Pair as Pair>::Public>,
|
||||
{
|
||||
AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
|
||||
}
|
||||
|
||||
/// Generate an Aura authority key.
|
||||
pub fn authority_keys_from_seed(s: &str) -> (AuraId, GrandpaId) {
|
||||
(get_from_seed::<AuraId>(s), get_from_seed::<GrandpaId>(s))
|
||||
}
|
||||
|
||||
pub fn development_config() -> Result<ChainSpec, String> {
|
||||
Ok(ChainSpec::builder(
|
||||
WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?,
|
||||
None,
|
||||
)
|
||||
.with_name("Development")
|
||||
.with_id("dev")
|
||||
.with_chain_type(ChainType::Development)
|
||||
.with_genesis_config_patch(testnet_genesis(
|
||||
// Initial PoA authorities
|
||||
vec![authority_keys_from_seed("Alice")],
|
||||
// Sudo account
|
||||
get_account_id_from_seed::<sr25519::Public>("Alice"),
|
||||
// Pre-funded accounts
|
||||
vec![
|
||||
get_account_id_from_seed::<sr25519::Public>("Alice"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Bob"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
|
||||
],
|
||||
true,
|
||||
))
|
||||
.build())
|
||||
}
|
||||
|
||||
pub fn local_testnet_config() -> Result<ChainSpec, String> {
|
||||
Ok(ChainSpec::builder(
|
||||
WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?,
|
||||
None,
|
||||
)
|
||||
.with_name("Local Testnet")
|
||||
.with_id("local_testnet")
|
||||
.with_chain_type(ChainType::Local)
|
||||
.with_genesis_config_patch(testnet_genesis(
|
||||
// Initial PoA authorities
|
||||
vec![authority_keys_from_seed("Alice"), authority_keys_from_seed("Bob")],
|
||||
// Sudo account
|
||||
get_account_id_from_seed::<sr25519::Public>("Alice"),
|
||||
// Pre-funded accounts
|
||||
vec![
|
||||
get_account_id_from_seed::<sr25519::Public>("Alice"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Bob"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Charlie"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Dave"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Eve"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Ferdie"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Charlie//stash"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Dave//stash"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Eve//stash"),
|
||||
get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
|
||||
],
|
||||
true,
|
||||
))
|
||||
.build())
|
||||
}
|
||||
|
||||
/// Configure initial storage state for FRAME modules.
|
||||
fn testnet_genesis(
|
||||
initial_authorities: Vec<(AuraId, GrandpaId)>,
|
||||
root_key: AccountId,
|
||||
endowed_accounts: Vec<AccountId>,
|
||||
_enable_println: bool,
|
||||
) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"balances": {
|
||||
// Configure endowed accounts with initial balance of 1 << 60.
|
||||
"balances": endowed_accounts.iter().cloned().map(|k| (k, 1u64 << 60)).collect::<Vec<_>>(),
|
||||
},
|
||||
"aura": {
|
||||
"authorities": initial_authorities.iter().map(|x| (x.0.clone())).collect::<Vec<_>>(),
|
||||
},
|
||||
"grandpa": {
|
||||
"authorities": initial_authorities.iter().map(|x| (x.1.clone(), 1)).collect::<Vec<_>>(),
|
||||
},
|
||||
"sudo": {
|
||||
// Assign network admin rights.
|
||||
"key": Some(root_key),
|
||||
},
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
use sc_cli::RunCmd;
|
||||
|
||||
#[derive(Debug, clap::Parser)]
|
||||
pub struct Cli {
|
||||
#[command(subcommand)]
|
||||
pub subcommand: Option<Subcommand>,
|
||||
|
||||
#[clap(flatten)]
|
||||
pub run: RunCmd,
|
||||
}
|
||||
|
||||
#[derive(Debug, clap::Subcommand)]
|
||||
#[allow(clippy::large_enum_variant)]
|
||||
pub enum Subcommand {
|
||||
/// Key management cli utilities
|
||||
#[command(subcommand)]
|
||||
Key(sc_cli::KeySubcommand),
|
||||
|
||||
/// Build a chain specification.
|
||||
BuildSpec(sc_cli::BuildSpecCmd),
|
||||
|
||||
/// Validate blocks.
|
||||
CheckBlock(sc_cli::CheckBlockCmd),
|
||||
|
||||
/// Export blocks.
|
||||
ExportBlocks(sc_cli::ExportBlocksCmd),
|
||||
|
||||
/// Export the state of a given block into a chain spec.
|
||||
ExportState(sc_cli::ExportStateCmd),
|
||||
|
||||
/// Import blocks.
|
||||
ImportBlocks(sc_cli::ImportBlocksCmd),
|
||||
|
||||
/// Remove the whole chain.
|
||||
PurgeChain(sc_cli::PurgeChainCmd),
|
||||
|
||||
/// Revert the chain to a previous state.
|
||||
Revert(sc_cli::RevertCmd),
|
||||
|
||||
/// Sub-commands concerned with benchmarking.
|
||||
#[command(subcommand)]
|
||||
Benchmark(frame_benchmarking_cli::BenchmarkCmd),
|
||||
|
||||
/// Try-runtime has migrated to a standalone CLI
|
||||
/// (<https://github.com/paritytech/try-runtime-cli>). The subcommand exists as a stub and
|
||||
/// deprecation notice. It will be removed entirely some time after January 2024.
|
||||
TryRuntime,
|
||||
|
||||
/// Db meta columns information.
|
||||
ChainInfo(sc_cli::ChainInfoCmd),
|
||||
}
|
||||
@@ -0,0 +1,188 @@
|
||||
use crate::{
|
||||
benchmarking::{inherent_benchmark_data, RemarkBuilder, TransferKeepAliveBuilder},
|
||||
chain_spec,
|
||||
cli::{Cli, Subcommand},
|
||||
service,
|
||||
};
|
||||
use frame_benchmarking_cli::{BenchmarkCmd, ExtrinsicFactory, SUBSTRATE_REFERENCE_HARDWARE};
|
||||
use sc_cli::SubstrateCli;
|
||||
use sc_service::PartialComponents;
|
||||
use solochain_template_runtime::{Block, EXISTENTIAL_DEPOSIT};
|
||||
use sp_keyring::Sr25519Keyring;
|
||||
|
||||
impl SubstrateCli for Cli {
|
||||
fn impl_name() -> String {
|
||||
"Substrate Node".into()
|
||||
}
|
||||
|
||||
fn impl_version() -> String {
|
||||
env!("SUBSTRATE_CLI_IMPL_VERSION").into()
|
||||
}
|
||||
|
||||
fn description() -> String {
|
||||
env!("CARGO_PKG_DESCRIPTION").into()
|
||||
}
|
||||
|
||||
fn author() -> String {
|
||||
env!("CARGO_PKG_AUTHORS").into()
|
||||
}
|
||||
|
||||
fn support_url() -> String {
|
||||
"support.anonymous.an".into()
|
||||
}
|
||||
|
||||
fn copyright_start_year() -> i32 {
|
||||
2017
|
||||
}
|
||||
|
||||
fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
|
||||
Ok(match id {
|
||||
"dev" => Box::new(chain_spec::development_config()?),
|
||||
"" | "local" => Box::new(chain_spec::local_testnet_config()?),
|
||||
path =>
|
||||
Box::new(chain_spec::ChainSpec::from_json_file(std::path::PathBuf::from(path))?),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse and run command line arguments
|
||||
pub fn run() -> sc_cli::Result<()> {
|
||||
let cli = Cli::from_args();
|
||||
|
||||
match &cli.subcommand {
|
||||
Some(Subcommand::Key(cmd)) => cmd.run(&cli),
|
||||
Some(Subcommand::BuildSpec(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
|
||||
},
|
||||
Some(Subcommand::CheckBlock(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.async_run(|config| {
|
||||
let PartialComponents { client, task_manager, import_queue, .. } =
|
||||
service::new_partial(&config)?;
|
||||
Ok((cmd.run(client, import_queue), task_manager))
|
||||
})
|
||||
},
|
||||
Some(Subcommand::ExportBlocks(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.async_run(|config| {
|
||||
let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?;
|
||||
Ok((cmd.run(client, config.database), task_manager))
|
||||
})
|
||||
},
|
||||
Some(Subcommand::ExportState(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.async_run(|config| {
|
||||
let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?;
|
||||
Ok((cmd.run(client, config.chain_spec), task_manager))
|
||||
})
|
||||
},
|
||||
Some(Subcommand::ImportBlocks(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.async_run(|config| {
|
||||
let PartialComponents { client, task_manager, import_queue, .. } =
|
||||
service::new_partial(&config)?;
|
||||
Ok((cmd.run(client, import_queue), task_manager))
|
||||
})
|
||||
},
|
||||
Some(Subcommand::PurgeChain(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.sync_run(|config| cmd.run(config.database))
|
||||
},
|
||||
Some(Subcommand::Revert(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.async_run(|config| {
|
||||
let PartialComponents { client, task_manager, backend, .. } =
|
||||
service::new_partial(&config)?;
|
||||
let aux_revert = Box::new(|client, _, blocks| {
|
||||
sc_consensus_grandpa::revert(client, blocks)?;
|
||||
Ok(())
|
||||
});
|
||||
Ok((cmd.run(client, backend, Some(aux_revert)), task_manager))
|
||||
})
|
||||
},
|
||||
Some(Subcommand::Benchmark(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
|
||||
runner.sync_run(|config| {
|
||||
// This switch needs to be in the client, since the client decides
|
||||
// which sub-commands it wants to support.
|
||||
match cmd {
|
||||
BenchmarkCmd::Pallet(cmd) => {
|
||||
if !cfg!(feature = "runtime-benchmarks") {
|
||||
return Err(
|
||||
"Runtime benchmarking wasn't enabled when building the node. \
|
||||
You can enable it with `--features runtime-benchmarks`."
|
||||
.into(),
|
||||
)
|
||||
}
|
||||
|
||||
cmd.run::<sp_runtime::traits::HashingFor<Block>, ()>(config)
|
||||
},
|
||||
BenchmarkCmd::Block(cmd) => {
|
||||
let PartialComponents { client, .. } = service::new_partial(&config)?;
|
||||
cmd.run(client)
|
||||
},
|
||||
#[cfg(not(feature = "runtime-benchmarks"))]
|
||||
BenchmarkCmd::Storage(_) => Err(
|
||||
"Storage benchmarking can be enabled with `--features runtime-benchmarks`."
|
||||
.into(),
|
||||
),
|
||||
#[cfg(feature = "runtime-benchmarks")]
|
||||
BenchmarkCmd::Storage(cmd) => {
|
||||
let PartialComponents { client, backend, .. } =
|
||||
service::new_partial(&config)?;
|
||||
let db = backend.expose_db();
|
||||
let storage = backend.expose_storage();
|
||||
|
||||
cmd.run(config, client, db, storage)
|
||||
},
|
||||
BenchmarkCmd::Overhead(cmd) => {
|
||||
let PartialComponents { client, .. } = service::new_partial(&config)?;
|
||||
let ext_builder = RemarkBuilder::new(client.clone());
|
||||
|
||||
cmd.run(
|
||||
config,
|
||||
client,
|
||||
inherent_benchmark_data()?,
|
||||
Vec::new(),
|
||||
&ext_builder,
|
||||
)
|
||||
},
|
||||
BenchmarkCmd::Extrinsic(cmd) => {
|
||||
let PartialComponents { client, .. } = service::new_partial(&config)?;
|
||||
// Register the *Remark* and *TKA* builders.
|
||||
let ext_factory = ExtrinsicFactory(vec![
|
||||
Box::new(RemarkBuilder::new(client.clone())),
|
||||
Box::new(TransferKeepAliveBuilder::new(
|
||||
client.clone(),
|
||||
Sr25519Keyring::Alice.to_account_id(),
|
||||
EXISTENTIAL_DEPOSIT,
|
||||
)),
|
||||
]);
|
||||
|
||||
cmd.run(client, inherent_benchmark_data()?, Vec::new(), &ext_factory)
|
||||
},
|
||||
BenchmarkCmd::Machine(cmd) =>
|
||||
cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone()),
|
||||
}
|
||||
})
|
||||
},
|
||||
#[cfg(feature = "try-runtime")]
|
||||
Some(Subcommand::TryRuntime) => Err(try_runtime_cli::DEPRECATION_NOTICE.into()),
|
||||
#[cfg(not(feature = "try-runtime"))]
|
||||
Some(Subcommand::TryRuntime) => Err("TryRuntime wasn't enabled when building the node. \
|
||||
You can enable it with `--features try-runtime`."
|
||||
.into()),
|
||||
Some(Subcommand::ChainInfo(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.sync_run(|config| cmd.run::<Block>(&config))
|
||||
},
|
||||
None => {
|
||||
let runner = cli.create_runner(&cli.run)?;
|
||||
runner.run_node_until_exit(|config| async move {
|
||||
service::new_full(config).map_err(sc_cli::Error::Service)
|
||||
})
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
//! Substrate Node Template CLI library.
|
||||
#![warn(missing_docs)]
|
||||
|
||||
mod benchmarking;
|
||||
mod chain_spec;
|
||||
mod cli;
|
||||
mod command;
|
||||
mod rpc;
|
||||
mod service;
|
||||
|
||||
fn main() -> sc_cli::Result<()> {
|
||||
command::run()
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
//! A collection of node-specific RPC methods.
|
||||
//! Substrate provides the `sc-rpc` crate, which defines the core RPC layer
|
||||
//! used by Substrate nodes. This file extends those RPC definitions with
|
||||
//! capabilities that are specific to this project's runtime configuration.
|
||||
|
||||
#![warn(missing_docs)]
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use jsonrpsee::RpcModule;
|
||||
use sc_transaction_pool_api::TransactionPool;
|
||||
use solochain_template_runtime::{opaque::Block, AccountId, Balance, Nonce};
|
||||
use sp_api::ProvideRuntimeApi;
|
||||
use sp_block_builder::BlockBuilder;
|
||||
use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
|
||||
|
||||
pub use sc_rpc_api::DenyUnsafe;
|
||||
|
||||
/// Full client dependencies.
|
||||
pub struct FullDeps<C, P> {
|
||||
/// The client instance to use.
|
||||
pub client: Arc<C>,
|
||||
/// Transaction pool instance.
|
||||
pub pool: Arc<P>,
|
||||
/// Whether to deny unsafe calls
|
||||
pub deny_unsafe: DenyUnsafe,
|
||||
}
|
||||
|
||||
/// Instantiate all full RPC extensions.
|
||||
pub fn create_full<C, P>(
|
||||
deps: FullDeps<C, P>,
|
||||
) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
|
||||
where
|
||||
C: ProvideRuntimeApi<Block>,
|
||||
C: HeaderBackend<Block> + HeaderMetadata<Block, Error = BlockChainError> + 'static,
|
||||
C: Send + Sync + 'static,
|
||||
C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
|
||||
C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
|
||||
C::Api: BlockBuilder<Block>,
|
||||
P: TransactionPool + 'static,
|
||||
{
|
||||
use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
|
||||
use substrate_frame_rpc_system::{System, SystemApiServer};
|
||||
|
||||
let mut module = RpcModule::new(());
|
||||
let FullDeps { client, pool, deny_unsafe } = deps;
|
||||
|
||||
module.merge(System::new(client.clone(), pool, deny_unsafe).into_rpc())?;
|
||||
module.merge(TransactionPayment::new(client).into_rpc())?;
|
||||
|
||||
// Extend this RPC with a custom API by using the following syntax.
|
||||
// `YourRpcStruct` should have a reference to a client, which is needed
|
||||
// to call into the runtime.
|
||||
// `module.merge(YourRpcTrait::into_rpc(YourRpcStruct::new(ReferenceToClient, ...)))?;`
|
||||
|
||||
// You probably want to enable the `rpc v2 chainSpec` API as well
|
||||
//
|
||||
// let chain_name = chain_spec.name().to_string();
|
||||
// let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed");
|
||||
// let properties = chain_spec.properties();
|
||||
// module.merge(ChainSpec::new(chain_name, genesis_hash, properties).into_rpc())?;
|
||||
|
||||
Ok(module)
|
||||
}
|
||||
@@ -0,0 +1,317 @@
|
||||
//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
|
||||
|
||||
use futures::FutureExt;
|
||||
use sc_client_api::{Backend, BlockBackend};
|
||||
use sc_consensus_aura::{ImportQueueParams, SlotProportion, StartAuraParams};
|
||||
use sc_consensus_grandpa::SharedVoterState;
|
||||
use sc_service::{error::Error as ServiceError, Configuration, TaskManager, WarpSyncParams};
|
||||
use sc_telemetry::{Telemetry, TelemetryWorker};
|
||||
use sc_transaction_pool_api::OffchainTransactionPoolFactory;
|
||||
use solochain_template_runtime::{self, opaque::Block, RuntimeApi};
|
||||
use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
|
||||
use std::{sync::Arc, time::Duration};
|
||||
|
||||
pub(crate) type FullClient = sc_service::TFullClient<
|
||||
Block,
|
||||
RuntimeApi,
|
||||
sc_executor::WasmExecutor<sp_io::SubstrateHostFunctions>,
|
||||
>;
|
||||
type FullBackend = sc_service::TFullBackend<Block>;
|
||||
type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
|
||||
|
||||
/// The minimum period of blocks on which justifications will be
|
||||
/// imported and generated.
|
||||
const GRANDPA_JUSTIFICATION_PERIOD: u32 = 512;
|
||||
|
||||
pub type Service = sc_service::PartialComponents<
|
||||
FullClient,
|
||||
FullBackend,
|
||||
FullSelectChain,
|
||||
sc_consensus::DefaultImportQueue<Block>,
|
||||
sc_transaction_pool::FullPool<Block, FullClient>,
|
||||
(
|
||||
sc_consensus_grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, FullSelectChain>,
|
||||
sc_consensus_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
|
||||
Option<Telemetry>,
|
||||
),
|
||||
>;
|
||||
|
||||
pub fn new_partial(config: &Configuration) -> Result<Service, ServiceError> {
|
||||
let telemetry = config
|
||||
.telemetry_endpoints
|
||||
.clone()
|
||||
.filter(|x| !x.is_empty())
|
||||
.map(|endpoints| -> Result<_, sc_telemetry::Error> {
|
||||
let worker = TelemetryWorker::new(16)?;
|
||||
let telemetry = worker.handle().new_telemetry(endpoints);
|
||||
Ok((worker, telemetry))
|
||||
})
|
||||
.transpose()?;
|
||||
|
||||
let executor = sc_service::new_wasm_executor::<sp_io::SubstrateHostFunctions>(config);
|
||||
let (client, backend, keystore_container, task_manager) =
|
||||
sc_service::new_full_parts::<Block, RuntimeApi, _>(
|
||||
config,
|
||||
telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
|
||||
executor,
|
||||
)?;
|
||||
let client = Arc::new(client);
|
||||
|
||||
let telemetry = telemetry.map(|(worker, telemetry)| {
|
||||
task_manager.spawn_handle().spawn("telemetry", None, worker.run());
|
||||
telemetry
|
||||
});
|
||||
|
||||
let select_chain = sc_consensus::LongestChain::new(backend.clone());
|
||||
|
||||
let transaction_pool = sc_transaction_pool::BasicPool::new_full(
|
||||
config.transaction_pool.clone(),
|
||||
config.role.is_authority().into(),
|
||||
config.prometheus_registry(),
|
||||
task_manager.spawn_essential_handle(),
|
||||
client.clone(),
|
||||
);
|
||||
|
||||
let (grandpa_block_import, grandpa_link) = sc_consensus_grandpa::block_import(
|
||||
client.clone(),
|
||||
GRANDPA_JUSTIFICATION_PERIOD,
|
||||
&client,
|
||||
select_chain.clone(),
|
||||
telemetry.as_ref().map(|x| x.handle()),
|
||||
)?;
|
||||
|
||||
let cidp_client = client.clone();
|
||||
let import_queue =
|
||||
sc_consensus_aura::import_queue::<AuraPair, _, _, _, _, _>(ImportQueueParams {
|
||||
block_import: grandpa_block_import.clone(),
|
||||
justification_import: Some(Box::new(grandpa_block_import.clone())),
|
||||
client: client.clone(),
|
||||
create_inherent_data_providers: move |parent_hash, _| {
|
||||
let cidp_client = cidp_client.clone();
|
||||
async move {
|
||||
let slot_duration = sc_consensus_aura::standalone::slot_duration_at(
|
||||
&*cidp_client,
|
||||
parent_hash,
|
||||
)?;
|
||||
let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
|
||||
|
||||
let slot =
|
||||
sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
|
||||
*timestamp,
|
||||
slot_duration,
|
||||
);
|
||||
|
||||
Ok((slot, timestamp))
|
||||
}
|
||||
},
|
||||
spawner: &task_manager.spawn_essential_handle(),
|
||||
registry: config.prometheus_registry(),
|
||||
check_for_equivocation: Default::default(),
|
||||
telemetry: telemetry.as_ref().map(|x| x.handle()),
|
||||
compatibility_mode: Default::default(),
|
||||
})?;
|
||||
|
||||
Ok(sc_service::PartialComponents {
|
||||
client,
|
||||
backend,
|
||||
task_manager,
|
||||
import_queue,
|
||||
keystore_container,
|
||||
select_chain,
|
||||
transaction_pool,
|
||||
other: (grandpa_block_import, grandpa_link, telemetry),
|
||||
})
|
||||
}
|
||||
|
||||
/// Builds a new service for a full client.
|
||||
pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
|
||||
let sc_service::PartialComponents {
|
||||
client,
|
||||
backend,
|
||||
mut task_manager,
|
||||
import_queue,
|
||||
keystore_container,
|
||||
select_chain,
|
||||
transaction_pool,
|
||||
other: (block_import, grandpa_link, mut telemetry),
|
||||
} = new_partial(&config)?;
|
||||
|
||||
let mut net_config = sc_network::config::FullNetworkConfiguration::new(&config.network);
|
||||
|
||||
let grandpa_protocol_name = sc_consensus_grandpa::protocol_standard_name(
|
||||
&client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"),
|
||||
&config.chain_spec,
|
||||
);
|
||||
let (grandpa_protocol_config, grandpa_notification_service) =
|
||||
sc_consensus_grandpa::grandpa_peers_set_config(grandpa_protocol_name.clone());
|
||||
net_config.add_notification_protocol(grandpa_protocol_config);
|
||||
|
||||
let warp_sync = Arc::new(sc_consensus_grandpa::warp_proof::NetworkProvider::new(
|
||||
backend.clone(),
|
||||
grandpa_link.shared_authority_set().clone(),
|
||||
Vec::default(),
|
||||
));
|
||||
|
||||
let (network, system_rpc_tx, tx_handler_controller, network_starter, sync_service) =
|
||||
sc_service::build_network(sc_service::BuildNetworkParams {
|
||||
config: &config,
|
||||
net_config,
|
||||
client: client.clone(),
|
||||
transaction_pool: transaction_pool.clone(),
|
||||
spawn_handle: task_manager.spawn_handle(),
|
||||
import_queue,
|
||||
block_announce_validator_builder: None,
|
||||
warp_sync_params: Some(WarpSyncParams::WithProvider(warp_sync)),
|
||||
block_relay: None,
|
||||
})?;
|
||||
|
||||
if config.offchain_worker.enabled {
|
||||
task_manager.spawn_handle().spawn(
|
||||
"offchain-workers-runner",
|
||||
"offchain-worker",
|
||||
sc_offchain::OffchainWorkers::new(sc_offchain::OffchainWorkerOptions {
|
||||
runtime_api_provider: client.clone(),
|
||||
is_validator: config.role.is_authority(),
|
||||
keystore: Some(keystore_container.keystore()),
|
||||
offchain_db: backend.offchain_storage(),
|
||||
transaction_pool: Some(OffchainTransactionPoolFactory::new(
|
||||
transaction_pool.clone(),
|
||||
)),
|
||||
network_provider: network.clone(),
|
||||
enable_http_requests: true,
|
||||
custom_extensions: |_| vec![],
|
||||
})
|
||||
.run(client.clone(), task_manager.spawn_handle())
|
||||
.boxed(),
|
||||
);
|
||||
}
|
||||
|
||||
let role = config.role.clone();
|
||||
let force_authoring = config.force_authoring;
|
||||
let backoff_authoring_blocks: Option<()> = None;
|
||||
let name = config.network.node_name.clone();
|
||||
let enable_grandpa = !config.disable_grandpa;
|
||||
let prometheus_registry = config.prometheus_registry().cloned();
|
||||
|
||||
let rpc_extensions_builder = {
|
||||
let client = client.clone();
|
||||
let pool = transaction_pool.clone();
|
||||
|
||||
Box::new(move |deny_unsafe, _| {
|
||||
let deps =
|
||||
crate::rpc::FullDeps { client: client.clone(), pool: pool.clone(), deny_unsafe };
|
||||
crate::rpc::create_full(deps).map_err(Into::into)
|
||||
})
|
||||
};
|
||||
|
||||
let _rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
|
||||
network: network.clone(),
|
||||
client: client.clone(),
|
||||
keystore: keystore_container.keystore(),
|
||||
task_manager: &mut task_manager,
|
||||
transaction_pool: transaction_pool.clone(),
|
||||
rpc_builder: rpc_extensions_builder,
|
||||
backend,
|
||||
system_rpc_tx,
|
||||
tx_handler_controller,
|
||||
sync_service: sync_service.clone(),
|
||||
config,
|
||||
telemetry: telemetry.as_mut(),
|
||||
})?;
|
||||
|
||||
if role.is_authority() {
|
||||
let proposer_factory = sc_basic_authorship::ProposerFactory::new(
|
||||
task_manager.spawn_handle(),
|
||||
client.clone(),
|
||||
transaction_pool.clone(),
|
||||
prometheus_registry.as_ref(),
|
||||
telemetry.as_ref().map(|x| x.handle()),
|
||||
);
|
||||
|
||||
let slot_duration = sc_consensus_aura::slot_duration(&*client)?;
|
||||
|
||||
let aura = sc_consensus_aura::start_aura::<AuraPair, _, _, _, _, _, _, _, _, _, _>(
|
||||
StartAuraParams {
|
||||
slot_duration,
|
||||
client,
|
||||
select_chain,
|
||||
block_import,
|
||||
proposer_factory,
|
||||
create_inherent_data_providers: move |_, ()| async move {
|
||||
let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
|
||||
|
||||
let slot =
|
||||
sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
|
||||
*timestamp,
|
||||
slot_duration,
|
||||
);
|
||||
|
||||
Ok((slot, timestamp))
|
||||
},
|
||||
force_authoring,
|
||||
backoff_authoring_blocks,
|
||||
keystore: keystore_container.keystore(),
|
||||
sync_oracle: sync_service.clone(),
|
||||
justification_sync_link: sync_service.clone(),
|
||||
block_proposal_slot_portion: SlotProportion::new(2f32 / 3f32),
|
||||
max_block_proposal_slot_portion: None,
|
||||
telemetry: telemetry.as_ref().map(|x| x.handle()),
|
||||
compatibility_mode: Default::default(),
|
||||
},
|
||||
)?;
|
||||
|
||||
// the AURA authoring task is considered essential, i.e. if it
|
||||
// fails we take down the service with it.
|
||||
task_manager
|
||||
.spawn_essential_handle()
|
||||
.spawn_blocking("aura", Some("block-authoring"), aura);
|
||||
}
|
||||
|
||||
if enable_grandpa {
|
||||
// if the node isn't actively participating in consensus then it doesn't
|
||||
// need a keystore, regardless of which protocol we use below.
|
||||
let keystore = if role.is_authority() { Some(keystore_container.keystore()) } else { None };
|
||||
|
||||
let grandpa_config = sc_consensus_grandpa::Config {
|
||||
// FIXME #1578 make this available through chainspec
|
||||
gossip_duration: Duration::from_millis(333),
|
||||
justification_generation_period: GRANDPA_JUSTIFICATION_PERIOD,
|
||||
name: Some(name),
|
||||
observer_enabled: false,
|
||||
keystore,
|
||||
local_role: role,
|
||||
telemetry: telemetry.as_ref().map(|x| x.handle()),
|
||||
protocol_name: grandpa_protocol_name,
|
||||
};
|
||||
|
||||
// start the full GRANDPA voter
|
||||
// NOTE: non-authorities could run the GRANDPA observer protocol, but at
|
||||
// this point the full voter should provide better guarantees of block
|
||||
// and vote data availability than the observer. The observer has not
|
||||
// been tested extensively yet and having most nodes in a network run it
|
||||
// could lead to finality stalls.
|
||||
let grandpa_config = sc_consensus_grandpa::GrandpaParams {
|
||||
config: grandpa_config,
|
||||
link: grandpa_link,
|
||||
network,
|
||||
sync: Arc::new(sync_service),
|
||||
notification_service: grandpa_notification_service,
|
||||
voting_rule: sc_consensus_grandpa::VotingRulesBuilder::default().build(),
|
||||
prometheus_registry,
|
||||
shared_voter_state: SharedVoterState::empty(),
|
||||
telemetry: telemetry.as_ref().map(|x| x.handle()),
|
||||
offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(transaction_pool),
|
||||
};
|
||||
|
||||
// the GRANDPA voter task is considered infallible, i.e.
|
||||
// if it fails we take down the service with it.
|
||||
task_manager.spawn_essential_handle().spawn_blocking(
|
||||
"grandpa-voter",
|
||||
None,
|
||||
sc_consensus_grandpa::run_grandpa_voter(grandpa_config)?,
|
||||
);
|
||||
}
|
||||
|
||||
network_starter.start_network();
|
||||
Ok(task_manager)
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
[package]
|
||||
name = "pallet-template"
|
||||
description = "FRAME pallet template for defining custom runtime logic. (polkadot v1.9.0)"
|
||||
version = "0.1.0"
|
||||
license = "MIT-0"
|
||||
authors.workspace = true
|
||||
homepage.workspace = true
|
||||
repository.workspace = true
|
||||
edition.workspace = true
|
||||
publish = false
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
targets = ["x86_64-unknown-linux-gnu"]
|
||||
|
||||
[dependencies]
|
||||
codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
|
||||
"derive",
|
||||
] }
|
||||
scale-info = { version = "2.10.0", default-features = false, features = [
|
||||
"derive",
|
||||
] }
|
||||
|
||||
# frame deps
|
||||
frame-benchmarking = { version = "31.0.0", default-features = false, optional = true }
|
||||
frame-support = { version = "31.0.0", default-features = false }
|
||||
frame-system = { version = "31.0.0", default-features = false }
|
||||
|
||||
[dev-dependencies]
|
||||
sp-core = { version = "31.0.0" }
|
||||
sp-io = { version = "33.0.0" }
|
||||
sp-runtime = { version = "34.0.0" }
|
||||
|
||||
[features]
|
||||
default = ["std"]
|
||||
std = [
|
||||
"codec/std",
|
||||
"frame-benchmarking?/std",
|
||||
"frame-support/std",
|
||||
"frame-system/std",
|
||||
"scale-info/std",
|
||||
]
|
||||
runtime-benchmarks = [
|
||||
"frame-benchmarking/runtime-benchmarks",
|
||||
"frame-support/runtime-benchmarks",
|
||||
"frame-system/runtime-benchmarks",
|
||||
]
|
||||
try-runtime = [
|
||||
"frame-support/try-runtime",
|
||||
"frame-system/try-runtime",
|
||||
]
|
||||
@@ -0,0 +1 @@
|
||||
License: MIT-0
|
||||
@@ -0,0 +1,35 @@
|
||||
//! Benchmarking setup for pallet-template
|
||||
#![cfg(feature = "runtime-benchmarks")]
|
||||
use super::*;
|
||||
|
||||
#[allow(unused)]
|
||||
use crate::Pallet as Template;
|
||||
use frame_benchmarking::v2::*;
|
||||
use frame_system::RawOrigin;
|
||||
|
||||
#[benchmarks]
|
||||
mod benchmarks {
|
||||
use super::*;
|
||||
|
||||
#[benchmark]
|
||||
fn do_something() {
|
||||
let value = 100u32.into();
|
||||
let caller: T::AccountId = whitelisted_caller();
|
||||
#[extrinsic_call]
|
||||
do_something(RawOrigin::Signed(caller), value);
|
||||
|
||||
assert_eq!(Something::<T>::get(), Some(value));
|
||||
}
|
||||
|
||||
#[benchmark]
|
||||
fn cause_error() {
|
||||
Something::<T>::put(100u32);
|
||||
let caller: T::AccountId = whitelisted_caller();
|
||||
#[extrinsic_call]
|
||||
cause_error(RawOrigin::Signed(caller));
|
||||
|
||||
assert_eq!(Something::<T>::get(), Some(101u32));
|
||||
}
|
||||
|
||||
impl_benchmark_test_suite!(Template, crate::mock::new_test_ext(), crate::mock::Test);
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
//! # Template Pallet
|
||||
//!
|
||||
//! A pallet with minimal functionality to help developers understand the essential components of
|
||||
//! writing a FRAME pallet. It is typically used in beginner tutorials or in Substrate template
|
||||
//! nodes as a starting point for creating a new pallet and **not meant to be used in production**.
|
||||
//!
|
||||
//! ## Overview
|
||||
//!
|
||||
//! This template pallet contains basic examples of:
|
||||
//! - declaring a storage item that stores a single `u32` value
|
||||
//! - declaring and using events
|
||||
//! - declaring and using errors
|
||||
//! - a dispatchable function that allows a user to set a new value to storage and emits an event
|
||||
//! upon success
|
||||
//! - another dispatchable function that causes a custom error to be thrown
|
||||
//!
|
||||
//! Each pallet section is annotated with an attribute using the `#[pallet::...]` procedural macro.
|
||||
//! This macro generates the necessary code for a pallet to be aggregated into a FRAME runtime.
|
||||
//!
|
||||
//! Learn more about FRAME macros [here](https://docs.substrate.io/reference/frame-macros/).
|
||||
//!
|
||||
//! ### Pallet Sections
|
||||
//!
|
||||
//! The pallet sections in this template are:
|
||||
//!
|
||||
//! - A **configuration trait** that defines the types and parameters which the pallet depends on
|
||||
//! (denoted by the `#[pallet::config]` attribute). See: [`Config`].
|
||||
//! - A **means to store pallet-specific data** (denoted by the `#[pallet::storage]` attribute).
|
||||
//! See: [`storage_types`].
|
||||
//! - A **declaration of the events** this pallet emits (denoted by the `#[pallet::event]`
|
||||
//! attribute). See: [`Event`].
|
||||
//! - A **declaration of the errors** that this pallet can throw (denoted by the `#[pallet::error]`
|
||||
//! attribute). See: [`Error`].
|
||||
//! - A **set of dispatchable functions** that define the pallet's functionality (denoted by the
|
||||
//! `#[pallet::call]` attribute). See: [`dispatchables`].
|
||||
//!
|
||||
//! Run `cargo doc --package pallet-template --open` to view this pallet's documentation.
|
||||
|
||||
// We make sure this pallet uses `no_std` for compiling to Wasm.
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
// Re-export pallet items so that they can be accessed from the crate namespace.
|
||||
pub use pallet::*;
|
||||
|
||||
// FRAME pallets require their own "mock runtimes" to be able to run unit tests. This module
|
||||
// contains a mock runtime specific for testing this pallet's functionality.
|
||||
#[cfg(test)]
|
||||
mod mock;
|
||||
|
||||
// This module contains the unit tests for this pallet.
|
||||
// Learn about pallet unit testing here: https://docs.substrate.io/test/unit-testing/
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
// Every callable function or "dispatchable" a pallet exposes must have weight values that correctly
|
||||
// estimate a dispatchable's execution time. The benchmarking module is used to calculate weights
|
||||
// for each dispatchable and generates this pallet's weight.rs file. Learn more about benchmarking here: https://docs.substrate.io/test/benchmark/
|
||||
#[cfg(feature = "runtime-benchmarks")]
|
||||
mod benchmarking;
|
||||
pub mod weights;
|
||||
pub use weights::*;
|
||||
|
||||
// All pallet logic is defined in its own module and must be annotated by the `pallet` attribute.
|
||||
#[frame_support::pallet]
|
||||
pub mod pallet {
|
||||
// Import various useful types required by all FRAME pallets.
|
||||
use super::*;
|
||||
use frame_support::pallet_prelude::*;
|
||||
use frame_system::pallet_prelude::*;
|
||||
|
||||
// The `Pallet` struct serves as a placeholder to implement traits, methods and dispatchables
|
||||
// (`Call`s) in this pallet.
|
||||
#[pallet::pallet]
|
||||
pub struct Pallet<T>(_);
|
||||
|
||||
/// The pallet's configuration trait.
|
||||
///
|
||||
/// All our types and constants a pallet depends on must be declared here.
|
||||
/// These types are defined generically and made concrete when the pallet is declared in the
|
||||
/// `runtime/src/lib.rs` file of your chain.
|
||||
#[pallet::config]
|
||||
pub trait Config: frame_system::Config {
|
||||
/// The overarching runtime event type.
|
||||
type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
|
||||
/// A type representing the weights required by the dispatchables of this pallet.
|
||||
type WeightInfo: WeightInfo;
|
||||
}
|
||||
|
||||
/// A storage item for this pallet.
|
||||
///
|
||||
/// In this template, we are declaring a storage item called `Something` that stores a single
|
||||
/// `u32` value. Learn more about runtime storage here: <https://docs.substrate.io/build/runtime-storage/>
|
||||
#[pallet::storage]
|
||||
pub type Something<T> = StorageValue<_, u32>;
|
||||
|
||||
/// Events that functions in this pallet can emit.
|
||||
///
|
||||
/// Events are a simple means of indicating to the outside world (such as dApps, chain explorers
|
||||
/// or other users) that some notable update in the runtime has occurred. In a FRAME pallet, the
|
||||
/// documentation for each event field and its parameters is added to a node's metadata so it
|
||||
/// can be used by external interfaces or tools.
|
||||
///
|
||||
/// The `generate_deposit` macro generates a function on `Pallet` called `deposit_event` which
|
||||
/// will convert the event type of your pallet into `RuntimeEvent` (declared in the pallet's
|
||||
/// [`Config`] trait) and deposit it using [`frame_system::Pallet::deposit_event`].
|
||||
#[pallet::event]
|
||||
#[pallet::generate_deposit(pub(super) fn deposit_event)]
|
||||
pub enum Event<T: Config> {
|
||||
/// A user has successfully set a new value.
|
||||
SomethingStored {
|
||||
/// The new value set.
|
||||
something: u32,
|
||||
/// The account who set the new value.
|
||||
who: T::AccountId,
|
||||
},
|
||||
}
|
||||
|
||||
/// Errors that can be returned by this pallet.
|
||||
///
|
||||
/// Errors tell users that something went wrong so it's important that their naming is
|
||||
/// informative. Similar to events, error documentation is added to a node's metadata so it's
|
||||
/// equally important that they have helpful documentation associated with them.
|
||||
///
|
||||
/// This type of runtime error can be up to 4 bytes in size should you want to return additional
|
||||
/// information.
|
||||
#[pallet::error]
|
||||
pub enum Error<T> {
|
||||
/// The value retrieved was `None` as no value was previously set.
|
||||
NoneValue,
|
||||
/// There was an attempt to increment the value in storage over `u32::MAX`.
|
||||
StorageOverflow,
|
||||
}
|
||||
|
||||
/// The pallet's dispatchable functions ([`Call`]s).
|
||||
///
|
||||
/// Dispatchable functions allows users to interact with the pallet and invoke state changes.
|
||||
/// These functions materialize as "extrinsics", which are often compared to transactions.
|
||||
/// They must always return a `DispatchResult` and be annotated with a weight and call index.
|
||||
///
|
||||
/// The [`call_index`] macro is used to explicitly
|
||||
/// define an index for calls in the [`Call`] enum. This is useful for pallets that may
|
||||
/// introduce new dispatchables over time. If the order of a dispatchable changes, its index
|
||||
/// will also change which will break backwards compatibility.
|
||||
///
|
||||
/// The [`weight`] macro is used to assign a weight to each call.
|
||||
#[pallet::call]
|
||||
impl<T: Config> Pallet<T> {
|
||||
/// An example dispatchable that takes a single u32 value as a parameter, writes the value
|
||||
/// to storage and emits an event.
|
||||
///
|
||||
/// It checks that the _origin_ for this call is _Signed_ and returns a dispatch
|
||||
/// error if it isn't. Learn more about origins here: <https://docs.substrate.io/build/origins/>
|
||||
#[pallet::call_index(0)]
|
||||
#[pallet::weight(T::WeightInfo::do_something())]
|
||||
pub fn do_something(origin: OriginFor<T>, something: u32) -> DispatchResult {
|
||||
// Check that the extrinsic was signed and get the signer.
|
||||
let who = ensure_signed(origin)?;
|
||||
|
||||
// Update storage.
|
||||
Something::<T>::put(something);
|
||||
|
||||
// Emit an event.
|
||||
Self::deposit_event(Event::SomethingStored { something, who });
|
||||
|
||||
// Return a successful `DispatchResult`
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// An example dispatchable that may throw a custom error.
|
||||
///
|
||||
/// It checks that the caller is a signed origin and reads the current value from the
|
||||
/// `Something` storage item. If a current value exists, it is incremented by 1 and then
|
||||
/// written back to storage.
|
||||
///
|
||||
/// ## Errors
|
||||
///
|
||||
/// The function will return an error under the following conditions:
|
||||
///
|
||||
/// - If no value has been set ([`Error::NoneValue`])
|
||||
/// - If incrementing the value in storage causes an arithmetic overflow
|
||||
/// ([`Error::StorageOverflow`])
|
||||
#[pallet::call_index(1)]
|
||||
#[pallet::weight(T::WeightInfo::cause_error())]
|
||||
pub fn cause_error(origin: OriginFor<T>) -> DispatchResult {
|
||||
let _who = ensure_signed(origin)?;
|
||||
|
||||
// Read a value from storage.
|
||||
match Something::<T>::get() {
|
||||
// Return an error if the value has not been set.
|
||||
None => Err(Error::<T>::NoneValue.into()),
|
||||
Some(old) => {
|
||||
// Increment the value read from storage. This will cause an error in the event
|
||||
// of overflow.
|
||||
let new = old.checked_add(1).ok_or(Error::<T>::StorageOverflow)?;
|
||||
// Update the value in storage with the incremented result.
|
||||
Something::<T>::put(new);
|
||||
Ok(())
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
use crate as pallet_template;
|
||||
use frame_support::{
|
||||
derive_impl,
|
||||
traits::{ConstU16, ConstU64},
|
||||
};
|
||||
use sp_core::H256;
|
||||
use sp_runtime::{
|
||||
traits::{BlakeTwo256, IdentityLookup},
|
||||
BuildStorage,
|
||||
};
|
||||
|
||||
type Block = frame_system::mocking::MockBlock<Test>;
|
||||
|
||||
// Configure a mock runtime to test the pallet.
|
||||
frame_support::construct_runtime!(
|
||||
pub enum Test
|
||||
{
|
||||
System: frame_system,
|
||||
TemplateModule: pallet_template,
|
||||
}
|
||||
);
|
||||
|
||||
#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
|
||||
impl frame_system::Config for Test {
|
||||
type BaseCallFilter = frame_support::traits::Everything;
|
||||
type BlockWeights = ();
|
||||
type BlockLength = ();
|
||||
type DbWeight = ();
|
||||
type RuntimeOrigin = RuntimeOrigin;
|
||||
type RuntimeCall = RuntimeCall;
|
||||
type Nonce = u64;
|
||||
type Hash = H256;
|
||||
type Hashing = BlakeTwo256;
|
||||
type AccountId = u64;
|
||||
type Lookup = IdentityLookup<Self::AccountId>;
|
||||
type Block = Block;
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type BlockHashCount = ConstU64<250>;
|
||||
type Version = ();
|
||||
type PalletInfo = PalletInfo;
|
||||
type AccountData = ();
|
||||
type OnNewAccount = ();
|
||||
type OnKilledAccount = ();
|
||||
type SystemWeightInfo = ();
|
||||
type SS58Prefix = ConstU16<42>;
|
||||
type OnSetCode = ();
|
||||
type MaxConsumers = frame_support::traits::ConstU32<16>;
|
||||
}
|
||||
|
||||
impl pallet_template::Config for Test {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type WeightInfo = ();
|
||||
}
|
||||
|
||||
// Build genesis storage according to the mock runtime.
|
||||
pub fn new_test_ext() -> sp_io::TestExternalities {
|
||||
frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
use crate::{mock::*, Error, Event, Something};
|
||||
use frame_support::{assert_noop, assert_ok};
|
||||
|
||||
#[test]
|
||||
fn it_works_for_default_value() {
|
||||
new_test_ext().execute_with(|| {
|
||||
// Go past genesis block so events get deposited
|
||||
System::set_block_number(1);
|
||||
// Dispatch a signed extrinsic.
|
||||
assert_ok!(TemplateModule::do_something(RuntimeOrigin::signed(1), 42));
|
||||
// Read pallet storage and assert an expected result.
|
||||
assert_eq!(Something::<Test>::get(), Some(42));
|
||||
// Assert that the correct event was deposited
|
||||
System::assert_last_event(Event::SomethingStored { something: 42, who: 1 }.into());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn correct_error_for_none_value() {
|
||||
new_test_ext().execute_with(|| {
|
||||
// Ensure the expected error is thrown when no value is present.
|
||||
assert_noop!(
|
||||
TemplateModule::cause_error(RuntimeOrigin::signed(1)),
|
||||
Error::<Test>::NoneValue
|
||||
);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
|
||||
//! Autogenerated weights for pallet_template
|
||||
//!
|
||||
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
|
||||
//! DATE: 2023-04-06, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
|
||||
//! WORST CASE MAP SIZE: `1000000`
|
||||
//! HOSTNAME: `Alexs-MacBook-Pro-2.local`, CPU: `<UNKNOWN>`
|
||||
//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
|
||||
|
||||
// Executed Command:
|
||||
// ../../target/release/node-template
|
||||
// benchmark
|
||||
// pallet
|
||||
// --chain
|
||||
// dev
|
||||
// --pallet
|
||||
// pallet_template
|
||||
// --extrinsic
|
||||
// *
|
||||
// --steps=50
|
||||
// --repeat=20
|
||||
// --wasm-execution=compiled
|
||||
// --output
|
||||
// pallets/template/src/weights.rs
|
||||
// --template
|
||||
// ../../.maintain/frame-weight-template.hbs
|
||||
|
||||
#![cfg_attr(rustfmt, rustfmt_skip)]
|
||||
#![allow(unused_parens)]
|
||||
#![allow(unused_imports)]
|
||||
|
||||
use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
|
||||
use core::marker::PhantomData;
|
||||
|
||||
/// Weight functions needed for pallet_template.
|
||||
pub trait WeightInfo {
|
||||
fn do_something() -> Weight;
|
||||
fn cause_error() -> Weight;
|
||||
}
|
||||
|
||||
/// Weights for pallet_template using the Substrate node and recommended hardware.
|
||||
pub struct SubstrateWeight<T>(PhantomData<T>);
|
||||
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
|
||||
/// Storage: TemplateModule Something (r:0 w:1)
|
||||
/// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
|
||||
fn do_something() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `0`
|
||||
// Estimated: `0`
|
||||
// Minimum execution time: 8_000_000 picoseconds.
|
||||
Weight::from_parts(9_000_000, 0)
|
||||
.saturating_add(T::DbWeight::get().writes(1_u64))
|
||||
}
|
||||
/// Storage: TemplateModule Something (r:1 w:1)
|
||||
/// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
|
||||
fn cause_error() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `32`
|
||||
// Estimated: `1489`
|
||||
// Minimum execution time: 6_000_000 picoseconds.
|
||||
Weight::from_parts(6_000_000, 1489)
|
||||
.saturating_add(T::DbWeight::get().reads(1_u64))
|
||||
.saturating_add(T::DbWeight::get().writes(1_u64))
|
||||
}
|
||||
}
|
||||
|
||||
// For backwards compatibility and tests
|
||||
impl WeightInfo for () {
|
||||
/// Storage: TemplateModule Something (r:0 w:1)
|
||||
/// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
|
||||
fn do_something() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `0`
|
||||
// Estimated: `0`
|
||||
// Minimum execution time: 8_000_000 picoseconds.
|
||||
Weight::from_parts(9_000_000, 0)
|
||||
.saturating_add(RocksDbWeight::get().writes(1_u64))
|
||||
}
|
||||
/// Storage: TemplateModule Something (r:1 w:1)
|
||||
/// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
|
||||
fn cause_error() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `32`
|
||||
// Estimated: `1489`
|
||||
// Minimum execution time: 6_000_000 picoseconds.
|
||||
Weight::from_parts(6_000_000, 1489)
|
||||
.saturating_add(RocksDbWeight::get().reads(1_u64))
|
||||
.saturating_add(RocksDbWeight::get().writes(1_u64))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
[package]
|
||||
name = "solochain-template-runtime"
|
||||
description = "A solochain runtime template built with Substrate, part of Polkadot Sdk. (polkadot v1.9.0)"
|
||||
version = "0.1.0"
|
||||
license = "MIT-0"
|
||||
authors.workspace = true
|
||||
homepage.workspace = true
|
||||
repository.workspace = true
|
||||
edition.workspace = true
|
||||
publish = false
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
targets = ["x86_64-unknown-linux-gnu"]
|
||||
|
||||
[dependencies]
|
||||
codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
|
||||
"derive",
|
||||
] }
|
||||
scale-info = { version = "2.10.0", default-features = false, features = [
|
||||
"derive",
|
||||
"serde",
|
||||
] }
|
||||
|
||||
# frame
|
||||
frame-support = { version = "31.0.0", default-features = false, features = ["experimental"] }
|
||||
frame-system = { version = "31.0.0", default-features = false }
|
||||
frame-try-runtime = { version = "0.37.0", default-features = false, optional = true }
|
||||
frame-executive = { version = "31.0.0", default-features = false }
|
||||
|
||||
# frame pallets
|
||||
pallet-aura = { version = "30.0.0", default-features = false }
|
||||
pallet-balances = { version = "31.0.0", default-features = false }
|
||||
pallet-grandpa = { version = "31.0.0", default-features = false }
|
||||
pallet-sudo = { version = "31.0.0", default-features = false }
|
||||
pallet-timestamp = { version = "30.0.0", default-features = false }
|
||||
pallet-transaction-payment = { version = "31.0.0", default-features = false }
|
||||
|
||||
# primitives
|
||||
sp-api = { version = "29.0.0", default-features = false }
|
||||
sp-block-builder = { version = "29.0.0", default-features = false }
|
||||
sp-consensus-aura = { version = "0.35.0", default-features = false, features = ["serde"] }
|
||||
sp-consensus-grandpa = { version = "16.0.0", default-features = false, features = ["serde"] }
|
||||
sp-core = { version = "31.0.0", default-features = false, features = ["serde"] }
|
||||
sp-inherents = { version = "29.0.0", default-features = false }
|
||||
sp-offchain = { version = "29.0.0", default-features = false }
|
||||
sp-runtime = { version = "34.0.0", default-features = false, features = ["serde"] }
|
||||
sp-session = { version = "30.0.0", default-features = false }
|
||||
sp-std = { version = "14.0.0", default-features = false }
|
||||
sp-storage = { version = "20.0.0", default-features = false }
|
||||
sp-transaction-pool = { version = "29.0.0", default-features = false }
|
||||
sp-version = { version = "32.0.0", default-features = false, features = ["serde"] }
|
||||
sp-genesis-builder = { version = "0.10.0", default-features = false }
|
||||
|
||||
# RPC related
|
||||
frame-system-rpc-runtime-api = { version = "29.0.0", default-features = false }
|
||||
pallet-transaction-payment-rpc-runtime-api = { version = "31.0.0", default-features = false }
|
||||
|
||||
# Used for runtime benchmarking
|
||||
frame-benchmarking = { version = "31.0.0", default-features = false, optional = true }
|
||||
frame-system-benchmarking = { version = "31.0.0", default-features = false, optional = true }
|
||||
|
||||
# The pallet in this template.
|
||||
pallet-template = { path = "../pallets/template", default-features = false, version = "0.1.0" }
|
||||
|
||||
[build-dependencies]
|
||||
substrate-wasm-builder = { version = "20.0.0", optional = true }
|
||||
|
||||
[features]
|
||||
default = ["std"]
|
||||
std = [
|
||||
"codec/std",
|
||||
"scale-info/std",
|
||||
|
||||
"frame-executive/std",
|
||||
"frame-support/std",
|
||||
"frame-system-benchmarking?/std",
|
||||
"frame-system-rpc-runtime-api/std",
|
||||
"frame-system/std",
|
||||
|
||||
"frame-benchmarking?/std",
|
||||
"frame-try-runtime?/std",
|
||||
|
||||
"pallet-aura/std",
|
||||
"pallet-balances/std",
|
||||
"pallet-grandpa/std",
|
||||
"pallet-sudo/std",
|
||||
"pallet-template/std",
|
||||
"pallet-timestamp/std",
|
||||
"pallet-transaction-payment-rpc-runtime-api/std",
|
||||
"pallet-transaction-payment/std",
|
||||
|
||||
"sp-api/std",
|
||||
"sp-block-builder/std",
|
||||
"sp-consensus-aura/std",
|
||||
"sp-consensus-grandpa/std",
|
||||
"sp-core/std",
|
||||
"sp-genesis-builder/std",
|
||||
"sp-inherents/std",
|
||||
"sp-offchain/std",
|
||||
"sp-runtime/std",
|
||||
"sp-session/std",
|
||||
"sp-std/std",
|
||||
"sp-storage/std",
|
||||
"sp-transaction-pool/std",
|
||||
"sp-version/std",
|
||||
|
||||
"substrate-wasm-builder",
|
||||
]
|
||||
|
||||
runtime-benchmarks = [
|
||||
"frame-benchmarking/runtime-benchmarks",
|
||||
"frame-support/runtime-benchmarks",
|
||||
"frame-system-benchmarking/runtime-benchmarks",
|
||||
"frame-system/runtime-benchmarks",
|
||||
"pallet-balances/runtime-benchmarks",
|
||||
"pallet-grandpa/runtime-benchmarks",
|
||||
"pallet-sudo/runtime-benchmarks",
|
||||
"pallet-template/runtime-benchmarks",
|
||||
"pallet-timestamp/runtime-benchmarks",
|
||||
"sp-runtime/runtime-benchmarks",
|
||||
]
|
||||
|
||||
try-runtime = [
|
||||
"frame-executive/try-runtime",
|
||||
"frame-support/try-runtime",
|
||||
"frame-system/try-runtime",
|
||||
"frame-try-runtime/try-runtime",
|
||||
"pallet-aura/try-runtime",
|
||||
"pallet-balances/try-runtime",
|
||||
"pallet-grandpa/try-runtime",
|
||||
"pallet-sudo/try-runtime",
|
||||
"pallet-template/try-runtime",
|
||||
"pallet-timestamp/try-runtime",
|
||||
"pallet-transaction-payment/try-runtime",
|
||||
"sp-runtime/try-runtime",
|
||||
]
|
||||
|
||||
experimental = ["pallet-aura/experimental"]
|
||||
@@ -0,0 +1,10 @@
|
||||
fn main() {
|
||||
#[cfg(feature = "std")]
|
||||
{
|
||||
substrate_wasm_builder::WasmBuilder::new()
|
||||
.with_current_project()
|
||||
.export_heap_base()
|
||||
.import_memory()
|
||||
.build();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,588 @@
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
|
||||
|
||||
use pallet_grandpa::AuthorityId as GrandpaId;
|
||||
use sp_api::impl_runtime_apis;
|
||||
use sp_consensus_aura::sr25519::AuthorityId as AuraId;
|
||||
use sp_core::{crypto::KeyTypeId, OpaqueMetadata};
|
||||
use sp_runtime::{
|
||||
create_runtime_str, generic, impl_opaque_keys,
|
||||
traits::{BlakeTwo256, Block as BlockT, IdentifyAccount, NumberFor, One, Verify},
|
||||
transaction_validity::{TransactionSource, TransactionValidity},
|
||||
ApplyExtrinsicResult, MultiSignature,
|
||||
};
|
||||
use sp_std::prelude::*;
|
||||
#[cfg(feature = "std")]
|
||||
use sp_version::NativeVersion;
|
||||
use sp_version::RuntimeVersion;
|
||||
|
||||
use frame_support::genesis_builder_helper::{build_config, create_default_config};
|
||||
pub use frame_support::{
|
||||
construct_runtime, derive_impl, parameter_types,
|
||||
traits::{
|
||||
ConstBool, ConstU128, ConstU32, ConstU64, ConstU8, KeyOwnerProofSystem, Randomness,
|
||||
StorageInfo,
|
||||
},
|
||||
weights::{
|
||||
constants::{
|
||||
BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_REF_TIME_PER_SECOND,
|
||||
},
|
||||
IdentityFee, Weight,
|
||||
},
|
||||
StorageValue,
|
||||
};
|
||||
pub use frame_system::Call as SystemCall;
|
||||
pub use pallet_balances::Call as BalancesCall;
|
||||
pub use pallet_timestamp::Call as TimestampCall;
|
||||
use pallet_transaction_payment::{ConstFeeMultiplier, CurrencyAdapter, Multiplier};
|
||||
#[cfg(any(feature = "std", test))]
|
||||
pub use sp_runtime::BuildStorage;
|
||||
pub use sp_runtime::{Perbill, Permill};
|
||||
|
||||
/// Import the template pallet.
|
||||
pub use pallet_template;
|
||||
|
||||
/// An index to a block.
|
||||
pub type BlockNumber = u32;
|
||||
|
||||
/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
|
||||
pub type Signature = MultiSignature;
|
||||
|
||||
/// Some way of identifying an account on the chain. We intentionally make it equivalent
|
||||
/// to the public key of our transaction signing scheme.
|
||||
pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
|
||||
|
||||
/// Balance of an account.
|
||||
pub type Balance = u128;
|
||||
|
||||
/// Index of a transaction in the chain.
|
||||
pub type Nonce = u32;
|
||||
|
||||
/// A hash of some data used by the chain.
|
||||
pub type Hash = sp_core::H256;
|
||||
|
||||
/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
|
||||
/// the specifics of the runtime. They can then be made to be agnostic over specific formats
|
||||
/// of data like extrinsics, allowing for them to continue syncing the network through upgrades
|
||||
/// to even the core data structures.
|
||||
pub mod opaque {
|
||||
use super::*;
|
||||
|
||||
pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
|
||||
|
||||
/// Opaque block header type.
|
||||
pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
|
||||
/// Opaque block type.
|
||||
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
|
||||
/// Opaque block identifier type.
|
||||
pub type BlockId = generic::BlockId<Block>;
|
||||
|
||||
impl_opaque_keys! {
|
||||
pub struct SessionKeys {
|
||||
pub aura: Aura,
|
||||
pub grandpa: Grandpa,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// To learn more about runtime versioning, see:
|
||||
// https://docs.substrate.io/main-docs/build/upgrade#runtime-versioning
|
||||
#[sp_version::runtime_version]
|
||||
pub const VERSION: RuntimeVersion = RuntimeVersion {
|
||||
spec_name: create_runtime_str!("solochain-template-runtime"),
|
||||
impl_name: create_runtime_str!("solochain-template-runtime"),
|
||||
authoring_version: 1,
|
||||
// The version of the runtime specification. A full node will not attempt to use its native
|
||||
// runtime in substitute for the on-chain Wasm runtime unless all of `spec_name`,
|
||||
// `spec_version`, and `authoring_version` are the same between Wasm and native.
|
||||
// This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
|
||||
// the compatible custom types.
|
||||
spec_version: 100,
|
||||
impl_version: 1,
|
||||
apis: RUNTIME_API_VERSIONS,
|
||||
transaction_version: 1,
|
||||
state_version: 1,
|
||||
};
|
||||
|
||||
/// This determines the average expected block time that we are targeting.
|
||||
/// Blocks will be produced at a minimum duration defined by `SLOT_DURATION`.
|
||||
/// `SLOT_DURATION` is picked up by `pallet_timestamp` which is in turn picked
|
||||
/// up by `pallet_aura` to implement `fn slot_duration()`.
|
||||
///
|
||||
/// Change this to adjust the block time.
|
||||
pub const MILLISECS_PER_BLOCK: u64 = 6000;
|
||||
|
||||
// NOTE: Currently it is not possible to change the slot duration after the chain has started.
|
||||
// Attempting to do so will brick block production.
|
||||
pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;
|
||||
|
||||
// Time is measured by number of blocks.
|
||||
pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
|
||||
pub const HOURS: BlockNumber = MINUTES * 60;
|
||||
pub const DAYS: BlockNumber = HOURS * 24;
|
||||
|
||||
/// The version information used to identify this runtime when compiled natively.
|
||||
#[cfg(feature = "std")]
|
||||
pub fn native_version() -> NativeVersion {
|
||||
NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
|
||||
}
|
||||
|
||||
const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
|
||||
|
||||
parameter_types! {
|
||||
pub const BlockHashCount: BlockNumber = 2400;
|
||||
pub const Version: RuntimeVersion = VERSION;
|
||||
/// We allow for 2 seconds of compute with a 6 second average block time.
|
||||
pub BlockWeights: frame_system::limits::BlockWeights =
|
||||
frame_system::limits::BlockWeights::with_sensible_defaults(
|
||||
Weight::from_parts(2u64 * WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
|
||||
NORMAL_DISPATCH_RATIO,
|
||||
);
|
||||
pub BlockLength: frame_system::limits::BlockLength = frame_system::limits::BlockLength
|
||||
::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
|
||||
pub const SS58Prefix: u8 = 42;
|
||||
}
|
||||
|
||||
/// The default types are being injected by [`derive_impl`](`frame_support::derive_impl`) from
|
||||
/// [`SoloChainDefaultConfig`](`struct@frame_system::config_preludes::SolochainDefaultConfig`),
|
||||
/// but overridden as needed.
|
||||
#[derive_impl(frame_system::config_preludes::SolochainDefaultConfig as frame_system::DefaultConfig)]
|
||||
impl frame_system::Config for Runtime {
|
||||
/// The block type for the runtime.
|
||||
type Block = Block;
|
||||
/// Block & extrinsics weights: base values and limits.
|
||||
type BlockWeights = BlockWeights;
|
||||
/// The maximum length of a block (in bytes).
|
||||
type BlockLength = BlockLength;
|
||||
/// The identifier used to distinguish between accounts.
|
||||
type AccountId = AccountId;
|
||||
/// The type for storing how many extrinsics an account has signed.
|
||||
type Nonce = Nonce;
|
||||
/// The type for hashing blocks and tries.
|
||||
type Hash = Hash;
|
||||
/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
|
||||
type BlockHashCount = BlockHashCount;
|
||||
/// The weight of database operations that the runtime can invoke.
|
||||
type DbWeight = RocksDbWeight;
|
||||
/// Version of the runtime.
|
||||
type Version = Version;
|
||||
/// The data to be stored in an account.
|
||||
type AccountData = pallet_balances::AccountData<Balance>;
|
||||
/// This is used as an identifier of the chain. 42 is the generic substrate prefix.
|
||||
type SS58Prefix = SS58Prefix;
|
||||
type MaxConsumers = frame_support::traits::ConstU32<16>;
|
||||
}
|
||||
|
||||
impl pallet_aura::Config for Runtime {
|
||||
type AuthorityId = AuraId;
|
||||
type DisabledValidators = ();
|
||||
type MaxAuthorities = ConstU32<32>;
|
||||
type AllowMultipleBlocksPerSlot = ConstBool<false>;
|
||||
|
||||
#[cfg(feature = "experimental")]
|
||||
type SlotDuration = pallet_aura::MinimumPeriodTimesTwo<Runtime>;
|
||||
}
|
||||
|
||||
impl pallet_grandpa::Config for Runtime {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
|
||||
type WeightInfo = ();
|
||||
type MaxAuthorities = ConstU32<32>;
|
||||
type MaxNominators = ConstU32<0>;
|
||||
type MaxSetIdSessionEntries = ConstU64<0>;
|
||||
|
||||
type KeyOwnerProof = sp_core::Void;
|
||||
type EquivocationReportSystem = ();
|
||||
}
|
||||
|
||||
impl pallet_timestamp::Config for Runtime {
|
||||
/// A timestamp: milliseconds since the unix epoch.
|
||||
type Moment = u64;
|
||||
type OnTimestampSet = Aura;
|
||||
type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>;
|
||||
type WeightInfo = ();
|
||||
}
|
||||
|
||||
/// Existential deposit.
|
||||
pub const EXISTENTIAL_DEPOSIT: u128 = 500;
|
||||
|
||||
impl pallet_balances::Config for Runtime {
|
||||
type MaxLocks = ConstU32<50>;
|
||||
type MaxReserves = ();
|
||||
type ReserveIdentifier = [u8; 8];
|
||||
/// The type for recording an account's balance.
|
||||
type Balance = Balance;
|
||||
/// The ubiquitous event type.
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type DustRemoval = ();
|
||||
type ExistentialDeposit = ConstU128<EXISTENTIAL_DEPOSIT>;
|
||||
type AccountStore = System;
|
||||
type WeightInfo = pallet_balances::weights::SubstrateWeight<Runtime>;
|
||||
type FreezeIdentifier = ();
|
||||
type MaxFreezes = ();
|
||||
type RuntimeHoldReason = ();
|
||||
type RuntimeFreezeReason = ();
|
||||
}
|
||||
|
||||
parameter_types! {
|
||||
pub FeeMultiplier: Multiplier = Multiplier::one();
|
||||
}
|
||||
|
||||
impl pallet_transaction_payment::Config for Runtime {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
|
||||
type OperationalFeeMultiplier = ConstU8<5>;
|
||||
type WeightToFee = IdentityFee<Balance>;
|
||||
type LengthToFee = IdentityFee<Balance>;
|
||||
type FeeMultiplierUpdate = ConstFeeMultiplier<FeeMultiplier>;
|
||||
}
|
||||
|
||||
impl pallet_sudo::Config for Runtime {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type RuntimeCall = RuntimeCall;
|
||||
type WeightInfo = pallet_sudo::weights::SubstrateWeight<Runtime>;
|
||||
}
|
||||
|
||||
/// Configure the pallet-template in pallets/template.
|
||||
impl pallet_template::Config for Runtime {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type WeightInfo = pallet_template::weights::SubstrateWeight<Runtime>;
|
||||
}
|
||||
|
||||
// Create the runtime by composing the FRAME pallets that were previously configured.
|
||||
#[frame_support::runtime]
|
||||
mod runtime {
|
||||
#[runtime::runtime]
|
||||
#[runtime::derive(
|
||||
RuntimeCall,
|
||||
RuntimeEvent,
|
||||
RuntimeError,
|
||||
RuntimeOrigin,
|
||||
RuntimeFreezeReason,
|
||||
RuntimeHoldReason,
|
||||
RuntimeSlashReason,
|
||||
RuntimeLockId,
|
||||
RuntimeTask
|
||||
)]
|
||||
pub struct Runtime;
|
||||
|
||||
#[runtime::pallet_index(0)]
|
||||
pub type System = frame_system;
|
||||
|
||||
#[runtime::pallet_index(1)]
|
||||
pub type Timestamp = pallet_timestamp;
|
||||
|
||||
#[runtime::pallet_index(2)]
|
||||
pub type Aura = pallet_aura;
|
||||
|
||||
#[runtime::pallet_index(3)]
|
||||
pub type Grandpa = pallet_grandpa;
|
||||
|
||||
#[runtime::pallet_index(4)]
|
||||
pub type Balances = pallet_balances;
|
||||
|
||||
#[runtime::pallet_index(5)]
|
||||
pub type TransactionPayment = pallet_transaction_payment;
|
||||
|
||||
#[runtime::pallet_index(6)]
|
||||
pub type Sudo = pallet_sudo;
|
||||
|
||||
// Include the custom logic from the pallet-template in the runtime.
|
||||
#[runtime::pallet_index(7)]
|
||||
pub type TemplateModule = pallet_template;
|
||||
}
|
||||
|
||||
/// The address format for describing accounts.
|
||||
pub type Address = sp_runtime::MultiAddress<AccountId, ()>;
|
||||
/// Block header type as expected by this runtime.
|
||||
pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
|
||||
/// Block type as expected by this runtime.
|
||||
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
|
||||
/// The SignedExtension to the basic transaction logic.
|
||||
pub type SignedExtra = (
|
||||
frame_system::CheckNonZeroSender<Runtime>,
|
||||
frame_system::CheckSpecVersion<Runtime>,
|
||||
frame_system::CheckTxVersion<Runtime>,
|
||||
frame_system::CheckGenesis<Runtime>,
|
||||
frame_system::CheckEra<Runtime>,
|
||||
frame_system::CheckNonce<Runtime>,
|
||||
frame_system::CheckWeight<Runtime>,
|
||||
pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
|
||||
);
|
||||
|
||||
/// All migrations of the runtime, aside from the ones declared in the pallets.
|
||||
///
|
||||
/// This can be a tuple of types, each implementing `OnRuntimeUpgrade`.
|
||||
#[allow(unused_parens)]
|
||||
type Migrations = ();
|
||||
|
||||
/// Unchecked extrinsic type as expected by this runtime.
|
||||
pub type UncheckedExtrinsic =
|
||||
generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
|
||||
/// The payload being signed in transactions.
|
||||
pub type SignedPayload = generic::SignedPayload<RuntimeCall, SignedExtra>;
|
||||
/// Executive: handles dispatch to the various modules.
|
||||
pub type Executive = frame_executive::Executive<
|
||||
Runtime,
|
||||
Block,
|
||||
frame_system::ChainContext<Runtime>,
|
||||
Runtime,
|
||||
AllPalletsWithSystem,
|
||||
Migrations,
|
||||
>;
|
||||
|
||||
#[cfg(feature = "runtime-benchmarks")]
|
||||
mod benches {
|
||||
frame_benchmarking::define_benchmarks!(
|
||||
[frame_benchmarking, BaselineBench::<Runtime>]
|
||||
[frame_system, SystemBench::<Runtime>]
|
||||
[pallet_balances, Balances]
|
||||
[pallet_timestamp, Timestamp]
|
||||
[pallet_sudo, Sudo]
|
||||
[pallet_template, TemplateModule]
|
||||
);
|
||||
}
|
||||
|
||||
impl_runtime_apis! {
|
||||
impl sp_api::Core<Block> for Runtime {
|
||||
fn version() -> RuntimeVersion {
|
||||
VERSION
|
||||
}
|
||||
|
||||
fn execute_block(block: Block) {
|
||||
Executive::execute_block(block);
|
||||
}
|
||||
|
||||
fn initialize_block(header: &<Block as BlockT>::Header) -> sp_runtime::ExtrinsicInclusionMode {
|
||||
Executive::initialize_block(header)
|
||||
}
|
||||
}
|
||||
|
||||
impl sp_api::Metadata<Block> for Runtime {
|
||||
fn metadata() -> OpaqueMetadata {
|
||||
OpaqueMetadata::new(Runtime::metadata().into())
|
||||
}
|
||||
|
||||
fn metadata_at_version(version: u32) -> Option<OpaqueMetadata> {
|
||||
Runtime::metadata_at_version(version)
|
||||
}
|
||||
|
||||
fn metadata_versions() -> sp_std::vec::Vec<u32> {
|
||||
Runtime::metadata_versions()
|
||||
}
|
||||
}
|
||||
|
||||
impl sp_block_builder::BlockBuilder<Block> for Runtime {
|
||||
fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
|
||||
Executive::apply_extrinsic(extrinsic)
|
||||
}
|
||||
|
||||
fn finalize_block() -> <Block as BlockT>::Header {
|
||||
Executive::finalize_block()
|
||||
}
|
||||
|
||||
fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
|
||||
data.create_extrinsics()
|
||||
}
|
||||
|
||||
fn check_inherents(
|
||||
block: Block,
|
||||
data: sp_inherents::InherentData,
|
||||
) -> sp_inherents::CheckInherentsResult {
|
||||
data.check_extrinsics(&block)
|
||||
}
|
||||
}
|
||||
|
||||
impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
|
||||
fn validate_transaction(
|
||||
source: TransactionSource,
|
||||
tx: <Block as BlockT>::Extrinsic,
|
||||
block_hash: <Block as BlockT>::Hash,
|
||||
) -> TransactionValidity {
|
||||
Executive::validate_transaction(source, tx, block_hash)
|
||||
}
|
||||
}
|
||||
|
||||
impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
|
||||
fn offchain_worker(header: &<Block as BlockT>::Header) {
|
||||
Executive::offchain_worker(header)
|
||||
}
|
||||
}
|
||||
|
||||
impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {
|
||||
fn slot_duration() -> sp_consensus_aura::SlotDuration {
|
||||
sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())
|
||||
}
|
||||
|
||||
fn authorities() -> Vec<AuraId> {
|
||||
Aura::authorities().into_inner()
|
||||
}
|
||||
}
|
||||
|
||||
impl sp_session::SessionKeys<Block> for Runtime {
|
||||
fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
|
||||
opaque::SessionKeys::generate(seed)
|
||||
}
|
||||
|
||||
fn decode_session_keys(
|
||||
encoded: Vec<u8>,
|
||||
) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {
|
||||
opaque::SessionKeys::decode_into_raw_public_keys(&encoded)
|
||||
}
|
||||
}
|
||||
|
||||
impl sp_consensus_grandpa::GrandpaApi<Block> for Runtime {
|
||||
fn grandpa_authorities() -> sp_consensus_grandpa::AuthorityList {
|
||||
Grandpa::grandpa_authorities()
|
||||
}
|
||||
|
||||
fn current_set_id() -> sp_consensus_grandpa::SetId {
|
||||
Grandpa::current_set_id()
|
||||
}
|
||||
|
||||
fn submit_report_equivocation_unsigned_extrinsic(
|
||||
_equivocation_proof: sp_consensus_grandpa::EquivocationProof<
|
||||
<Block as BlockT>::Hash,
|
||||
NumberFor<Block>,
|
||||
>,
|
||||
_key_owner_proof: sp_consensus_grandpa::OpaqueKeyOwnershipProof,
|
||||
) -> Option<()> {
|
||||
None
|
||||
}
|
||||
|
||||
fn generate_key_ownership_proof(
|
||||
_set_id: sp_consensus_grandpa::SetId,
|
||||
_authority_id: GrandpaId,
|
||||
) -> Option<sp_consensus_grandpa::OpaqueKeyOwnershipProof> {
|
||||
// NOTE: this is the only implementation possible since we've
|
||||
// defined our key owner proof type as a bottom type (i.e. a type
|
||||
// with no values).
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
|
||||
fn account_nonce(account: AccountId) -> Nonce {
|
||||
System::account_nonce(account)
|
||||
}
|
||||
}
|
||||
|
||||
impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {
|
||||
fn query_info(
|
||||
uxt: <Block as BlockT>::Extrinsic,
|
||||
len: u32,
|
||||
) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo<Balance> {
|
||||
TransactionPayment::query_info(uxt, len)
|
||||
}
|
||||
fn query_fee_details(
|
||||
uxt: <Block as BlockT>::Extrinsic,
|
||||
len: u32,
|
||||
) -> pallet_transaction_payment::FeeDetails<Balance> {
|
||||
TransactionPayment::query_fee_details(uxt, len)
|
||||
}
|
||||
fn query_weight_to_fee(weight: Weight) -> Balance {
|
||||
TransactionPayment::weight_to_fee(weight)
|
||||
}
|
||||
fn query_length_to_fee(length: u32) -> Balance {
|
||||
TransactionPayment::length_to_fee(length)
|
||||
}
|
||||
}
|
||||
|
||||
impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentCallApi<Block, Balance, RuntimeCall>
|
||||
for Runtime
|
||||
{
|
||||
fn query_call_info(
|
||||
call: RuntimeCall,
|
||||
len: u32,
|
||||
) -> pallet_transaction_payment::RuntimeDispatchInfo<Balance> {
|
||||
TransactionPayment::query_call_info(call, len)
|
||||
}
|
||||
fn query_call_fee_details(
|
||||
call: RuntimeCall,
|
||||
len: u32,
|
||||
) -> pallet_transaction_payment::FeeDetails<Balance> {
|
||||
TransactionPayment::query_call_fee_details(call, len)
|
||||
}
|
||||
fn query_weight_to_fee(weight: Weight) -> Balance {
|
||||
TransactionPayment::weight_to_fee(weight)
|
||||
}
|
||||
fn query_length_to_fee(length: u32) -> Balance {
|
||||
TransactionPayment::length_to_fee(length)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "runtime-benchmarks")]
|
||||
impl frame_benchmarking::Benchmark<Block> for Runtime {
|
||||
fn benchmark_metadata(extra: bool) -> (
|
||||
Vec<frame_benchmarking::BenchmarkList>,
|
||||
Vec<frame_support::traits::StorageInfo>,
|
||||
) {
|
||||
use frame_benchmarking::{baseline, Benchmarking, BenchmarkList};
|
||||
use frame_support::traits::StorageInfoTrait;
|
||||
use frame_system_benchmarking::Pallet as SystemBench;
|
||||
use baseline::Pallet as BaselineBench;
|
||||
|
||||
let mut list = Vec::<BenchmarkList>::new();
|
||||
list_benchmarks!(list, extra);
|
||||
|
||||
let storage_info = AllPalletsWithSystem::storage_info();
|
||||
|
||||
(list, storage_info)
|
||||
}
|
||||
|
||||
fn dispatch_benchmark(
|
||||
config: frame_benchmarking::BenchmarkConfig
|
||||
) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {
|
||||
use frame_benchmarking::{baseline, Benchmarking, BenchmarkBatch};
|
||||
use sp_storage::TrackedStorageKey;
|
||||
use frame_system_benchmarking::Pallet as SystemBench;
|
||||
use baseline::Pallet as BaselineBench;
|
||||
|
||||
impl frame_system_benchmarking::Config for Runtime {}
|
||||
impl baseline::Config for Runtime {}
|
||||
|
||||
use frame_support::traits::WhitelistedStorageKeys;
|
||||
let whitelist: Vec<TrackedStorageKey> = AllPalletsWithSystem::whitelisted_storage_keys();
|
||||
|
||||
let mut batches = Vec::<BenchmarkBatch>::new();
|
||||
let params = (&config, &whitelist);
|
||||
add_benchmarks!(params, batches);
|
||||
|
||||
Ok(batches)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "try-runtime")]
|
||||
impl frame_try_runtime::TryRuntime<Block> for Runtime {
|
||||
fn on_runtime_upgrade(checks: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) {
|
||||
// NOTE: intentional unwrap: we don't want to propagate the error backwards, and want to
|
||||
// have a backtrace here. If any of the pre/post migration checks fail, we shall stop
|
||||
// right here and right now.
|
||||
let weight = Executive::try_runtime_upgrade(checks).unwrap();
|
||||
(weight, BlockWeights::get().max_block)
|
||||
}
|
||||
|
||||
fn execute_block(
|
||||
block: Block,
|
||||
state_root_check: bool,
|
||||
signature_check: bool,
|
||||
select: frame_try_runtime::TryStateSelect
|
||||
) -> Weight {
|
||||
// NOTE: intentional unwrap: we don't want to propagate the error backwards, and want to
|
||||
// have a backtrace here.
|
||||
Executive::try_execute_block(block, state_root_check, signature_check, select).expect("execute-block failed")
|
||||
}
|
||||
}
|
||||
|
||||
impl sp_genesis_builder::GenesisBuilder<Block> for Runtime {
|
||||
fn create_default_config() -> Vec<u8> {
|
||||
create_default_config::<RuntimeGenesisConfig>()
|
||||
}
|
||||
|
||||
fn build_config(config: Vec<u8>) -> sp_genesis_builder::Result {
|
||||
build_config::<RuntimeGenesisConfig>(config)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user