feat: Rebrand Polkadot/Substrate references to PezkuwiChain
This commit systematically rebrands various references from Parity Technologies' Polkadot/Substrate ecosystem to PezkuwiChain within the kurdistan-sdk. Key changes include: - Updated external repository URLs (zombienet-sdk, parity-db, parity-scale-codec, wasm-instrument) to point to pezkuwichain forks. - Modified internal documentation and code comments to reflect PezkuwiChain naming and structure. - Replaced direct references to with or specific paths within the for XCM, Pezkuwi, and other modules. - Cleaned up deprecated issue and PR references in various and files, particularly in and modules. - Adjusted image and logo URLs in documentation to point to PezkuwiChain assets. - Removed or rephrased comments related to external Polkadot/Substrate PRs and issues. This is a significant step towards fully customizing the SDK for the PezkuwiChain ecosystem.
This commit is contained in:
@@ -0,0 +1,287 @@
|
||||
// This file is part of Pezcumulus.
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
use codec::Encode;
|
||||
use pezsc_block_builder::BlockBuilderBuilder;
|
||||
|
||||
use crate::{construct_extrinsic, Client as TestClient};
|
||||
use cumulus_pallet_teyrchain_system::teyrchain_inherent::{
|
||||
BasicTeyrchainInherentData, InboundMessagesData,
|
||||
};
|
||||
use cumulus_primitives_core::{relay_chain::AccountId, PersistedValidationData};
|
||||
use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder;
|
||||
use cumulus_test_runtime::{
|
||||
BalancesCall, GluttonCall, NodeBlock, SudoCall, UncheckedExtrinsic, WASM_BINARY,
|
||||
};
|
||||
use pezframe_system_rpc_runtime_api::AccountNonceApi;
|
||||
use pezkuwi_primitives::HeadData;
|
||||
use pezsc_client_api::UsageProvider;
|
||||
use pezsc_consensus::{
|
||||
block_import::{BlockImportParams, ForkChoiceStrategy},
|
||||
BlockImport, ImportResult, StateAction,
|
||||
};
|
||||
use pezsc_executor::DEFAULT_HEAP_ALLOC_STRATEGY;
|
||||
use pezsc_executor_common::runtime_blob::RuntimeBlob;
|
||||
use pezsp_api::ProvideRuntimeApi;
|
||||
use pezsp_blockchain::{ApplyExtrinsicFailed::Validity, Error::ApplyExtrinsicFailed};
|
||||
use pezsp_consensus::BlockOrigin;
|
||||
use pezsp_core::{sr25519, Pair};
|
||||
use pezsp_keyring::Sr25519Keyring::Alice;
|
||||
use pezsp_runtime::{
|
||||
transaction_validity::{InvalidTransaction, TransactionValidityError},
|
||||
AccountId32, FixedU64, MultiAddress, OpaqueExtrinsic,
|
||||
};
|
||||
|
||||
/// Accounts to use for transfer transactions. Enough for 5000 transactions.
|
||||
const NUM_ACCOUNTS: usize = 10000;
|
||||
|
||||
/// Create accounts by deriving from Alice
|
||||
pub fn create_benchmark_accounts() -> (Vec<sr25519::Pair>, Vec<sr25519::Pair>, Vec<AccountId32>) {
|
||||
let accounts: Vec<sr25519::Pair> = (0..NUM_ACCOUNTS)
|
||||
.map(|idx| {
|
||||
Pair::from_string(&format!("{}/{}", Alice.to_seed(), idx), None)
|
||||
.expect("Creates account pair")
|
||||
})
|
||||
.collect();
|
||||
let account_ids = accounts
|
||||
.iter()
|
||||
.map(|account| AccountId::from(account.public()))
|
||||
.collect::<Vec<AccountId>>();
|
||||
let (src_accounts, dst_accounts) = accounts.split_at(NUM_ACCOUNTS / 2);
|
||||
(src_accounts.to_vec(), dst_accounts.to_vec(), account_ids)
|
||||
}
|
||||
|
||||
/// Create a timestamp extrinsic ahead by `MinimumPeriod` of the last known timestamp
|
||||
pub fn extrinsic_set_time(client: &TestClient) -> OpaqueExtrinsic {
|
||||
let best_number = client.usage_info().chain.best_number;
|
||||
|
||||
let timestamp = best_number as u64 * cumulus_test_runtime::MinimumPeriod::get();
|
||||
cumulus_test_runtime::UncheckedExtrinsic::new_bare(
|
||||
cumulus_test_runtime::RuntimeCall::Timestamp(pezpallet_timestamp::Call::set {
|
||||
now: timestamp,
|
||||
}),
|
||||
)
|
||||
.into()
|
||||
}
|
||||
|
||||
/// Create a set validation data extrinsic
|
||||
pub fn extrinsic_set_validation_data(
|
||||
parent_header: cumulus_test_runtime::Header,
|
||||
) -> OpaqueExtrinsic {
|
||||
let parent_head = HeadData(parent_header.encode());
|
||||
let sproof_builder = RelayStateSproofBuilder {
|
||||
para_id: cumulus_test_runtime::TEYRCHAIN_ID.into(),
|
||||
included_para_head: parent_head.clone().into(),
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
let (relay_parent_storage_root, relay_chain_state) = sproof_builder.into_state_root_and_proof();
|
||||
let data = BasicTeyrchainInherentData {
|
||||
validation_data: PersistedValidationData {
|
||||
parent_head,
|
||||
relay_parent_number: 10,
|
||||
relay_parent_storage_root,
|
||||
max_pov_size: 10000,
|
||||
},
|
||||
relay_chain_state,
|
||||
relay_parent_descendants: Default::default(),
|
||||
collator_peer_id: None,
|
||||
};
|
||||
|
||||
let inbound_messages_data = InboundMessagesData {
|
||||
downward_messages: Default::default(),
|
||||
horizontal_messages: Default::default(),
|
||||
};
|
||||
|
||||
cumulus_test_runtime::UncheckedExtrinsic::new_bare(
|
||||
cumulus_test_runtime::RuntimeCall::TeyrchainSystem(
|
||||
cumulus_pallet_teyrchain_system::Call::set_validation_data {
|
||||
data,
|
||||
inbound_messages_data,
|
||||
},
|
||||
),
|
||||
)
|
||||
.into()
|
||||
}
|
||||
|
||||
/// Import block into the given client and make sure the import was successful
|
||||
pub async fn import_block(client: &TestClient, block: &NodeBlock, import_existing: bool) {
|
||||
let mut params = BlockImportParams::new(BlockOrigin::File, block.header.clone());
|
||||
params.body = Some(block.extrinsics.clone());
|
||||
params.state_action = StateAction::Execute;
|
||||
params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
|
||||
params.import_existing = import_existing;
|
||||
let import_result = client.import_block(params).await;
|
||||
assert!(
|
||||
matches!(import_result, Ok(ImportResult::Imported(_))),
|
||||
"Unexpected block import result: {:?}!",
|
||||
import_result
|
||||
);
|
||||
}
|
||||
|
||||
/// Creates transfer extrinsics pair-wise from elements of `src_accounts` to `dst_accounts`.
|
||||
pub fn create_benchmarking_transfer_extrinsics(
|
||||
client: &TestClient,
|
||||
src_accounts: &[sr25519::Pair],
|
||||
dst_accounts: &[sr25519::Pair],
|
||||
) -> (usize, Vec<OpaqueExtrinsic>) {
|
||||
let chain = client.usage_info().chain;
|
||||
// Add as many transfer extrinsics as possible into a single block.
|
||||
let mut block_builder = BlockBuilderBuilder::new(client)
|
||||
.on_parent_block(chain.best_hash)
|
||||
.with_parent_block_number(chain.best_number)
|
||||
.build()
|
||||
.expect("Creates block builder");
|
||||
let mut max_transfer_count = 0;
|
||||
let mut extrinsics = Vec::new();
|
||||
// Every block needs one timestamp extrinsic.
|
||||
let time_ext = extrinsic_set_time(client);
|
||||
extrinsics.push(time_ext);
|
||||
|
||||
// Every block needs tone set_validation_data extrinsic.
|
||||
let parent_hash = client.usage_info().chain.best_hash;
|
||||
let parent_header = client.header(parent_hash).expect("Just fetched this hash.").unwrap();
|
||||
let set_validation_data_extrinsic = extrinsic_set_validation_data(parent_header);
|
||||
extrinsics.push(set_validation_data_extrinsic);
|
||||
|
||||
for (src, dst) in src_accounts.iter().zip(dst_accounts.iter()) {
|
||||
let extrinsic: UncheckedExtrinsic = construct_extrinsic(
|
||||
client,
|
||||
BalancesCall::transfer_keep_alive {
|
||||
dest: MultiAddress::Id(AccountId::from(dst.public())),
|
||||
value: 10000,
|
||||
},
|
||||
src.clone(),
|
||||
Some(0),
|
||||
);
|
||||
|
||||
match block_builder.push(extrinsic.clone().into()) {
|
||||
Ok(_) => {},
|
||||
Err(ApplyExtrinsicFailed(Validity(TransactionValidityError::Invalid(
|
||||
InvalidTransaction::ExhaustsResources,
|
||||
)))) => break,
|
||||
Err(error) => panic!("{}", error),
|
||||
}
|
||||
|
||||
extrinsics.push(extrinsic.into());
|
||||
max_transfer_count += 1;
|
||||
}
|
||||
|
||||
if max_transfer_count >= src_accounts.len() {
|
||||
panic!("Block could fit more transfers, increase NUM_ACCOUNTS to generate more accounts.");
|
||||
}
|
||||
|
||||
(max_transfer_count, extrinsics)
|
||||
}
|
||||
|
||||
/// Prepare pezcumulus test runtime for execution
|
||||
pub fn get_wasm_module() -> Box<dyn pezsc_executor_common::wasm_runtime::WasmModule> {
|
||||
let blob = RuntimeBlob::uncompress_if_needed(
|
||||
WASM_BINARY.expect("You need to build the WASM binaries to run the benchmark!"),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let config = pezsc_executor_wasmtime::Config {
|
||||
allow_missing_func_imports: true,
|
||||
cache_path: None,
|
||||
semantics: pezsc_executor_wasmtime::Semantics {
|
||||
heap_alloc_strategy: DEFAULT_HEAP_ALLOC_STRATEGY,
|
||||
instantiation_strategy: pezsc_executor::WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
|
||||
deterministic_stack_limit: None,
|
||||
canonicalize_nans: false,
|
||||
parallel_compilation: true,
|
||||
wasm_multi_value: false,
|
||||
wasm_bulk_memory: false,
|
||||
wasm_reference_types: false,
|
||||
wasm_simd: false,
|
||||
},
|
||||
};
|
||||
Box::new(
|
||||
pezsc_executor_wasmtime::create_runtime::<pezsp_io::BizinikiwiHostFunctions>(blob, config)
|
||||
.expect("Unable to create wasm module."),
|
||||
)
|
||||
}
|
||||
|
||||
/// Create a block containing setup extrinsics for the glutton pallet.
|
||||
pub fn set_glutton_parameters(
|
||||
client: &TestClient,
|
||||
initialize: bool,
|
||||
compute_ratio: &FixedU64,
|
||||
storage_ratio: &FixedU64,
|
||||
) -> NodeBlock {
|
||||
let parent_hash = client.usage_info().chain.best_hash;
|
||||
let parent_header = client.header(parent_hash).expect("Just fetched this hash.").unwrap();
|
||||
|
||||
let mut last_nonce = client
|
||||
.runtime_api()
|
||||
.account_nonce(parent_hash, Alice.into())
|
||||
.expect("Fetching account nonce works; qed");
|
||||
|
||||
let mut extrinsics = vec![];
|
||||
if initialize {
|
||||
// Initialize the pallet
|
||||
extrinsics.push(construct_extrinsic(
|
||||
client,
|
||||
SudoCall::sudo {
|
||||
call: Box::new(
|
||||
GluttonCall::initialize_pallet { new_count: 5000, witness_count: None }.into(),
|
||||
),
|
||||
},
|
||||
Alice.into(),
|
||||
Some(last_nonce),
|
||||
));
|
||||
last_nonce += 1;
|
||||
}
|
||||
|
||||
// Set compute weight that should be consumed per block
|
||||
let set_compute = construct_extrinsic(
|
||||
client,
|
||||
SudoCall::sudo {
|
||||
call: Box::new(GluttonCall::set_compute { compute: *compute_ratio }.into()),
|
||||
},
|
||||
Alice.into(),
|
||||
Some(last_nonce),
|
||||
);
|
||||
last_nonce += 1;
|
||||
extrinsics.push(set_compute);
|
||||
|
||||
// Set storage weight that should be consumed per block
|
||||
let set_storage = construct_extrinsic(
|
||||
client,
|
||||
SudoCall::sudo {
|
||||
call: Box::new(GluttonCall::set_storage { storage: *storage_ratio }.into()),
|
||||
},
|
||||
Alice.into(),
|
||||
Some(last_nonce),
|
||||
);
|
||||
extrinsics.push(set_storage);
|
||||
let chain = client.usage_info().chain;
|
||||
|
||||
let mut block_builder = BlockBuilderBuilder::new(client)
|
||||
.on_parent_block(chain.best_hash)
|
||||
.with_parent_block_number(chain.best_number)
|
||||
.build()
|
||||
.unwrap();
|
||||
block_builder.push(extrinsic_set_time(client)).unwrap();
|
||||
block_builder.push(extrinsic_set_validation_data(parent_header)).unwrap();
|
||||
for extrinsic in extrinsics {
|
||||
block_builder.push(extrinsic.into()).unwrap();
|
||||
}
|
||||
|
||||
let built_block = block_builder.build().unwrap();
|
||||
built_block.block
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// This file is part of Pezcumulus.
|
||||
|
||||
// Pezcumulus is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Pezcumulus is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Pezcumulus. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#![allow(missing_docs)]
|
||||
|
||||
use cumulus_client_service::TeyrchainHostFunctions;
|
||||
use cumulus_primitives_core::ParaId;
|
||||
use cumulus_test_runtime::AccountId;
|
||||
use pezsc_chain_spec::GenesisConfigBuilderRuntimeCaller;
|
||||
use pezsc_service::{ChainType, GenericChainSpec};
|
||||
use serde_json::json;
|
||||
|
||||
/// Get the chain spec for a specific teyrchain ID.
|
||||
/// The given accounts are initialized with funds in addition
|
||||
/// to the default known accounts.
|
||||
pub fn get_chain_spec_with_extra_endowed(
|
||||
id: Option<ParaId>,
|
||||
extra_endowed_accounts: Vec<AccountId>,
|
||||
code: &[u8],
|
||||
) -> GenericChainSpec {
|
||||
let runtime_caller = GenesisConfigBuilderRuntimeCaller::<TeyrchainHostFunctions>::new(code);
|
||||
let mut development_preset = runtime_caller
|
||||
.get_named_preset(Some(&pezsp_genesis_builder::LOCAL_TESTNET_RUNTIME_PRESET.to_string()))
|
||||
.expect("development preset is available on test runtime; qed");
|
||||
|
||||
// Extract existing balances
|
||||
let existing_balances = development_preset
|
||||
.get("balances")
|
||||
.and_then(|b| b.get("balances"))
|
||||
.and_then(|b| b.as_array())
|
||||
.cloned()
|
||||
.unwrap_or_default();
|
||||
|
||||
// Create new balances by combining existing and extra accounts
|
||||
let mut all_balances = existing_balances;
|
||||
all_balances.extend(extra_endowed_accounts.into_iter().map(|a| json!([a, 1u64 << 60])));
|
||||
|
||||
let mut patch_json = json!({
|
||||
"balances": {
|
||||
"balances": all_balances,
|
||||
},
|
||||
});
|
||||
|
||||
if let Some(id) = id {
|
||||
// Merge teyrchain ID if given, otherwise use the one from the preset.
|
||||
pezsc_chain_spec::json_merge(
|
||||
&mut patch_json,
|
||||
json!({
|
||||
"teyrchainInfo": {
|
||||
"teyrchainId": id,
|
||||
},
|
||||
|
||||
}),
|
||||
);
|
||||
};
|
||||
|
||||
pezsc_chain_spec::json_merge(&mut development_preset, patch_json.into());
|
||||
|
||||
GenericChainSpec::builder(code, None)
|
||||
.with_name("Local Testnet")
|
||||
.with_id(pezsp_genesis_builder::LOCAL_TESTNET_RUNTIME_PRESET)
|
||||
.with_chain_type(ChainType::Local)
|
||||
.with_genesis_config_patch(development_preset)
|
||||
.build()
|
||||
}
|
||||
|
||||
/// Get the chain spec for a specific teyrchain ID.
|
||||
pub fn get_chain_spec(id: Option<ParaId>) -> GenericChainSpec {
|
||||
get_chain_spec_with_extra_endowed(
|
||||
id,
|
||||
Default::default(),
|
||||
cumulus_test_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"),
|
||||
)
|
||||
}
|
||||
|
||||
/// Get the chain spec for a specific teyrchain ID.
|
||||
pub fn get_elastic_scaling_chain_spec(id: Option<ParaId>) -> GenericChainSpec {
|
||||
get_chain_spec_with_extra_endowed(
|
||||
id,
|
||||
Default::default(),
|
||||
cumulus_test_runtime::elastic_scaling::WASM_BINARY
|
||||
.expect("WASM binary was not built, please build it!"),
|
||||
)
|
||||
}
|
||||
|
||||
pub fn get_relay_parent_offset_chain_spec(id: Option<ParaId>) -> GenericChainSpec {
|
||||
get_chain_spec_with_extra_endowed(
|
||||
id,
|
||||
Default::default(),
|
||||
cumulus_test_runtime::relay_parent_offset::WASM_BINARY
|
||||
.expect("WASM binary was not built, please build it!"),
|
||||
)
|
||||
}
|
||||
|
||||
/// Get the chain spec for a specific teyrchain ID.
|
||||
pub fn get_elastic_scaling_500ms_chain_spec(id: Option<ParaId>) -> GenericChainSpec {
|
||||
get_chain_spec_with_extra_endowed(
|
||||
id,
|
||||
Default::default(),
|
||||
cumulus_test_runtime::elastic_scaling_500ms::WASM_BINARY
|
||||
.expect("WASM binary was not built, please build it!"),
|
||||
)
|
||||
}
|
||||
|
||||
/// Get the chain spec for a specific teyrchain ID.
|
||||
pub fn get_elastic_scaling_mvp_chain_spec(id: Option<ParaId>) -> GenericChainSpec {
|
||||
get_chain_spec_with_extra_endowed(
|
||||
id,
|
||||
Default::default(),
|
||||
cumulus_test_runtime::elastic_scaling_mvp::WASM_BINARY
|
||||
.expect("WASM binary was not built, please build it!"),
|
||||
)
|
||||
}
|
||||
|
||||
pub fn get_elastic_scaling_multi_block_slot_chain_spec(id: Option<ParaId>) -> GenericChainSpec {
|
||||
get_chain_spec_with_extra_endowed(
|
||||
id,
|
||||
Default::default(),
|
||||
cumulus_test_runtime::elastic_scaling_multi_block_slot::WASM_BINARY
|
||||
.expect("WASM binary was not built, please build it!"),
|
||||
)
|
||||
}
|
||||
|
||||
pub fn get_sync_backing_chain_spec(id: Option<ParaId>) -> GenericChainSpec {
|
||||
get_chain_spec_with_extra_endowed(
|
||||
id,
|
||||
Default::default(),
|
||||
cumulus_test_runtime::sync_backing::WASM_BINARY
|
||||
.expect("WASM binary was not built, please build it!"),
|
||||
)
|
||||
}
|
||||
|
||||
pub fn get_async_backing_chain_spec(id: Option<ParaId>) -> GenericChainSpec {
|
||||
get_chain_spec_with_extra_endowed(
|
||||
id,
|
||||
Default::default(),
|
||||
cumulus_test_runtime::async_backing::WASM_BINARY
|
||||
.expect("WASM binary was not built, please build it!"),
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,374 @@
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// This file is part of Pezcumulus.
|
||||
|
||||
// Pezcumulus is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Pezcumulus is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Pezcumulus. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
use clap::ValueEnum;
|
||||
use cumulus_client_cli::{ExportGenesisHeadCommand, ExportGenesisWasmCommand};
|
||||
use pezkuwi_service::{ChainSpec, ParaId, PrometheusConfig};
|
||||
use pezsc_cli::{
|
||||
CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams, NetworkParams,
|
||||
Result as CliResult, RpcEndpoint, SharedParams, BizinikiwiCli,
|
||||
};
|
||||
use pezsc_service::BasePath;
|
||||
use std::{
|
||||
fmt::{Display, Formatter},
|
||||
path::PathBuf,
|
||||
};
|
||||
|
||||
#[derive(Debug, clap::Parser)]
|
||||
#[command(
|
||||
version,
|
||||
propagate_version = true,
|
||||
args_conflicts_with_subcommands = true,
|
||||
subcommand_negates_reqs = true
|
||||
)]
|
||||
pub struct TestCollatorCli {
|
||||
#[command(subcommand)]
|
||||
pub subcommand: Option<Subcommand>,
|
||||
|
||||
#[command(flatten)]
|
||||
pub run: cumulus_client_cli::RunCmd,
|
||||
|
||||
/// Relay chain arguments
|
||||
#[arg(raw = true)]
|
||||
pub relaychain_args: Vec<String>,
|
||||
|
||||
#[arg(long)]
|
||||
pub disable_block_announcements: bool,
|
||||
|
||||
#[arg(long)]
|
||||
pub fail_pov_recovery: bool,
|
||||
|
||||
/// Authoring style to use.
|
||||
#[arg(long, default_value_t = AuthoringPolicy::Lookahead)]
|
||||
pub authoring: AuthoringPolicy,
|
||||
}
|
||||
|
||||
/// Collator implementation to use.
|
||||
#[derive(PartialEq, Debug, ValueEnum, Clone, Copy)]
|
||||
pub enum AuthoringPolicy {
|
||||
/// Use the lookahead collator. Builds blocks once per relay chain block,
|
||||
/// builds on relay chain forks.
|
||||
Lookahead,
|
||||
/// Use the slot-based collator which can handle elastic-scaling. Builds blocks based on time
|
||||
/// and can utilize multiple cores, always builds on the best relay chain block available.
|
||||
SlotBased,
|
||||
}
|
||||
|
||||
impl Display for AuthoringPolicy {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
AuthoringPolicy::Lookahead => write!(f, "lookahead"),
|
||||
AuthoringPolicy::SlotBased => write!(f, "slot-based"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, clap::Subcommand)]
|
||||
pub enum Subcommand {
|
||||
/// Build a chain specification.
|
||||
/// DEPRECATED: `build-spec` command will be removed after 1/04/2026. Use `export-chain-spec`
|
||||
/// command instead.
|
||||
#[deprecated(
|
||||
note = "build-spec command will be removed after 1/04/2026. Use export-chain-spec command instead"
|
||||
)]
|
||||
BuildSpec(pezsc_cli::BuildSpecCmd),
|
||||
|
||||
/// Export the chain specification.
|
||||
ExportChainSpec(pezsc_cli::ExportChainSpecCmd),
|
||||
|
||||
/// Export the genesis state of the teyrchain.
|
||||
#[command(alias = "export-genesis-state")]
|
||||
ExportGenesisHead(ExportGenesisHeadCommand),
|
||||
|
||||
/// Export the genesis wasm of the teyrchain.
|
||||
ExportGenesisWasm(ExportGenesisWasmCommand),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct RelayChainCli {
|
||||
/// The actual relay chain cli object.
|
||||
pub base: pezkuwi_cli::RunCmd,
|
||||
|
||||
/// Optional chain id that should be passed to the relay chain.
|
||||
pub chain_id: Option<String>,
|
||||
|
||||
/// The base path that should be used by the relay chain.
|
||||
pub base_path: Option<PathBuf>,
|
||||
}
|
||||
|
||||
impl RelayChainCli {
|
||||
/// Parse the relay chain CLI parameters using the para chain `Configuration`.
|
||||
pub fn new<'a>(
|
||||
para_config: &pezsc_service::Configuration,
|
||||
relay_chain_args: impl Iterator<Item = &'a String>,
|
||||
) -> Self {
|
||||
let base_path = para_config.base_path.path().join("pezkuwi");
|
||||
Self {
|
||||
base_path: Some(base_path),
|
||||
chain_id: None,
|
||||
base: clap::Parser::parse_from(relay_chain_args),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl CliConfiguration<Self> for RelayChainCli {
|
||||
fn shared_params(&self) -> &SharedParams {
|
||||
self.base.base.shared_params()
|
||||
}
|
||||
|
||||
fn import_params(&self) -> Option<&ImportParams> {
|
||||
self.base.base.import_params()
|
||||
}
|
||||
|
||||
fn network_params(&self) -> Option<&NetworkParams> {
|
||||
self.base.base.network_params()
|
||||
}
|
||||
|
||||
fn keystore_params(&self) -> Option<&KeystoreParams> {
|
||||
self.base.base.keystore_params()
|
||||
}
|
||||
|
||||
fn base_path(&self) -> CliResult<Option<BasePath>> {
|
||||
Ok(self
|
||||
.shared_params()
|
||||
.base_path()?
|
||||
.or_else(|| self.base_path.clone().map(Into::into)))
|
||||
}
|
||||
|
||||
fn rpc_addr(&self, default_listen_port: u16) -> CliResult<Option<Vec<RpcEndpoint>>> {
|
||||
self.base.base.rpc_addr(default_listen_port)
|
||||
}
|
||||
|
||||
fn prometheus_config(
|
||||
&self,
|
||||
default_listen_port: u16,
|
||||
chain_spec: &Box<dyn ChainSpec>,
|
||||
) -> CliResult<Option<PrometheusConfig>> {
|
||||
self.base.base.prometheus_config(default_listen_port, chain_spec)
|
||||
}
|
||||
|
||||
fn init<F>(
|
||||
&self,
|
||||
_support_url: &String,
|
||||
_impl_version: &String,
|
||||
_logger_hook: F,
|
||||
) -> CliResult<()>
|
||||
where
|
||||
F: FnOnce(&mut pezsc_cli::LoggerBuilder),
|
||||
{
|
||||
unreachable!("PezkuwiCli is never initialized; qed");
|
||||
}
|
||||
|
||||
fn chain_id(&self, is_dev: bool) -> CliResult<String> {
|
||||
let chain_id = self.base.base.chain_id(is_dev)?;
|
||||
|
||||
Ok(if chain_id.is_empty() { self.chain_id.clone().unwrap_or_default() } else { chain_id })
|
||||
}
|
||||
|
||||
fn role(&self, is_dev: bool) -> CliResult<pezsc_service::Role> {
|
||||
self.base.base.role(is_dev)
|
||||
}
|
||||
|
||||
fn transaction_pool(
|
||||
&self,
|
||||
is_dev: bool,
|
||||
) -> CliResult<pezsc_service::config::TransactionPoolOptions> {
|
||||
self.base.base.transaction_pool(is_dev)
|
||||
}
|
||||
|
||||
fn trie_cache_maximum_size(&self) -> CliResult<Option<usize>> {
|
||||
self.base.base.trie_cache_maximum_size()
|
||||
}
|
||||
|
||||
fn rpc_methods(&self) -> CliResult<pezsc_service::config::RpcMethods> {
|
||||
self.base.base.rpc_methods()
|
||||
}
|
||||
|
||||
fn rpc_max_connections(&self) -> CliResult<u32> {
|
||||
self.base.base.rpc_max_connections()
|
||||
}
|
||||
|
||||
fn rpc_cors(&self, is_dev: bool) -> CliResult<Option<Vec<String>>> {
|
||||
self.base.base.rpc_cors(is_dev)
|
||||
}
|
||||
|
||||
fn default_heap_pages(&self) -> CliResult<Option<u64>> {
|
||||
self.base.base.default_heap_pages()
|
||||
}
|
||||
|
||||
fn force_authoring(&self) -> CliResult<bool> {
|
||||
self.base.base.force_authoring()
|
||||
}
|
||||
|
||||
fn disable_grandpa(&self) -> CliResult<bool> {
|
||||
self.base.base.disable_grandpa()
|
||||
}
|
||||
|
||||
fn max_runtime_instances(&self) -> CliResult<Option<usize>> {
|
||||
self.base.base.max_runtime_instances()
|
||||
}
|
||||
|
||||
fn announce_block(&self) -> CliResult<bool> {
|
||||
self.base.base.announce_block()
|
||||
}
|
||||
|
||||
fn telemetry_endpoints(
|
||||
&self,
|
||||
chain_spec: &Box<dyn ChainSpec>,
|
||||
) -> CliResult<Option<pezsc_telemetry::TelemetryEndpoints>> {
|
||||
self.base.base.telemetry_endpoints(chain_spec)
|
||||
}
|
||||
|
||||
fn node_name(&self) -> CliResult<String> {
|
||||
self.base.base.node_name()
|
||||
}
|
||||
}
|
||||
|
||||
impl DefaultConfigurationValues for RelayChainCli {
|
||||
fn p2p_listen_port() -> u16 {
|
||||
30334
|
||||
}
|
||||
|
||||
fn rpc_listen_port() -> u16 {
|
||||
9945
|
||||
}
|
||||
|
||||
fn prometheus_listen_port() -> u16 {
|
||||
9616
|
||||
}
|
||||
}
|
||||
|
||||
impl BizinikiwiCli for TestCollatorCli {
|
||||
fn impl_name() -> String {
|
||||
"Pezcumulus zombienet test teyrchain".into()
|
||||
}
|
||||
|
||||
fn impl_version() -> String {
|
||||
String::new()
|
||||
}
|
||||
|
||||
fn description() -> String {
|
||||
format!(
|
||||
"Pezcumulus zombienet test teyrchain\n\nThe command-line arguments provided first will be \
|
||||
passed to the teyrchain node, while the arguments provided after -- will be passed \
|
||||
to the relaychain node.\n\n\
|
||||
{} [teyrchain-args] -- [relaychain-args]",
|
||||
Self::executable_name()
|
||||
)
|
||||
}
|
||||
|
||||
fn author() -> String {
|
||||
env!("CARGO_PKG_AUTHORS").into()
|
||||
}
|
||||
|
||||
fn support_url() -> String {
|
||||
"https://github.com/pezkuwichain/pezkuwi-sdk/issues/new".into()
|
||||
}
|
||||
|
||||
fn copyright_start_year() -> i32 {
|
||||
2017
|
||||
}
|
||||
|
||||
fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn pezsc_service::ChainSpec>, String> {
|
||||
Ok(match id {
|
||||
"" => {
|
||||
tracing::info!("Using default test service chain spec.");
|
||||
Box::new(cumulus_test_service::get_chain_spec(Some(ParaId::from(2000)))) as Box<_>
|
||||
},
|
||||
"elastic-scaling-mvp" => {
|
||||
tracing::info!("Using elastic-scaling mvp chain spec.");
|
||||
Box::new(cumulus_test_service::get_elastic_scaling_mvp_chain_spec(Some(
|
||||
ParaId::from(2100),
|
||||
))) as Box<_>
|
||||
},
|
||||
"elastic-scaling" => {
|
||||
tracing::info!("Using elastic-scaling chain spec.");
|
||||
Box::new(cumulus_test_service::get_elastic_scaling_chain_spec(Some(ParaId::from(
|
||||
2200,
|
||||
)))) as Box<_>
|
||||
},
|
||||
"elastic-scaling-500ms" => {
|
||||
tracing::info!("Using elastic-scaling 500ms chain spec.");
|
||||
Box::new(cumulus_test_service::get_elastic_scaling_500ms_chain_spec(Some(
|
||||
ParaId::from(2300),
|
||||
))) as Box<_>
|
||||
},
|
||||
"elastic-scaling-multi-block-slot" => {
|
||||
tracing::info!("Using elastic-scaling multi-block-slot chain spec.");
|
||||
Box::new(cumulus_test_service::get_elastic_scaling_multi_block_slot_chain_spec(
|
||||
Some(ParaId::from(2400)),
|
||||
)) as Box<_>
|
||||
},
|
||||
"sync-backing" => {
|
||||
tracing::info!("Using sync backing chain spec.");
|
||||
Box::new(cumulus_test_service::get_sync_backing_chain_spec(Some(ParaId::from(
|
||||
2500,
|
||||
)))) as Box<_>
|
||||
},
|
||||
"async-backing" => {
|
||||
tracing::info!("Using async backing chain spec.");
|
||||
Box::new(cumulus_test_service::get_async_backing_chain_spec(Some(ParaId::from(
|
||||
2500,
|
||||
)))) as Box<_>
|
||||
},
|
||||
"relay-parent-offset" => Box::new(
|
||||
cumulus_test_service::get_relay_parent_offset_chain_spec(Some(ParaId::from(2600))),
|
||||
) as Box<_>,
|
||||
path => {
|
||||
let chain_spec: pezsc_chain_spec::GenericChainSpec =
|
||||
pezsc_chain_spec::GenericChainSpec::from_json_file(path.into())?;
|
||||
Box::new(chain_spec)
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl BizinikiwiCli for RelayChainCli {
|
||||
fn impl_name() -> String {
|
||||
"Pezkuwi collator".into()
|
||||
}
|
||||
|
||||
fn impl_version() -> String {
|
||||
String::new()
|
||||
}
|
||||
|
||||
fn description() -> String {
|
||||
format!(
|
||||
"Pezkuwi collator\n\nThe command-line arguments provided first will be \
|
||||
passed to the teyrchain node, while the arguments provided after -- will be passed \
|
||||
to the relay chain node.\n\n\
|
||||
{} [teyrchain-args] -- [relay_chain-args]",
|
||||
Self::executable_name()
|
||||
)
|
||||
}
|
||||
|
||||
fn author() -> String {
|
||||
env!("CARGO_PKG_AUTHORS").into()
|
||||
}
|
||||
|
||||
fn support_url() -> String {
|
||||
"https://github.com/pezkuwichain/pezkuwi-sdk/issues/new".into()
|
||||
}
|
||||
|
||||
fn copyright_start_year() -> i32 {
|
||||
2017
|
||||
}
|
||||
|
||||
fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn pezsc_service::ChainSpec>, String> {
|
||||
<pezkuwi_cli::Cli as BizinikiwiCli>::from_iter([RelayChainCli::executable_name()].iter())
|
||||
.load_spec(id)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,996 @@
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// This file is part of Pezcumulus.
|
||||
|
||||
// Pezcumulus is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Pezcumulus is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Pezcumulus. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
//! Crate used for testing with Pezcumulus.
|
||||
|
||||
#![warn(missing_docs)]
|
||||
|
||||
/// Utilities used for benchmarking
|
||||
pub mod bench_utils;
|
||||
|
||||
pub mod chain_spec;
|
||||
|
||||
use cumulus_client_collator::service::CollatorService;
|
||||
use cumulus_client_consensus_aura::{
|
||||
collators::{
|
||||
lookahead::{self as aura, Params as AuraParams},
|
||||
slot_based::{
|
||||
self as slot_based, Params as SlotBasedParams, SlotBasedBlockImport,
|
||||
SlotBasedBlockImportHandle,
|
||||
},
|
||||
},
|
||||
ImportQueueParams,
|
||||
};
|
||||
use prometheus::Registry;
|
||||
use runtime::AccountId;
|
||||
use pezsc_executor::{HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY};
|
||||
use pezsp_consensus_aura::sr25519::AuthorityPair;
|
||||
use std::{
|
||||
collections::HashSet,
|
||||
future::Future,
|
||||
net::{Ipv4Addr, SocketAddr, SocketAddrV4},
|
||||
time::Duration,
|
||||
};
|
||||
use url::Url;
|
||||
|
||||
use crate::runtime::Weight;
|
||||
use cumulus_client_cli::{CollatorOptions, RelayChainMode};
|
||||
use cumulus_client_consensus_common::TeyrchainBlockImport as TTeyrchainBlockImport;
|
||||
use cumulus_client_pov_recovery::{RecoveryDelayRange, RecoveryHandle};
|
||||
use cumulus_client_service::{
|
||||
build_network, prepare_node_config, start_relay_chain_tasks, BuildNetworkParams,
|
||||
CollatorSybilResistance, DARecoveryProfile, StartRelayChainTasksParams,
|
||||
TeyrchainTracingExecuteBlock,
|
||||
};
|
||||
use cumulus_primitives_core::{relay_chain::ValidationCode, GetTeyrchainInfo, ParaId};
|
||||
use cumulus_relay_chain_inprocess_interface::RelayChainInProcessInterface;
|
||||
use cumulus_relay_chain_interface::{RelayChainError, RelayChainInterface, RelayChainResult};
|
||||
use cumulus_relay_chain_minimal_node::build_minimal_relay_chain_node_with_rpc;
|
||||
|
||||
use cumulus_test_runtime::{Hash, NodeBlock as Block, RuntimeApi};
|
||||
|
||||
use pezframe_system_rpc_runtime_api::AccountNonceApi;
|
||||
use pezkuwi_node_subsystem::{errors::RecoveryError, messages::AvailabilityRecoveryMessage};
|
||||
use pezkuwi_overseer::Handle as OverseerHandle;
|
||||
use pezkuwi_primitives::{CandidateHash, CollatorPair};
|
||||
use pezkuwi_service::ProvideRuntimeApi;
|
||||
use pezsc_consensus::ImportQueue;
|
||||
use pezsc_network::{
|
||||
config::{FullNetworkConfiguration, TransportConfig},
|
||||
multiaddr,
|
||||
service::traits::NetworkService,
|
||||
NetworkBackend, NetworkBlock, NetworkStateInfo,
|
||||
};
|
||||
use pezsc_service::{
|
||||
config::{
|
||||
BlocksPruning, DatabaseSource, ExecutorConfiguration, KeystoreConfig, MultiaddrWithPeerId,
|
||||
NetworkConfiguration, OffchainWorkerConfig, PruningMode, RpcBatchRequestConfig,
|
||||
RpcConfiguration, RpcEndpoint, WasmExecutionMethod,
|
||||
},
|
||||
BasePath, ChainSpec as ChainSpecService, Configuration, Error as ServiceError,
|
||||
PartialComponents, Role, RpcHandlers, TFullBackend, TFullClient, TaskManager,
|
||||
};
|
||||
use pezsp_arithmetic::traits::SaturatedConversion;
|
||||
use pezsp_blockchain::HeaderBackend;
|
||||
use pezsp_core::Pair;
|
||||
use pezsp_keyring::Sr25519Keyring;
|
||||
use pezsp_runtime::{codec::Encode, generic, MultiAddress};
|
||||
use pezsp_state_machine::BasicExternalities;
|
||||
use std::sync::Arc;
|
||||
use bizinikiwi_test_client::{
|
||||
BlockchainEventsExt, RpcHandlersExt, RpcTransactionError, RpcTransactionOutput,
|
||||
};
|
||||
|
||||
pub use chain_spec::*;
|
||||
pub use cumulus_test_runtime as runtime;
|
||||
pub use pezsp_keyring::Sr25519Keyring as Keyring;
|
||||
|
||||
const LOG_TARGET: &str = "pezcumulus-test-service";
|
||||
|
||||
/// The signature of the announce block fn.
|
||||
pub type AnnounceBlockFn = Arc<dyn Fn(Hash, Option<Vec<u8>>) + Send + Sync>;
|
||||
|
||||
type HostFunctions =
|
||||
(pezsp_io::BizinikiwiHostFunctions, cumulus_client_service::storage_proof_size::HostFunctions);
|
||||
/// The client type being used by the test service.
|
||||
pub type Client = TFullClient<runtime::NodeBlock, runtime::RuntimeApi, WasmExecutor<HostFunctions>>;
|
||||
|
||||
/// The backend type being used by the test service.
|
||||
pub type Backend = TFullBackend<Block>;
|
||||
|
||||
/// The block-import type being used by the test service.
|
||||
pub type TeyrchainBlockImport =
|
||||
TTeyrchainBlockImport<Block, SlotBasedBlockImport<Block, Arc<Client>, Client>, Backend>;
|
||||
|
||||
/// Transaction pool type used by the test service
|
||||
pub type TransactionPool = Arc<pezsc_transaction_pool::TransactionPoolHandle<Block, Client>>;
|
||||
|
||||
/// Recovery handle that fails regularly to simulate unavailable povs.
|
||||
pub struct FailingRecoveryHandle {
|
||||
overseer_handle: OverseerHandle,
|
||||
counter: u32,
|
||||
failed_hashes: HashSet<CandidateHash>,
|
||||
}
|
||||
|
||||
impl FailingRecoveryHandle {
|
||||
/// Create a new FailingRecoveryHandle
|
||||
pub fn new(overseer_handle: OverseerHandle) -> Self {
|
||||
Self { overseer_handle, counter: 0, failed_hashes: Default::default() }
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl RecoveryHandle for FailingRecoveryHandle {
|
||||
async fn send_recovery_msg(
|
||||
&mut self,
|
||||
message: AvailabilityRecoveryMessage,
|
||||
origin: &'static str,
|
||||
) {
|
||||
let AvailabilityRecoveryMessage::RecoverAvailableData(ref receipt, _, _, _, _) = message;
|
||||
let candidate_hash = receipt.hash();
|
||||
|
||||
// For every 3rd block we immediately signal unavailability to trigger
|
||||
// a retry. The same candidate is never failed multiple times to ensure progress.
|
||||
if self.counter % 3 == 0 && self.failed_hashes.insert(candidate_hash) {
|
||||
tracing::info!(target: LOG_TARGET, ?candidate_hash, "Failing pov recovery.");
|
||||
|
||||
let AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, back_sender) =
|
||||
message;
|
||||
back_sender
|
||||
.send(Err(RecoveryError::Unavailable))
|
||||
.expect("Return channel should work here.");
|
||||
} else {
|
||||
self.overseer_handle.send_msg(message, origin).await;
|
||||
}
|
||||
self.counter += 1;
|
||||
}
|
||||
}
|
||||
|
||||
/// Assembly of PartialComponents (enough to run chain ops subcommands)
|
||||
pub type Service = PartialComponents<
|
||||
Client,
|
||||
Backend,
|
||||
(),
|
||||
pezsc_consensus::import_queue::BasicQueue<Block>,
|
||||
pezsc_transaction_pool::TransactionPoolHandle<Block, Client>,
|
||||
(TeyrchainBlockImport, SlotBasedBlockImportHandle<Block>),
|
||||
>;
|
||||
|
||||
/// Starts a `ServiceBuilder` for a full service.
|
||||
///
|
||||
/// Use this macro if you don't actually need the full service, but just the builder in order to
|
||||
/// be able to perform chain operations.
|
||||
pub fn new_partial(
|
||||
config: &mut Configuration,
|
||||
enable_import_proof_record: bool,
|
||||
) -> Result<Service, pezsc_service::Error> {
|
||||
let heap_pages = config
|
||||
.executor
|
||||
.default_heap_pages
|
||||
.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |h| HeapAllocStrategy::Static { extra_pages: h as _ });
|
||||
|
||||
let executor = WasmExecutor::builder()
|
||||
.with_execution_method(config.executor.wasm_method)
|
||||
.with_onchain_heap_alloc_strategy(heap_pages)
|
||||
.with_offchain_heap_alloc_strategy(heap_pages)
|
||||
.with_max_runtime_instances(config.executor.max_runtime_instances)
|
||||
.with_runtime_cache_size(config.executor.runtime_cache_size)
|
||||
.build();
|
||||
|
||||
let (client, backend, keystore_container, task_manager) =
|
||||
pezsc_service::new_full_parts_record_import::<Block, RuntimeApi, _>(
|
||||
config,
|
||||
None,
|
||||
executor,
|
||||
enable_import_proof_record,
|
||||
)?;
|
||||
let client = Arc::new(client);
|
||||
|
||||
let (block_import, slot_based_handle) =
|
||||
SlotBasedBlockImport::new(client.clone(), client.clone());
|
||||
let block_import = TeyrchainBlockImport::new(block_import, backend.clone());
|
||||
|
||||
let transaction_pool = Arc::from(
|
||||
pezsc_transaction_pool::Builder::new(
|
||||
task_manager.spawn_essential_handle(),
|
||||
client.clone(),
|
||||
config.role.is_authority().into(),
|
||||
)
|
||||
.with_options(config.transaction_pool.clone())
|
||||
.with_prometheus(config.prometheus_registry())
|
||||
.build(),
|
||||
);
|
||||
|
||||
let slot_duration = pezsc_consensus_aura::slot_duration(&*client)?;
|
||||
let import_queue = cumulus_client_consensus_aura::import_queue::<AuthorityPair, _, _, _, _, _>(
|
||||
ImportQueueParams {
|
||||
block_import: block_import.clone(),
|
||||
client: client.clone(),
|
||||
create_inherent_data_providers: move |_, ()| async move {
|
||||
let timestamp = pezsp_timestamp::InherentDataProvider::from_system_time();
|
||||
|
||||
let slot =
|
||||
pezsp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
|
||||
*timestamp,
|
||||
slot_duration,
|
||||
);
|
||||
|
||||
Ok((slot, timestamp))
|
||||
},
|
||||
spawner: &task_manager.spawn_essential_handle(),
|
||||
registry: None,
|
||||
telemetry: None,
|
||||
},
|
||||
)?;
|
||||
|
||||
let params = PartialComponents {
|
||||
backend,
|
||||
client,
|
||||
import_queue,
|
||||
keystore_container,
|
||||
task_manager,
|
||||
transaction_pool,
|
||||
select_chain: (),
|
||||
other: (block_import, slot_based_handle),
|
||||
};
|
||||
|
||||
Ok(params)
|
||||
}
|
||||
|
||||
async fn build_relay_chain_interface(
|
||||
relay_chain_config: Configuration,
|
||||
teyrchain_prometheus_registry: Option<&Registry>,
|
||||
collator_key: Option<CollatorPair>,
|
||||
collator_options: CollatorOptions,
|
||||
task_manager: &mut TaskManager,
|
||||
) -> RelayChainResult<Arc<dyn RelayChainInterface + 'static>> {
|
||||
let relay_chain_node = match collator_options.relay_chain_mode {
|
||||
cumulus_client_cli::RelayChainMode::Embedded => pezkuwi_test_service::new_full(
|
||||
relay_chain_config,
|
||||
if let Some(ref key) = collator_key {
|
||||
pezkuwi_service::IsTeyrchainNode::Collator(key.clone())
|
||||
} else {
|
||||
pezkuwi_service::IsTeyrchainNode::Collator(CollatorPair::generate().0)
|
||||
},
|
||||
None,
|
||||
pezkuwi_service::CollatorOverseerGen,
|
||||
Some("Relaychain"),
|
||||
)
|
||||
.map_err(|e| RelayChainError::Application(Box::new(e) as Box<_>))?,
|
||||
cumulus_client_cli::RelayChainMode::ExternalRpc(rpc_target_urls) =>
|
||||
return build_minimal_relay_chain_node_with_rpc(
|
||||
relay_chain_config,
|
||||
teyrchain_prometheus_registry,
|
||||
task_manager,
|
||||
rpc_target_urls,
|
||||
)
|
||||
.await
|
||||
.map(|r| r.0),
|
||||
};
|
||||
|
||||
task_manager.add_child(relay_chain_node.task_manager);
|
||||
tracing::info!("Using inprocess node.");
|
||||
Ok(Arc::new(RelayChainInProcessInterface::new(
|
||||
relay_chain_node.client.clone(),
|
||||
relay_chain_node.backend.clone(),
|
||||
relay_chain_node.sync_service.clone(),
|
||||
relay_chain_node.overseer_handle.ok_or(RelayChainError::GenericError(
|
||||
"Overseer should be running in full node.".to_string(),
|
||||
))?,
|
||||
)))
|
||||
}
|
||||
|
||||
/// Start a node with the given teyrchain `Configuration` and relay chain `Configuration`.
|
||||
///
|
||||
/// This is the actual implementation that is abstract over the executor and the runtime api.
|
||||
#[pezsc_tracing::logging::prefix_logs_with("Teyrchain")]
|
||||
pub async fn start_node_impl<RB, Net: NetworkBackend<Block, Hash>>(
|
||||
teyrchain_config: Configuration,
|
||||
collator_key: Option<CollatorPair>,
|
||||
relay_chain_config: Configuration,
|
||||
wrap_announce_block: Option<Box<dyn FnOnce(AnnounceBlockFn) -> AnnounceBlockFn>>,
|
||||
fail_pov_recovery: bool,
|
||||
rpc_ext_builder: RB,
|
||||
collator_options: CollatorOptions,
|
||||
proof_recording_during_import: bool,
|
||||
use_slot_based_collator: bool,
|
||||
) -> pezsc_service::error::Result<(
|
||||
TaskManager,
|
||||
Arc<Client>,
|
||||
Arc<dyn NetworkService>,
|
||||
RpcHandlers,
|
||||
TransactionPool,
|
||||
Arc<Backend>,
|
||||
)>
|
||||
where
|
||||
RB: Fn(Arc<Client>) -> Result<jsonrpsee::RpcModule<()>, pezsc_service::Error> + Send + 'static,
|
||||
{
|
||||
let mut teyrchain_config = prepare_node_config(teyrchain_config);
|
||||
|
||||
let params = new_partial(&mut teyrchain_config, proof_recording_during_import)?;
|
||||
|
||||
let transaction_pool = params.transaction_pool.clone();
|
||||
let mut task_manager = params.task_manager;
|
||||
|
||||
let client = params.client.clone();
|
||||
let backend = params.backend.clone();
|
||||
|
||||
let block_import = params.other.0;
|
||||
let slot_based_handle = params.other.1;
|
||||
let relay_chain_interface = build_relay_chain_interface(
|
||||
relay_chain_config,
|
||||
teyrchain_config.prometheus_registry(),
|
||||
collator_key.clone(),
|
||||
collator_options.clone(),
|
||||
&mut task_manager,
|
||||
)
|
||||
.await
|
||||
.map_err(|e| pezsc_service::Error::Application(Box::new(e) as Box<_>))?;
|
||||
|
||||
let import_queue_service = params.import_queue.service();
|
||||
let prometheus_registry = teyrchain_config.prometheus_registry().cloned();
|
||||
let net_config = FullNetworkConfiguration::<Block, Hash, Net>::new(
|
||||
&teyrchain_config.network,
|
||||
prometheus_registry.clone(),
|
||||
);
|
||||
|
||||
let best_hash = client.chain_info().best_hash;
|
||||
let para_id = client
|
||||
.runtime_api()
|
||||
.teyrchain_id(best_hash)
|
||||
.map_err(|e| pezsc_service::Error::Application(Box::new(e) as Box<_>))?;
|
||||
tracing::info!("Teyrchain id: {:?}", para_id);
|
||||
|
||||
let (network, system_rpc_tx, tx_handler_controller, sync_service) =
|
||||
build_network(BuildNetworkParams {
|
||||
teyrchain_config: &teyrchain_config,
|
||||
net_config,
|
||||
client: client.clone(),
|
||||
transaction_pool: transaction_pool.clone(),
|
||||
para_id,
|
||||
spawn_handle: task_manager.spawn_handle(),
|
||||
relay_chain_interface: relay_chain_interface.clone(),
|
||||
import_queue: params.import_queue,
|
||||
metrics: Net::register_notification_metrics(
|
||||
teyrchain_config.prometheus_config.as_ref().map(|config| &config.registry),
|
||||
),
|
||||
sybil_resistance_level: CollatorSybilResistance::Resistant,
|
||||
})
|
||||
.await?;
|
||||
|
||||
let keystore = params.keystore_container.keystore();
|
||||
let rpc_builder = {
|
||||
let client = client.clone();
|
||||
Box::new(move |_| rpc_ext_builder(client.clone()))
|
||||
};
|
||||
|
||||
let rpc_handlers = pezsc_service::spawn_tasks(pezsc_service::SpawnTasksParams {
|
||||
rpc_builder,
|
||||
client: client.clone(),
|
||||
transaction_pool: transaction_pool.clone(),
|
||||
task_manager: &mut task_manager,
|
||||
config: teyrchain_config,
|
||||
keystore: keystore.clone(),
|
||||
backend: backend.clone(),
|
||||
network: network.clone(),
|
||||
sync_service: sync_service.clone(),
|
||||
system_rpc_tx,
|
||||
tx_handler_controller,
|
||||
telemetry: None,
|
||||
tracing_execute_block: Some(Arc::new(TeyrchainTracingExecuteBlock::new(client.clone()))),
|
||||
})?;
|
||||
|
||||
let announce_block = {
|
||||
let sync_service = sync_service.clone();
|
||||
Arc::new(move |hash, data| sync_service.announce_block(hash, data))
|
||||
};
|
||||
|
||||
let announce_block = wrap_announce_block
|
||||
.map(|w| (w)(announce_block.clone()))
|
||||
.unwrap_or_else(|| announce_block);
|
||||
|
||||
let overseer_handle = relay_chain_interface
|
||||
.overseer_handle()
|
||||
.map_err(|e| pezsc_service::Error::Application(Box::new(e)))?;
|
||||
|
||||
let recovery_handle: Box<dyn RecoveryHandle> = if fail_pov_recovery {
|
||||
Box::new(FailingRecoveryHandle::new(overseer_handle.clone()))
|
||||
} else {
|
||||
Box::new(overseer_handle.clone())
|
||||
};
|
||||
let relay_chain_slot_duration = Duration::from_secs(6);
|
||||
|
||||
start_relay_chain_tasks(StartRelayChainTasksParams {
|
||||
client: client.clone(),
|
||||
announce_block: announce_block.clone(),
|
||||
para_id,
|
||||
relay_chain_interface: relay_chain_interface.clone(),
|
||||
task_manager: &mut task_manager,
|
||||
// Increase speed of recovery for testing purposes.
|
||||
da_recovery_profile: DARecoveryProfile::Other(RecoveryDelayRange {
|
||||
min: Duration::from_secs(1),
|
||||
max: Duration::from_secs(5),
|
||||
}),
|
||||
import_queue: import_queue_service,
|
||||
relay_chain_slot_duration,
|
||||
recovery_handle,
|
||||
sync_service: sync_service.clone(),
|
||||
prometheus_registry: None,
|
||||
})?;
|
||||
|
||||
let collator_peer_id = network.local_peer_id();
|
||||
if let Some(collator_key) = collator_key {
|
||||
let proposer = pezsc_basic_authorship::ProposerFactory::with_proof_recording(
|
||||
task_manager.spawn_handle(),
|
||||
client.clone(),
|
||||
transaction_pool.clone(),
|
||||
prometheus_registry.as_ref(),
|
||||
None,
|
||||
);
|
||||
|
||||
let collator_service = CollatorService::new(
|
||||
client.clone(),
|
||||
Arc::new(task_manager.spawn_handle()),
|
||||
announce_block,
|
||||
client.clone(),
|
||||
);
|
||||
|
||||
let client_for_aura = client.clone();
|
||||
|
||||
if use_slot_based_collator {
|
||||
tracing::info!(target: LOG_TARGET, "Starting block authoring with slot based authoring.");
|
||||
let params = SlotBasedParams {
|
||||
create_inherent_data_providers: move |_, ()| async move { Ok(()) },
|
||||
block_import,
|
||||
para_client: client.clone(),
|
||||
para_backend: backend.clone(),
|
||||
relay_client: relay_chain_interface,
|
||||
code_hash_provider: move |block_hash| {
|
||||
client_for_aura.code_at(block_hash).ok().map(|c| ValidationCode::from(c).hash())
|
||||
},
|
||||
keystore,
|
||||
collator_key,
|
||||
relay_chain_slot_duration,
|
||||
para_id,
|
||||
proposer,
|
||||
collator_service,
|
||||
authoring_duration: Duration::from_millis(2000),
|
||||
reinitialize: false,
|
||||
slot_offset: Duration::from_secs(1),
|
||||
block_import_handle: slot_based_handle,
|
||||
spawner: task_manager.spawn_essential_handle(),
|
||||
export_pov: None,
|
||||
max_pov_percentage: None,
|
||||
collator_peer_id,
|
||||
};
|
||||
|
||||
slot_based::run::<Block, AuthorityPair, _, _, _, _, _, _, _, _, _>(params);
|
||||
} else {
|
||||
tracing::info!(target: LOG_TARGET, "Starting block authoring with lookahead collator.");
|
||||
let params = AuraParams {
|
||||
create_inherent_data_providers: move |_, ()| async move { Ok(()) },
|
||||
block_import,
|
||||
para_client: client.clone(),
|
||||
para_backend: backend.clone(),
|
||||
relay_client: relay_chain_interface,
|
||||
code_hash_provider: move |block_hash| {
|
||||
client_for_aura.code_at(block_hash).ok().map(|c| ValidationCode::from(c).hash())
|
||||
},
|
||||
keystore,
|
||||
collator_key,
|
||||
collator_peer_id,
|
||||
para_id,
|
||||
overseer_handle,
|
||||
relay_chain_slot_duration,
|
||||
proposer,
|
||||
collator_service,
|
||||
authoring_duration: Duration::from_millis(2000),
|
||||
reinitialize: false,
|
||||
max_pov_percentage: None,
|
||||
};
|
||||
|
||||
let fut = aura::run::<Block, AuthorityPair, _, _, _, _, _, _, _, _>(params);
|
||||
task_manager.spawn_essential_handle().spawn("aura", None, fut);
|
||||
}
|
||||
}
|
||||
|
||||
Ok((task_manager, client, network, rpc_handlers, transaction_pool, backend))
|
||||
}
|
||||
|
||||
/// A Pezcumulus test node instance used for testing.
|
||||
pub struct TestNode {
|
||||
/// TaskManager's instance.
|
||||
pub task_manager: TaskManager,
|
||||
/// Client's instance.
|
||||
pub client: Arc<Client>,
|
||||
/// Node's network.
|
||||
pub network: Arc<dyn NetworkService>,
|
||||
/// The `MultiaddrWithPeerId` to this node. This is useful if you want to pass it as "boot
|
||||
/// node" to other nodes.
|
||||
pub addr: MultiaddrWithPeerId,
|
||||
/// RPCHandlers to make RPC queries.
|
||||
pub rpc_handlers: RpcHandlers,
|
||||
/// Node's transaction pool
|
||||
pub transaction_pool: TransactionPool,
|
||||
/// Node's backend
|
||||
pub backend: Arc<Backend>,
|
||||
}
|
||||
|
||||
/// A builder to create a [`TestNode`].
|
||||
pub struct TestNodeBuilder {
|
||||
para_id: ParaId,
|
||||
tokio_handle: tokio::runtime::Handle,
|
||||
key: Sr25519Keyring,
|
||||
collator_key: Option<CollatorPair>,
|
||||
teyrchain_nodes: Vec<MultiaddrWithPeerId>,
|
||||
teyrchain_nodes_exclusive: bool,
|
||||
relay_chain_nodes: Vec<MultiaddrWithPeerId>,
|
||||
wrap_announce_block: Option<Box<dyn FnOnce(AnnounceBlockFn) -> AnnounceBlockFn>>,
|
||||
storage_update_func_teyrchain: Option<Box<dyn Fn()>>,
|
||||
storage_update_func_relay_chain: Option<Box<dyn Fn()>>,
|
||||
relay_chain_mode: RelayChainMode,
|
||||
endowed_accounts: Vec<AccountId>,
|
||||
record_proof_during_import: bool,
|
||||
}
|
||||
|
||||
impl TestNodeBuilder {
|
||||
/// Create a new instance of `Self`.
|
||||
///
|
||||
/// `para_id` - The teyrchain id this node is running for.
|
||||
/// `tokio_handle` - The tokio handler to use.
|
||||
/// `key` - The key that will be used to generate the name and that will be passed as
|
||||
/// `dev_seed`.
|
||||
pub fn new(para_id: ParaId, tokio_handle: tokio::runtime::Handle, key: Sr25519Keyring) -> Self {
|
||||
TestNodeBuilder {
|
||||
key,
|
||||
para_id,
|
||||
tokio_handle,
|
||||
collator_key: None,
|
||||
teyrchain_nodes: Vec::new(),
|
||||
teyrchain_nodes_exclusive: false,
|
||||
relay_chain_nodes: Vec::new(),
|
||||
wrap_announce_block: None,
|
||||
storage_update_func_teyrchain: None,
|
||||
storage_update_func_relay_chain: None,
|
||||
endowed_accounts: Default::default(),
|
||||
relay_chain_mode: RelayChainMode::Embedded,
|
||||
record_proof_during_import: true,
|
||||
}
|
||||
}
|
||||
|
||||
/// Enable collator for this node.
|
||||
pub fn enable_collator(mut self) -> Self {
|
||||
let collator_key = CollatorPair::generate().0;
|
||||
self.collator_key = Some(collator_key);
|
||||
self
|
||||
}
|
||||
|
||||
/// Instruct the node to exclusively connect to registered teyrchain nodes.
|
||||
///
|
||||
/// Teyrchain nodes can be registered using [`Self::connect_to_teyrchain_node`] and
|
||||
/// [`Self::connect_to_teyrchain_nodes`].
|
||||
pub fn exclusively_connect_to_registered_teyrchain_nodes(mut self) -> Self {
|
||||
self.teyrchain_nodes_exclusive = true;
|
||||
self
|
||||
}
|
||||
|
||||
/// Make the node connect to the given teyrchain node.
|
||||
///
|
||||
/// By default the node will not be connected to any node or will be able to discover any other
|
||||
/// node.
|
||||
pub fn connect_to_teyrchain_node(mut self, node: &TestNode) -> Self {
|
||||
self.teyrchain_nodes.push(node.addr.clone());
|
||||
self
|
||||
}
|
||||
|
||||
/// Make the node connect to the given teyrchain nodes.
|
||||
///
|
||||
/// By default the node will not be connected to any node or will be able to discover any other
|
||||
/// node.
|
||||
pub fn connect_to_teyrchain_nodes<'a>(
|
||||
mut self,
|
||||
nodes: impl IntoIterator<Item = &'a TestNode>,
|
||||
) -> Self {
|
||||
self.teyrchain_nodes.extend(nodes.into_iter().map(|n| n.addr.clone()));
|
||||
self
|
||||
}
|
||||
|
||||
/// Make the node connect to the given relay chain node.
|
||||
///
|
||||
/// By default the node will not be connected to any node or will be able to discover any other
|
||||
/// node.
|
||||
pub fn connect_to_relay_chain_node(
|
||||
mut self,
|
||||
node: &pezkuwi_test_service::PezkuwiTestNode,
|
||||
) -> Self {
|
||||
self.relay_chain_nodes.push(node.addr.clone());
|
||||
self
|
||||
}
|
||||
|
||||
/// Make the node connect to the given relay chain nodes.
|
||||
///
|
||||
/// By default the node will not be connected to any node or will be able to discover any other
|
||||
/// node.
|
||||
pub fn connect_to_relay_chain_nodes<'a>(
|
||||
mut self,
|
||||
nodes: impl IntoIterator<Item = &'a pezkuwi_test_service::PezkuwiTestNode>,
|
||||
) -> Self {
|
||||
self.relay_chain_nodes.extend(nodes.into_iter().map(|n| n.addr.clone()));
|
||||
self
|
||||
}
|
||||
|
||||
/// Wrap the announce block function of this node.
|
||||
pub fn wrap_announce_block(
|
||||
mut self,
|
||||
wrap: impl FnOnce(AnnounceBlockFn) -> AnnounceBlockFn + 'static,
|
||||
) -> Self {
|
||||
self.wrap_announce_block = Some(Box::new(wrap));
|
||||
self
|
||||
}
|
||||
|
||||
/// Allows accessing the teyrchain storage before the test node is built.
|
||||
pub fn update_storage_teyrchain(mut self, updater: impl Fn() + 'static) -> Self {
|
||||
self.storage_update_func_teyrchain = Some(Box::new(updater));
|
||||
self
|
||||
}
|
||||
|
||||
/// Allows accessing the relay chain storage before the test node is built.
|
||||
pub fn update_storage_relay_chain(mut self, updater: impl Fn() + 'static) -> Self {
|
||||
self.storage_update_func_relay_chain = Some(Box::new(updater));
|
||||
self
|
||||
}
|
||||
|
||||
/// Connect to full node via RPC.
|
||||
pub fn use_external_relay_chain_node_at_url(mut self, network_address: Url) -> Self {
|
||||
self.relay_chain_mode = RelayChainMode::ExternalRpc(vec![network_address]);
|
||||
self
|
||||
}
|
||||
|
||||
/// Connect to full node via RPC.
|
||||
pub fn use_external_relay_chain_node_at_port(mut self, port: u16) -> Self {
|
||||
let mut localhost_url =
|
||||
Url::parse("ws://localhost").expect("Should be able to parse localhost Url");
|
||||
localhost_url.set_port(Some(port)).expect("Should be able to set port");
|
||||
self.relay_chain_mode = RelayChainMode::ExternalRpc(vec![localhost_url]);
|
||||
self
|
||||
}
|
||||
|
||||
/// Accounts which will have an initial balance.
|
||||
pub fn endowed_accounts(mut self, accounts: Vec<AccountId>) -> TestNodeBuilder {
|
||||
self.endowed_accounts = accounts;
|
||||
self
|
||||
}
|
||||
|
||||
/// Record proofs during import.
|
||||
pub fn import_proof_recording(mut self, should_record_proof: bool) -> TestNodeBuilder {
|
||||
self.record_proof_during_import = should_record_proof;
|
||||
self
|
||||
}
|
||||
|
||||
/// Build the [`TestNode`].
|
||||
pub async fn build(self) -> TestNode {
|
||||
let teyrchain_config = node_config(
|
||||
self.storage_update_func_teyrchain.unwrap_or_else(|| Box::new(|| ())),
|
||||
self.tokio_handle.clone(),
|
||||
self.key,
|
||||
self.teyrchain_nodes,
|
||||
self.teyrchain_nodes_exclusive,
|
||||
self.para_id,
|
||||
self.collator_key.is_some(),
|
||||
self.endowed_accounts,
|
||||
)
|
||||
.expect("could not generate Configuration");
|
||||
|
||||
let mut relay_chain_config = pezkuwi_test_service::node_config(
|
||||
self.storage_update_func_relay_chain.unwrap_or_else(|| Box::new(|| ())),
|
||||
self.tokio_handle,
|
||||
self.key,
|
||||
self.relay_chain_nodes,
|
||||
false,
|
||||
);
|
||||
|
||||
let collator_options = CollatorOptions {
|
||||
relay_chain_mode: self.relay_chain_mode,
|
||||
embedded_dht_bootnode: true,
|
||||
dht_bootnode_discovery: true,
|
||||
};
|
||||
|
||||
relay_chain_config.network.node_name =
|
||||
format!("{} (relay chain)", relay_chain_config.network.node_name);
|
||||
|
||||
let (task_manager, client, network, rpc_handlers, transaction_pool, backend) =
|
||||
match relay_chain_config.network.network_backend {
|
||||
pezsc_network::config::NetworkBackendType::Libp2p =>
|
||||
start_node_impl::<_, pezsc_network::NetworkWorker<_, _>>(
|
||||
teyrchain_config,
|
||||
self.collator_key,
|
||||
relay_chain_config,
|
||||
self.wrap_announce_block,
|
||||
false,
|
||||
|_| Ok(jsonrpsee::RpcModule::new(())),
|
||||
collator_options,
|
||||
self.record_proof_during_import,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("could not create Pezcumulus test service"),
|
||||
pezsc_network::config::NetworkBackendType::Litep2p =>
|
||||
start_node_impl::<_, pezsc_network::Litep2pNetworkBackend>(
|
||||
teyrchain_config,
|
||||
self.collator_key,
|
||||
relay_chain_config,
|
||||
self.wrap_announce_block,
|
||||
false,
|
||||
|_| Ok(jsonrpsee::RpcModule::new(())),
|
||||
collator_options,
|
||||
self.record_proof_during_import,
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.expect("could not create Pezcumulus test service"),
|
||||
};
|
||||
let peer_id = network.local_peer_id();
|
||||
let multiaddr = pezkuwi_test_service::get_listen_address(network.clone()).await;
|
||||
let addr = MultiaddrWithPeerId { multiaddr, peer_id };
|
||||
|
||||
TestNode { task_manager, client, network, addr, rpc_handlers, transaction_pool, backend }
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a Pezcumulus `Configuration`.
|
||||
///
|
||||
/// By default a TCP socket will be used, therefore you need to provide nodes if you want the
|
||||
/// node to be connected to other nodes.
|
||||
///
|
||||
/// If `nodes_exclusive` is `true`, the node will only connect to the given `nodes` and not to any
|
||||
/// other node.
|
||||
///
|
||||
/// The `storage_update_func` can be used to make adjustments to the runtime genesis.
|
||||
pub fn node_config(
|
||||
storage_update_func: impl Fn(),
|
||||
tokio_handle: tokio::runtime::Handle,
|
||||
key: Sr25519Keyring,
|
||||
nodes: Vec<MultiaddrWithPeerId>,
|
||||
nodes_exclusive: bool,
|
||||
para_id: ParaId,
|
||||
is_collator: bool,
|
||||
endowed_accounts: Vec<AccountId>,
|
||||
) -> Result<Configuration, ServiceError> {
|
||||
let base_path = BasePath::new_temp_dir()?;
|
||||
let root = base_path.path().join(format!("cumulus_test_service_{}", key));
|
||||
let role = if is_collator { Role::Authority } else { Role::Full };
|
||||
let key_seed = key.to_seed();
|
||||
let mut spec = Box::new(chain_spec::get_chain_spec_with_extra_endowed(
|
||||
Some(para_id),
|
||||
endowed_accounts,
|
||||
cumulus_test_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"),
|
||||
));
|
||||
|
||||
let mut storage = spec.as_storage_builder().build_storage().expect("could not build storage");
|
||||
|
||||
BasicExternalities::execute_with_storage(&mut storage, storage_update_func);
|
||||
spec.set_storage(storage);
|
||||
|
||||
let mut network_config = NetworkConfiguration::new(
|
||||
format!("{} (teyrchain)", key_seed),
|
||||
"network/test/0.1",
|
||||
Default::default(),
|
||||
None,
|
||||
);
|
||||
|
||||
if nodes_exclusive {
|
||||
network_config.default_peers_set.reserved_nodes = nodes;
|
||||
network_config.default_peers_set.non_reserved_mode =
|
||||
pezsc_network::config::NonReservedPeerMode::Deny;
|
||||
} else {
|
||||
network_config.boot_nodes = nodes;
|
||||
}
|
||||
|
||||
network_config.allow_non_globals_in_dht = true;
|
||||
|
||||
let addr: multiaddr::Multiaddr = "/ip4/127.0.0.1/tcp/0".parse().expect("valid address; qed");
|
||||
network_config.listen_addresses.push(addr.clone());
|
||||
network_config.transport =
|
||||
TransportConfig::Normal { enable_mdns: false, allow_private_ip: true };
|
||||
|
||||
Ok(Configuration {
|
||||
impl_name: "pezcumulus-test-node".to_string(),
|
||||
impl_version: "0.1".to_string(),
|
||||
role,
|
||||
tokio_handle,
|
||||
transaction_pool: Default::default(),
|
||||
network: network_config,
|
||||
keystore: KeystoreConfig::InMemory,
|
||||
database: DatabaseSource::RocksDb { path: root.join("db"), cache_size: 128 },
|
||||
trie_cache_maximum_size: Some(64 * 1024 * 1024),
|
||||
warm_up_trie_cache: None,
|
||||
state_pruning: Some(PruningMode::ArchiveAll),
|
||||
blocks_pruning: BlocksPruning::KeepAll,
|
||||
chain_spec: spec,
|
||||
executor: ExecutorConfiguration {
|
||||
wasm_method: WasmExecutionMethod::Compiled {
|
||||
instantiation_strategy:
|
||||
pezsc_executor_wasmtime::InstantiationStrategy::PoolingCopyOnWrite,
|
||||
},
|
||||
..ExecutorConfiguration::default()
|
||||
},
|
||||
rpc: RpcConfiguration {
|
||||
addr: None,
|
||||
max_connections: Default::default(),
|
||||
cors: None,
|
||||
methods: Default::default(),
|
||||
max_request_size: Default::default(),
|
||||
max_response_size: Default::default(),
|
||||
id_provider: None,
|
||||
max_subs_per_conn: Default::default(),
|
||||
port: 9945,
|
||||
message_buffer_capacity: Default::default(),
|
||||
batch_config: RpcBatchRequestConfig::Unlimited,
|
||||
rate_limit: None,
|
||||
rate_limit_whitelisted_ips: Default::default(),
|
||||
rate_limit_trust_proxy_headers: Default::default(),
|
||||
request_logger_limit: 1024,
|
||||
},
|
||||
prometheus_config: None,
|
||||
telemetry_endpoints: None,
|
||||
offchain_worker: OffchainWorkerConfig { enabled: true, indexing_enabled: false },
|
||||
force_authoring: false,
|
||||
disable_grandpa: false,
|
||||
dev_key_seed: Some(key_seed),
|
||||
tracing_targets: None,
|
||||
tracing_receiver: Default::default(),
|
||||
announce_block: true,
|
||||
data_path: root,
|
||||
base_path,
|
||||
wasm_runtime_overrides: None,
|
||||
})
|
||||
}
|
||||
|
||||
impl TestNode {
|
||||
/// Wait for `count` blocks to be imported in the node and then exit. This function will not
|
||||
/// return if no blocks are ever created, thus you should restrict the maximum amount of time of
|
||||
/// the test execution.
|
||||
pub fn wait_for_blocks(&self, count: usize) -> impl Future<Output = ()> {
|
||||
self.client.wait_for_blocks(count)
|
||||
}
|
||||
|
||||
/// Send an extrinsic to this node.
|
||||
pub async fn send_extrinsic(
|
||||
&self,
|
||||
function: impl Into<runtime::RuntimeCall>,
|
||||
caller: Sr25519Keyring,
|
||||
) -> Result<RpcTransactionOutput, RpcTransactionError> {
|
||||
let extrinsic = construct_extrinsic(&self.client, function, caller.pair(), Some(0));
|
||||
|
||||
self.rpc_handlers.send_transaction(extrinsic.into()).await
|
||||
}
|
||||
|
||||
/// Register a teyrchain at this relay chain.
|
||||
pub async fn schedule_upgrade(&self, validation: Vec<u8>) -> Result<(), RpcTransactionError> {
|
||||
let call = pezframe_system::Call::set_code { code: validation };
|
||||
|
||||
self.send_extrinsic(
|
||||
runtime::SudoCall::sudo_unchecked_weight {
|
||||
call: Box::new(call.into()),
|
||||
weight: Weight::from_parts(1_000, 0),
|
||||
},
|
||||
Sr25519Keyring::Alice,
|
||||
)
|
||||
.await
|
||||
.map(drop)
|
||||
}
|
||||
}
|
||||
|
||||
/// Fetch account nonce for key pair
|
||||
pub fn fetch_nonce(client: &Client, account: pezsp_core::sr25519::Public) -> u32 {
|
||||
let best_hash = client.chain_info().best_hash;
|
||||
client
|
||||
.runtime_api()
|
||||
.account_nonce(best_hash, account.into())
|
||||
.expect("Fetching account nonce works; qed")
|
||||
}
|
||||
|
||||
/// Construct an extrinsic that can be applied to the test runtime.
|
||||
pub fn construct_extrinsic(
|
||||
client: &Client,
|
||||
function: impl Into<runtime::RuntimeCall>,
|
||||
caller: pezsp_core::sr25519::Pair,
|
||||
nonce: Option<u32>,
|
||||
) -> runtime::UncheckedExtrinsic {
|
||||
let function = function.into();
|
||||
let current_block_hash = client.info().best_hash;
|
||||
let current_block = client.info().best_number.saturated_into();
|
||||
let genesis_block = client.hash(0).unwrap().unwrap();
|
||||
let nonce = nonce.unwrap_or_else(|| fetch_nonce(client, caller.public()));
|
||||
let period = runtime::BlockHashCount::get()
|
||||
.checked_next_power_of_two()
|
||||
.map(|c| c / 2)
|
||||
.unwrap_or(2) as u64;
|
||||
let tip = 0;
|
||||
let tx_ext: runtime::TxExtension = (
|
||||
pezframe_system::AuthorizeCall::<runtime::Runtime>::new(),
|
||||
pezframe_system::CheckNonZeroSender::<runtime::Runtime>::new(),
|
||||
pezframe_system::CheckSpecVersion::<runtime::Runtime>::new(),
|
||||
pezframe_system::CheckGenesis::<runtime::Runtime>::new(),
|
||||
pezframe_system::CheckEra::<runtime::Runtime>::from(generic::Era::mortal(
|
||||
period,
|
||||
current_block,
|
||||
)),
|
||||
pezframe_system::CheckNonce::<runtime::Runtime>::from(nonce),
|
||||
pezframe_system::CheckWeight::<runtime::Runtime>::new(),
|
||||
pezpallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(tip),
|
||||
)
|
||||
.into();
|
||||
let raw_payload = runtime::SignedPayload::from_raw(
|
||||
function.clone(),
|
||||
tx_ext.clone(),
|
||||
((), (), runtime::VERSION.spec_version, genesis_block, current_block_hash, (), (), ()),
|
||||
);
|
||||
let signature = raw_payload.using_encoded(|e| caller.sign(e));
|
||||
runtime::UncheckedExtrinsic::new_signed(
|
||||
function,
|
||||
MultiAddress::Id(caller.public().into()),
|
||||
runtime::Signature::Sr25519(signature),
|
||||
tx_ext,
|
||||
)
|
||||
}
|
||||
|
||||
/// Run a relay-chain validator node.
|
||||
///
|
||||
/// This is essentially a wrapper around
|
||||
/// [`run_validator_node`](pezkuwi_test_service::run_validator_node).
|
||||
pub fn run_relay_chain_validator_node(
|
||||
tokio_handle: tokio::runtime::Handle,
|
||||
key: Sr25519Keyring,
|
||||
storage_update_func: impl Fn(),
|
||||
boot_nodes: Vec<MultiaddrWithPeerId>,
|
||||
port: Option<u16>,
|
||||
) -> pezkuwi_test_service::PezkuwiTestNode {
|
||||
let mut config = pezkuwi_test_service::node_config(
|
||||
storage_update_func,
|
||||
tokio_handle.clone(),
|
||||
key,
|
||||
boot_nodes,
|
||||
true,
|
||||
);
|
||||
|
||||
if let Some(port) = port {
|
||||
config.rpc.addr = Some(vec![RpcEndpoint {
|
||||
batch_config: config.rpc.batch_config,
|
||||
cors: config.rpc.cors.clone(),
|
||||
listen_addr: SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, port)),
|
||||
max_connections: config.rpc.max_connections,
|
||||
max_payload_in_mb: config.rpc.max_request_size,
|
||||
max_payload_out_mb: config.rpc.max_response_size,
|
||||
max_subscriptions_per_connection: config.rpc.max_subs_per_conn,
|
||||
max_buffer_capacity_per_connection: config.rpc.message_buffer_capacity,
|
||||
rpc_methods: config.rpc.methods,
|
||||
rate_limit: config.rpc.rate_limit,
|
||||
rate_limit_trust_proxy_headers: config.rpc.rate_limit_trust_proxy_headers,
|
||||
rate_limit_whitelisted_ips: config.rpc.rate_limit_whitelisted_ips.clone(),
|
||||
retry_random_port: true,
|
||||
is_optional: false,
|
||||
}]);
|
||||
}
|
||||
|
||||
let mut workers_path = std::env::current_exe().unwrap();
|
||||
workers_path.pop();
|
||||
workers_path.pop();
|
||||
|
||||
tokio_handle.block_on(async move {
|
||||
pezkuwi_test_service::run_validator_node(config, Some(workers_path)).await
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// This file is part of Pezcumulus.
|
||||
|
||||
// Pezcumulus is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Pezcumulus is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Pezcumulus. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
mod cli;
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use cli::{AuthoringPolicy, RelayChainCli, Subcommand, TestCollatorCli};
|
||||
use cumulus_primitives_core::relay_chain::CollatorPair;
|
||||
use cumulus_test_service::{new_partial, AnnounceBlockFn};
|
||||
use pezsc_cli::{CliConfiguration, BizinikiwiCli};
|
||||
use pezsp_core::Pair;
|
||||
|
||||
pub fn wrap_announce_block() -> Box<dyn FnOnce(AnnounceBlockFn) -> AnnounceBlockFn> {
|
||||
tracing::info!("Block announcements disabled.");
|
||||
Box::new(|_| {
|
||||
// Never announce any block
|
||||
Arc::new(|_, _| {})
|
||||
})
|
||||
}
|
||||
|
||||
fn main() -> Result<(), pezsc_cli::Error> {
|
||||
let cli = TestCollatorCli::from_args();
|
||||
|
||||
match &cli.subcommand {
|
||||
#[allow(deprecated)]
|
||||
Some(Subcommand::BuildSpec(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
|
||||
},
|
||||
|
||||
Some(Subcommand::ExportChainSpec(cmd)) => {
|
||||
let chain_spec = cli.load_spec(&cmd.chain)?;
|
||||
cmd.run(chain_spec)
|
||||
},
|
||||
|
||||
Some(Subcommand::ExportGenesisHead(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.sync_run(|mut config| {
|
||||
let partial = new_partial(&mut config, false)?;
|
||||
cmd.run(partial.client)
|
||||
})
|
||||
},
|
||||
Some(Subcommand::ExportGenesisWasm(cmd)) => {
|
||||
let runner = cli.create_runner(cmd)?;
|
||||
runner.sync_run(|config| cmd.run(&*config.chain_spec))
|
||||
},
|
||||
None => {
|
||||
let log_filters = cli.run.normalize().log_filters();
|
||||
let mut builder = pezsc_cli::LoggerBuilder::new(log_filters.unwrap_or_default());
|
||||
builder.with_colors(false);
|
||||
let _ = builder.init();
|
||||
|
||||
let collator_options = cli.run.collator_options();
|
||||
let tokio_runtime = pezsc_cli::build_runtime()?;
|
||||
let tokio_handle = tokio_runtime.handle();
|
||||
let teyrchain_config = cli
|
||||
.run
|
||||
.normalize()
|
||||
.create_configuration(&cli, tokio_handle.clone())
|
||||
.expect("Should be able to generate config");
|
||||
|
||||
let relay_chain_cli = RelayChainCli::new(
|
||||
&teyrchain_config,
|
||||
[RelayChainCli::executable_name()].iter().chain(cli.relaychain_args.iter()),
|
||||
);
|
||||
let tokio_handle = teyrchain_config.tokio_handle.clone();
|
||||
let relay_chain_config = BizinikiwiCli::create_configuration(
|
||||
&relay_chain_cli,
|
||||
&relay_chain_cli,
|
||||
tokio_handle,
|
||||
)
|
||||
.map_err(|err| format!("Relay chain argument error: {}", err))?;
|
||||
|
||||
tracing::info!(
|
||||
"Is collating: {}",
|
||||
if teyrchain_config.role.is_authority() { "yes" } else { "no" }
|
||||
);
|
||||
if cli.fail_pov_recovery {
|
||||
tracing::info!("PoV recovery failure enabled");
|
||||
}
|
||||
|
||||
let collator_key =
|
||||
teyrchain_config.role.is_authority().then(|| CollatorPair::generate().0);
|
||||
|
||||
let use_slot_based_collator = cli.authoring == AuthoringPolicy::SlotBased;
|
||||
let (mut task_manager, _, _, _, _, _) = tokio_runtime
|
||||
.block_on(async move {
|
||||
match relay_chain_config.network.network_backend {
|
||||
pezsc_network::config::NetworkBackendType::Libp2p =>
|
||||
cumulus_test_service::start_node_impl::<
|
||||
_,
|
||||
pezsc_network::NetworkWorker<_, _>,
|
||||
>(
|
||||
teyrchain_config,
|
||||
collator_key,
|
||||
relay_chain_config,
|
||||
cli.disable_block_announcements.then(wrap_announce_block),
|
||||
cli.fail_pov_recovery,
|
||||
|_| Ok(jsonrpsee::RpcModule::new(())),
|
||||
collator_options,
|
||||
true,
|
||||
use_slot_based_collator,
|
||||
)
|
||||
.await,
|
||||
pezsc_network::config::NetworkBackendType::Litep2p =>
|
||||
cumulus_test_service::start_node_impl::<
|
||||
_,
|
||||
pezsc_network::Litep2pNetworkBackend,
|
||||
>(
|
||||
teyrchain_config,
|
||||
collator_key,
|
||||
relay_chain_config,
|
||||
cli.disable_block_announcements.then(wrap_announce_block),
|
||||
cli.fail_pov_recovery,
|
||||
|_| Ok(jsonrpsee::RpcModule::new(())),
|
||||
collator_options,
|
||||
true,
|
||||
use_slot_based_collator,
|
||||
)
|
||||
.await,
|
||||
}
|
||||
})
|
||||
.expect("could not create Pezcumulus test service");
|
||||
|
||||
tokio_runtime
|
||||
.block_on(task_manager.future())
|
||||
.expect("Could not run service to completion");
|
||||
Ok(())
|
||||
},
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user