Merge pull request #143 from OriginTrail/release/testnet

Mainnet Release 1.6.0

Author: Mihajlo-Pavlovic

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "neuroweb-node"
-version = "1.5.2"
+version = "1.6.0"
 authors = ["TraceLabs"]
 description = "NeuroWeb - Cumulus FRAME-based Substrate Node"
 license = "GPL-3.0-only"

Cargo.toml

@@ -8,8 +8,7 @@ use sp_runtime::traits::{IdentifyAccount, Verify};
 use std::{collections::BTreeMap, str::FromStr};
 
 /// Specialized `ChainSpec` for the normal parachain runtime.
-pub type ChainSpec =
-    sc_service::GenericChainSpec<neuroweb_runtime::RuntimeGenesisConfig, Extensions>;
+pub type ChainSpec = sc_service::GenericChainSpec<Extensions>;
 
 /// The default XCM version to set in genesis config.
 const SAFE_XCM_VERSION: u32 = xcm::prelude::XCM_VERSION;
@@ -193,6 +192,7 @@ fn testnet_genesis(
                     )
                 })
                 .collect(),
+            non_authority_keys: vec![],
         },
         // no need to pass anything to aura, in fact it will panic if we do. Session will take care
         // of this.

node/Cargo.toml

@@ -9,14 +9,13 @@ use log::info;
 use neuroweb_runtime::Block;
 use sc_cli::{
     ChainSpec, CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams,
-    NetworkParams, Result, SharedParams, SubstrateCli,
+    NetworkParams, Result, RpcEndpoint, SharedParams, SubstrateCli,
 };
 use sc_service::{
     config::{BasePath, PrometheusConfig},
     PartialComponents,
 };
 use sp_runtime::traits::AccountIdConversion;
-use std::net::SocketAddr;
 
 fn load_spec(id: &str) -> std::result::Result<Box<dyn ChainSpec>, String> {
     Ok(match id {
@@ -242,7 +241,10 @@ pub fn run() -> Result<()> {
                 let hwbench = (!cli.no_hardware_benchmarks)
                     .then_some(config.database.path().map(|database_path| {
                         let _ = std::fs::create_dir_all(&database_path);
-                        sc_sysinfo::gather_hwbench(Some(database_path))
+                        sc_sysinfo::gather_hwbench(
+                            Some(database_path),
+                            &SUBSTRATE_REFERENCE_HARDWARE,
+                        )
                     }))
                     .flatten();
 
@@ -339,7 +341,7 @@ impl CliConfiguration<Self> for RelayChainCli {
             .or_else(|| self.base_path.clone().map(Into::into)))
     }
 
-    fn rpc_addr(&self, default_listen_port: u16) -> Result<Option<SocketAddr>> {
+    fn rpc_addr(&self, default_listen_port: u16) -> Result<Option<Vec<RpcEndpoint>>> {
         self.base.base.rpc_addr(default_listen_port)
     }
 
@@ -353,15 +355,9 @@ impl CliConfiguration<Self> for RelayChainCli {
             .prometheus_config(default_listen_port, chain_spec)
     }
 
-    fn init<F>(
-        &self,
-        _support_url: &String,
-        _impl_version: &String,
-        _logger_hook: F,
-        _config: &sc_service::Configuration,
-    ) -> Result<()>
+    fn init<F>(&self, _support_url: &String, _impl_version: &String, _logger_hook: F) -> Result<()>
     where
-        F: FnOnce(&mut sc_cli::LoggerBuilder, &sc_service::Configuration),
+        F: FnOnce(&mut sc_cli::LoggerBuilder),
     {
         unreachable!("PolkadotCli is never initialized; qed");
     }

node/src/chain_spec.rs

@@ -22,7 +22,7 @@ use sc_client_api::{
 };
 use sc_network::service::traits::NetworkService;
 use sc_network_sync::SyncingService;
-pub use sc_rpc::{DenyUnsafe, SubscriptionTaskExecutor};
+pub use sc_rpc::SubscriptionTaskExecutor;
 use sc_transaction_pool::{ChainApi, Pool};
 use sc_transaction_pool_api::TransactionPool;
 use sp_api::{CallApiAt, ProvideRuntimeApi};
@@ -44,8 +44,6 @@ pub struct FullDeps<C, P, A: ChainApi> {
     pub graph: Arc<Pool<A>>,
     /// Chain syncing service
     pub sync: Arc<SyncingService<Block>>,
-    /// Whether to deny unsafe calls
-    pub deny_unsafe: DenyUnsafe,
     /// The Node authority flag
     pub is_authority: bool,
     /// Network service
@@ -107,7 +105,6 @@ where
         client,
         pool,
         graph,
-        deny_unsafe,
         network,
         backend,
         is_authority,
@@ -119,7 +116,7 @@ where
         block_data_cache,
     } = deps;
 
-    module.merge(System::new(client.clone(), pool.clone(), deny_unsafe).into_rpc())?;
+    module.merge(System::new(client.clone(), pool.clone()).into_rpc())?;
     module.merge(TransactionPayment::new(client.clone()).into_rpc())?;
 
     let signers = Vec::new();

node/src/command.rs

@@ -29,7 +29,6 @@ use sc_client_api::BlockchainEvents;
 use sc_consensus::ImportQueue;
 use sc_executor::{HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY};
 use sc_network::{NetworkBackend, NetworkBlock};
-use sc_network_sync::SyncingService;
 use sc_service::{Configuration, PartialComponents, TFullBackend, TFullClient, TaskManager};
 use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};
 use sp_keystore::KeystorePtr;
@@ -118,17 +117,18 @@ pub fn new_partial(
         .transpose()?;
 
     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.wasm_method)
+        .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.max_runtime_instances)
-        .with_runtime_cache_size(config.runtime_cache_size)
+        .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) =
@@ -222,12 +222,14 @@ where
     .map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?;
 
     let validator = parachain_config.role.is_authority();
-    let prometheus_registry = parachain_config.prometheus_registry().cloned();
     let is_authority = parachain_config.role.is_authority();
     let transaction_pool = params.transaction_pool.clone();
     let import_queue_service = params.import_queue.service();
-    let net_config =
-        sc_network::config::FullNetworkConfiguration::<_, _, N>::new(&parachain_config.network);
+    let prometheus_registry = parachain_config.prometheus_registry().cloned();
+    let net_config = sc_network::config::FullNetworkConfiguration::<_, _, N>::new(
+        &parachain_config.network,
+        prometheus_registry.clone(),
+    );
 
     let (network, system_rpc_tx, tx_handler_controller, start_network, sync_service) =
         build_network(BuildNetworkParams {
@@ -318,13 +320,12 @@ where
         let frontier_backend = frontier_backend.clone();
         let pubsub_notification_sinks = pubsub_notification_sinks.clone();
 
-        Box::new(move |deny_unsafe, subscription_task_executor| {
+        Box::new(move |subscription_task_executor| {
             let deps = crate::rpc::FullDeps {
                 client: client.clone(),
                 pool: transaction_pool.clone(),
                 graph: transaction_pool.pool().clone(),
                 sync: sync.clone(),
-                deny_unsafe,
                 is_authority,
                 network: network.clone(),
                 backend: frontier_backend.clone(),
@@ -369,7 +370,7 @@ where
         // Here you can check whether the hardware meets your chains' requirements. Putting a link
         // in there and swapping out the requirements for your own are probably a good idea. The
         // requirements for a para-chain are dictated by its relay-chain.
-        match SUBSTRATE_REFERENCE_HARDWARE.check_hardware(&hwbench) {
+        match SUBSTRATE_REFERENCE_HARDWARE.check_hardware(&hwbench, validator) {
             Err(err) if validator => {
                 log::warn!(
 				"⚠️  The hardware does not meet the minimal requirements {} for role 'Authority' find out more at:\n\
@@ -487,7 +488,7 @@ fn start_aura_consensus(
     task_manager: &TaskManager,
     relay_chain_interface: Arc<dyn RelayChainInterface>,
     transaction_pool: Arc<sc_transaction_pool::FullPool<Block, ParachainClient>>,
-    sync_oracle: Arc<SyncingService<Block>>,
+    sync_service: Arc<sc_network_sync::SyncingService<Block>>,
     keystore: KeystorePtr,
     para_id: ParaId,
     collator_key: CollatorPair,
@@ -511,8 +512,8 @@ fn start_aura_consensus(
         .map_err(|e| sc_service::Error::Application(Box::new(e)))?;
 
     let announce_block = {
-        let sync_service = sync_oracle.clone();
-        Arc::new(move |hash, data| sync_service.announce_block(hash, data))
+        let sync = sync_service.clone();
+        Arc::new(move |hash, data| sync.announce_block(hash, data))
     };
 
     let collator_service = cumulus_client_collator::service::CollatorService::new(
@@ -522,33 +523,31 @@ fn start_aura_consensus(
         client.clone(),
     );
 
-    let fut =
-        aura::run::<Block, sp_consensus_aura::sr25519::AuthorityPair, _, _, _, _, _, _, _, _, _>(
-            AuraParams {
-                create_inherent_data_providers: move |_, ()| async move { Ok(()) },
-                block_import: block_import.clone(),
-                para_client: client.clone(),
-                para_backend: backend.clone(),
-                relay_client: relay_chain_interface.clone(),
-                code_hash_provider: move |block_hash| {
-                    client
-                        .code_at(block_hash)
-                        .ok()
-                        .map(|c| ValidationCode::from(c).hash())
-                },
-                sync_oracle: sync_oracle.clone(),
-                keystore,
-                collator_key,
-                para_id,
-                overseer_handle,
-                relay_chain_slot_duration: Duration::from_secs(6),
-                proposer: cumulus_client_consensus_proposer::Proposer::new(proposer_factory),
-                collator_service,
-                // We got around 500ms for proposing
-                authoring_duration: Duration::from_millis(1500),
-                reinitialize: false,
+    let fut = aura::run::<Block, sp_consensus_aura::sr25519::AuthorityPair, _, _, _, _, _, _, _, _>(
+        AuraParams {
+            create_inherent_data_providers: move |_, ()| async move { Ok(()) },
+            block_import: block_import.clone(),
+            para_client: client.clone(),
+            para_backend: backend.clone(),
+            relay_client: relay_chain_interface.clone(),
+            code_hash_provider: move |block_hash| {
+                client
+                    .code_at(block_hash)
+                    .ok()
+                    .map(|c| ValidationCode::from(c).hash())
             },
-        );
+            keystore,
+            collator_key,
+            para_id,
+            overseer_handle,
+            relay_chain_slot_duration: Duration::from_secs(6),
+            proposer: cumulus_client_consensus_proposer::Proposer::new(proposer_factory),
+            collator_service,
+            // We got around 500ms for proposing
+            authoring_duration: Duration::from_millis(1500),
+            reinitialize: false,
+        },
+    );
 
     task_manager
         .spawn_essential_handle()

node/src/rpc.rs

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-wrapper"
-version = "0.1.0"
+version = "1.1.0"
 description = "TRAC token wrapper pallet for converting between foreign and local TRAC assets"
 authors.workspace = true
 edition.workspace = true

node/src/service.rs

@@ -233,6 +233,7 @@ pub mod pallet {
                 local_trac_asset_id,
                 &who,
                 amount,
+                frame_support::traits::tokens::Preservation::Expendable,
                 frame_support::traits::tokens::Precision::Exact,
                 frame_support::traits::tokens::Fortitude::Polite,
             )
@@ -281,6 +282,7 @@ pub mod pallet {
 
     impl<T: Config> Pallet<T> {
         /// Get the account ID of the pallet
+        /// Translates to gJpDhAL2bdaamftxXHXTbNxL6EZcXrgSmeLJzn2ficD3n4oWV
         pub fn pallet_account_id() -> T::AccountId {
             T::PalletId::get().into_account_truncating()
         }

pallets/wrapper/Cargo.toml

@@ -111,7 +111,7 @@ impl pallet_assets::Config for Test {
 }
 
 parameter_types! {
-    pub const WrapperPalletId: PalletId = PalletId(*b"pwrapper");
+    pub const WrapperPalletId: PalletId = PalletId(*b"p/wrpper");
     pub const LocalTracAssetId: AssetId = 1;
     pub const ForeignTracAssetId: AssetId = 2;
 }
@@ -165,6 +165,7 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
             // Give BOB some foreign TRAC
             (ForeignTracAssetId::get(), BOB, 500000),
         ],
+        next_asset_id: None,
     }
     .assimilate_storage(&mut t)
     .unwrap();