文件列表:

.cargo (0, 2023-02-12)
.cargo\config.toml (194, 2023-02-12)
.devcontainer (0, 2023-02-12)
.devcontainer\devcontainer.json (629, 2023-02-12)
.envrc (144, 2023-02-12)
.release-please-manifest.json (305, 2023-02-12)
.renovaterc.json (1194, 2023-02-12)
.vscode (0, 2023-02-12)
.vscode\launch.json (2435, 2023-02-12)
.vscode\tasks.json (1068, 2023-02-12)
CHANGELOG.md (13505, 2023-02-12)
CODE_OF_CONDUCT.md (5222, 2023-02-12)
Cargo.lock (200891, 2023-02-12)
Cargo.toml (325, 2023-02-12)
LICENSE (11340, 2023-02-12)
docker-compose.yml (474, 2023-02-12)
docs (0, 2023-02-12)
docs\genesis-data.md (123, 2023-02-12)
docs\rust-setup.md (8163, 2023-02-12)
node (0, 2023-02-12)
node\CHANGELOG.md (2320, 2023-02-12)
node\Cargo.toml (5361, 2023-02-12)
node\build.rs (156, 2023-02-12)
node\src (0, 2023-02-12)
node\src\benchmarking.rs (5523, 2023-02-12)
node\src\chain_spec.rs (6176, 2023-02-12)
node\src\cli.rs (1281, 2023-02-12)
node\src\command.rs (7099, 2023-02-12)
... ...

# FinalBiome Node [](https://github.com/finalbiome/finalbiome-node/actions/workflows/check.yml) A node of the FinalBiome Network. ## Development ### Rust Setup First, complete the [basic Rust setup instructions](./docs/rust-setup.md). ### Run Use Rust's native `cargo` command to build and launch the template node: ```sh cargo run --release -- --dev ``` ### Build The `cargo run` command will perform an initial build. Use the following command to build the node without launching it: ```sh cargo build --release ``` ### Embedded Docs Once the project has been built, the following command can be used to explore all parameters and subcommands: ```sh ./target/release/finalbiome-node -h ``` ## Run The provided `cargo run` command will launch a temporary node and its state will be discarded after you terminate the process. After the project has been built, there are other ways to launch the node. ### Single-Node Development Chain This command will start the single-node development chain with non-persistent state: ```bash ./target/release/finalbiome-node --dev ``` Purge the development chain's state: ```bash ./target/release/finalbiome-node purge-chain --dev ``` Start the development chain with detailed logging: ```bash RUST_BACKTRACE=1 ./target/release/finalbiome-node -ldebug --dev ``` > Development chain means that the state of our chain will be in a tmp folder while the nodes are > running. Also, **alice** account will be authority and sudo account as declared in the > [genesis state](https://github.com/substrate-developer-hub/substrate-finalbiome-node/blob/main/node/src/chain_spec.rs#L49). > At the same time the following accounts will be pre-funded: > - Alice > - Bob > - Alice//stash > - Bob//stash In case of being interested in maintaining the chain' state between runs a base path must be added so the db can be stored in the provided folder instead of a temporal one. We could use this folder to store different chain databases, as a different folder will be created per different chain that is ran. The following commands shows how to use a newly created folder as our db base path. ```bash // 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/finalbiome-node --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 Once the node template is running locally, you can connect it with **Polkadot-JS Apps** front-end to interact with your chain. [Click here](https://polkadot.js.org/apps/#/explorer?rpc=ws://localhost:9944) connecting the Apps to your local node template. ### Multi-Node Local Testnet If you want to see the multi-node consensus algorithm in action, refer to our [Simulate a network tutorial](https://docs.substrate.io/tutorials/get-started/simulate-network/). ## Template Structure The project 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/main-docs/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/main-docs/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, which 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/main-docs/fundamentals/consensus/#finalization-and-forks) and other [consensus mechanisms](https://docs.substrate.io/main-docs/fundamentals/consensus/#default-consensus-models) such as Aura for block authoring and GRANDPA for finality. After the node has been [built](#build), refer to the embedded documentation to learn more about the capabilities and configuration parameters that it exposes: ```shell ./target/release/finalbiome-node --help ``` ### Runtime In Substrate, the terms "runtime" and "state transition function" are analogous - they 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/main-docs/fundamentals/runtime-intro/#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://crates.parity.io/frame_support/macro.construct_runtime.html) macro, which is part of the core FRAME Support [system](https://docs.substrate.io/reference/frame-pallets/#system-pallets) library. ### Pallets The runtime in this project is constructed using many FRAME pallets that ship with the [core Substrate repository](https://github.com/paritytech/substrate/tree/master/frame) and a template pallet that is [defined in the `pallets`](./pallets/template/src/lib.rs) directory. A FRAME pallet is compromised of a number of blockchain primitives: - Storage: FRAME defines a rich set of powerful [storage abstractions](https://docs.substrate.io/main-docs/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 and errors](https://docs.substrate.io/main-docs/build/events-errors/) to notify users of important changes in the runtime. - Errors: When a dispatchable fails, it returns an error. - Config: The `Config` configuration interface is used to define the types and parameters upon which a FRAME pallet depends. ### Run in Docker First, install [Docker](https://docs.docker.com/get-docker/) and [Docker Compose](https://docs.docker.com/compose/install/). Then run the following command to start a single node development chain. ```bash ./scripts/docker_run.sh ``` This command will firstly compile your code, and then start a local development network. You can also replace the default command (`cargo build --release && ./target/release/finalbiome-node --dev --ws-external`) by appending your own. A few useful ones are as follow. ```bash # Run Substrate node without re-compiling ./scripts/docker_run.sh ./target/release/finalbiome-node --dev --ws-external # Purge the local dev chain ./scripts/docker_run.sh ./target/release/finalbiome-node purge-chain --dev # Check whether the code is compilable ./scripts/docker_run.sh cargo check ```

近期下载者：

相关文件：

评论：[我要评论] [举报此文件]

收藏者：