mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-04-27 09:17:58 +00:00
David
2de7e51c2a
* Comment out browser stuff * Remove browser stuff * Remove more wasm transport code * Remove ExtTransport and rework how telemetry initialises. * Change (most) wasm-timer using code to use std::time * Rename CI-job * Aura does not compile for wasm * Remove testing in the browser on CI * Update README * Leave `StreamSink` be * fmt
134 lines
4.4 KiB
Rust
134 lines
4.4 KiB
Rust
// This file is part of Substrate.
|
|
|
|
// Copyright (C) 2020-2021 Parity Technologies (UK) Ltd.
|
|
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
|
|
|
|
// This program 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.
|
|
|
|
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
use futures::FutureExt;
|
|
use sc_client_api::execution_extensions::ExecutionStrategies;
|
|
use sc_executor::WasmExecutionMethod;
|
|
use sc_informant::OutputFormat;
|
|
use sc_network::{
|
|
config::{NetworkConfiguration, Role, TransportConfig},
|
|
multiaddr,
|
|
};
|
|
use sc_service::{
|
|
config::KeystoreConfig, BasePath, ChainSpec, Configuration, DatabaseSource, KeepBlocks,
|
|
TaskExecutor, TaskType, TransactionStorageMode,
|
|
};
|
|
use sp_keyring::sr25519::Keyring::Alice;
|
|
use tokio::runtime::Handle;
|
|
|
|
pub use sc_cli::build_runtime;
|
|
|
|
/// Base db path gotten from env
|
|
pub fn base_path() -> BasePath {
|
|
if let Some(base) = std::env::var("DB_BASE_PATH").ok() {
|
|
BasePath::new(base)
|
|
} else {
|
|
BasePath::new_temp_dir().expect("couldn't create a temp dir")
|
|
}
|
|
}
|
|
|
|
/// Produces a default configuration object, suitable for use with most set ups.
|
|
pub fn default_config(
|
|
task_executor: TaskExecutor,
|
|
mut chain_spec: Box<dyn ChainSpec>,
|
|
) -> Configuration {
|
|
let base_path = base_path();
|
|
let root_path = base_path.path().to_path_buf().join("chains").join(chain_spec.id());
|
|
|
|
let storage = chain_spec
|
|
.as_storage_builder()
|
|
.build_storage()
|
|
.expect("could not build storage");
|
|
|
|
chain_spec.set_storage(storage);
|
|
let key_seed = Alice.to_seed();
|
|
|
|
let mut network_config = NetworkConfiguration::new(
|
|
format!("Test Node for: {}", key_seed),
|
|
"network/test/0.1",
|
|
Default::default(),
|
|
None,
|
|
);
|
|
let informant_output_format = OutputFormat { enable_color: false };
|
|
network_config.allow_non_globals_in_dht = true;
|
|
|
|
network_config.listen_addresses.push(multiaddr::Protocol::Memory(0).into());
|
|
|
|
network_config.transport = TransportConfig::MemoryOnly;
|
|
|
|
Configuration {
|
|
impl_name: "test-node".to_string(),
|
|
impl_version: "0.1".to_string(),
|
|
role: Role::Authority,
|
|
task_executor: task_executor.into(),
|
|
transaction_pool: Default::default(),
|
|
network: network_config,
|
|
keystore: KeystoreConfig::Path { path: root_path.join("key"), password: None },
|
|
database: DatabaseSource::RocksDb { path: root_path.join("db"), cache_size: 128 },
|
|
state_cache_size: 16777216,
|
|
state_cache_child_ratio: None,
|
|
chain_spec,
|
|
wasm_method: WasmExecutionMethod::Interpreted,
|
|
execution_strategies: ExecutionStrategies {
|
|
syncing: sc_client_api::ExecutionStrategy::AlwaysWasm,
|
|
importing: sc_client_api::ExecutionStrategy::AlwaysWasm,
|
|
block_construction: sc_client_api::ExecutionStrategy::AlwaysWasm,
|
|
offchain_worker: sc_client_api::ExecutionStrategy::AlwaysWasm,
|
|
other: sc_client_api::ExecutionStrategy::AlwaysWasm,
|
|
},
|
|
rpc_http: None,
|
|
rpc_ws: None,
|
|
rpc_ipc: None,
|
|
rpc_ws_max_connections: None,
|
|
rpc_http_threads: None,
|
|
rpc_cors: None,
|
|
rpc_methods: Default::default(),
|
|
rpc_max_payload: None,
|
|
prometheus_config: None,
|
|
telemetry_endpoints: None,
|
|
default_heap_pages: None,
|
|
offchain_worker: Default::default(),
|
|
force_authoring: false,
|
|
disable_grandpa: false,
|
|
dev_key_seed: Some(key_seed),
|
|
tracing_targets: None,
|
|
tracing_receiver: Default::default(),
|
|
max_runtime_instances: 8,
|
|
announce_block: true,
|
|
base_path: Some(base_path),
|
|
wasm_runtime_overrides: None,
|
|
informant_output_format,
|
|
disable_log_reloading: false,
|
|
keystore_remote: None,
|
|
keep_blocks: KeepBlocks::All,
|
|
state_pruning: Default::default(),
|
|
transaction_storage: TransactionStorageMode::BlockBody,
|
|
}
|
|
}
|
|
|
|
/// Produce a task executor given a handle to a tokio runtime
|
|
pub fn task_executor(handle: Handle) -> TaskExecutor {
|
|
let task_executor = move |fut, task_type| match task_type {
|
|
TaskType::Async => handle.spawn(fut).map(drop),
|
|
TaskType::Blocking =>
|
|
handle.spawn_blocking(move || futures::executor::block_on(fut)).map(drop),
|
|
};
|
|
|
|
task_executor.into()
|
|
}
|