Polkadot v1.6.0 upgrade

client/consensus/src/consensus_orchestrator.rs

@@ -68,10 +68,7 @@ use {
         time::{Duration, Instant},
     },
 };
-pub use {
-    sc_consensus_aura::{slot_duration, AuraVerifier, BuildAuraWorkerParams, SlotProportion},
-    sc_consensus_slots::InherentDataProviderExt,
-};
+pub use {sc_consensus_aura::SlotProportion, sc_consensus_slots::InherentDataProviderExt};
 
 const LOG_TARGET: &str = "aura::tanssi";
 

client/consensus/src/manual_seal.rs

@@ -24,13 +24,16 @@ use {
     sc_client_api::{AuxStore, UsageProvider},
     sc_consensus::BlockImportParams,
     sc_consensus_manual_seal::{ConsensusDataProvider, Error},
-    sp_api::{HeaderT, ProvideRuntimeApi},
+    sp_api::ProvideRuntimeApi,
     sp_blockchain::{HeaderBackend, HeaderMetadata},
     sp_consensus_aura::{digests::CompatibleDigestItem, AuraApi, Slot, SlotDuration},
     sp_core::Pair,
     sp_inherents::InherentData,
     sp_keystore::KeystorePtr,
-    sp_runtime::{traits::Block as BlockT, Digest, DigestItem},
+    sp_runtime::{
+        traits::{Block as BlockT, Header as HeaderT},
+        Digest, DigestItem,
+    },
     sp_timestamp::TimestampInherentData,
     std::{marker::PhantomData, sync::Arc},
     tp_consensus::TanssiAuthorityAssignmentApi,

client/consensus/src/tests.rs

@@ -34,7 +34,7 @@ use {
         CompatibleDigestItem, NimbusId, NimbusPair, NIMBUS_ENGINE_ID, NIMBUS_KEY_ID,
     },
     parking_lot::Mutex,
-    sc_block_builder::BlockBuilderProvider,
+    sc_block_builder::BlockBuilderBuilder,
     sc_client_api::{BlockchainEvents, HeaderBackend},
     sc_consensus::{BoxJustificationImport, ForkChoiceStrategy},
     sc_consensus_aura::SlotProportion,
@@ -212,7 +212,14 @@ impl Proposer<TestBlock> for DummyProposer {
         _: Duration,
         _: Option<usize>,
     ) -> Self::Proposal {
-        let r = self.1.new_block(digests).unwrap().build();
+        let r = BlockBuilderBuilder::new(&*self.1)
+            .on_parent_block(self.1.chain_info().best_hash)
+            .fetch_parent_block_number(&*self.1)
+            .unwrap()
+            .with_inherent_digests(digests)
+            .build()
+            .unwrap()
+            .build();
 
         futures::future::ready(r.map(|b| Proposal {
             block: b.block,

client/node-common/src/command.rs

@@ -0,0 +1,58 @@
+// Copyright (C) Moondance Labs Ltd.
+// This file is part of Tanssi.
+
+// Tanssi 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.
+
+// Tanssi 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 Tanssi.  If not, see <http://www.gnu.org/licenses/>.
+
+use parity_scale_codec::Encode;
+use sc_chain_spec::ChainSpec;
+use sp_runtime::{
+    traits::{Block as BlockT, Hash as HashT, Header as HeaderT, Zero},
+    StateVersion,
+};
+
+/// Generate the genesis block from a given ChainSpec.
+pub fn generate_genesis_block<Block: BlockT>(
+    chain_spec: &dyn ChainSpec,
+    genesis_state_version: StateVersion,
+) -> Result<Block, String> {
+    let storage = chain_spec.build_storage()?;
+
+    let child_roots = storage.children_default.iter().map(|(sk, child_content)| {
+        let state_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
+            child_content.data.clone().into_iter().collect(),
+            genesis_state_version,
+        );
+        (sk.clone(), state_root.encode())
+    });
+    let state_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
+        storage.top.clone().into_iter().chain(child_roots).collect(),
+        genesis_state_version,
+    );
+
+    let extrinsics_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
+        Vec::new(),
+        genesis_state_version,
+    );
+
+    Ok(Block::new(
+        <<Block as BlockT>::Header as HeaderT>::new(
+            Zero::zero(),
+            extrinsics_root,
+            state_root,
+            Default::default(),
+            Default::default(),
+        ),
+        Default::default(),
+    ))
+}

client/node-common/src/lib.rs

@@ -15,3 +15,5 @@
 // along with Tanssi.  If not, see <http://www.gnu.org/licenses/>.
 
 pub mod service;
+
+pub mod command;

client/node-common/src/service.rs

@@ -521,10 +521,14 @@ 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.
-            if collator && !SUBSTRATE_REFERENCE_HARDWARE.check_hardware(hwbench) {
-                log::warn!(
-                    "⚠️  The hardware does not meet the minimal requirements for role 'Authority'."
+            match SUBSTRATE_REFERENCE_HARDWARE.check_hardware(&hwbench) {
+                Err(err) if collator => {
+                    log::warn!(
+                    "⚠️  The hardware does not meet the minimal requirements {} for role 'Authority'.",
+                    err
                 );
+                }
+                _ => {}
             }
 
             if let Some(ref mut telemetry) = telemetry {

container-chains/templates/frontier/node/Cargo.toml

@@ -18,6 +18,7 @@ jsonrpsee = { workspace = true, features = [ "server" ] }
 log = { workspace = true }
 parity-scale-codec = { workspace = true }
 serde = { workspace = true, features = [ "derive" ] }
+serde_json = { workspace = true }
 url = { workspace = true }
 
 # Local
@@ -90,7 +91,7 @@ cumulus-client-consensus-common = { workspace = true }
 cumulus-client-network = { workspace = true }
 cumulus-client-service = { workspace = true }
 cumulus-primitives-core = { workspace = true }
-cumulus-primitives-parachain-inherent = { workspace = true }
+cumulus-client-parachain-inherent = { workspace = true }
 cumulus-relay-chain-interface = { workspace = true }
 cumulus-test-relay-sproof-builder = { workspace = true }
 

container-chains/templates/frontier/node/src/chain_spec.rs

@@ -73,29 +73,25 @@ pub fn development_config(para_id: ParaId, boot_nodes: Vec<String>) -> ChainSpec
         })
         .collect();
 
-    ChainSpec::from_genesis(
-        // Name
-        "Development",
-        // ID
-        "dev",
-        ChainType::Development,
-        move || {
-            testnet_genesis(
-                default_funded_accounts.clone(),
-                para_id,
-                AccountId::from(hex!("f24FF3a9CF04c71Dbc94D0b566f7A27B94566cac")), // Alith
-            )
-        },
-        boot_nodes,
-        None,
-        None,
-        None,
-        Some(properties),
+    ChainSpec::builder(
+        container_chain_template_frontier_runtime::WASM_BINARY
+            .expect("WASM binary was not built, please build it!"),
         Extensions {
             relay_chain: "rococo-local".into(), // You MUST set this to the correct network!
             para_id: para_id.into(),
         },
     )
+    .with_name("Development")
+    .with_id("dev")
+    .with_chain_type(ChainType::Development)
+    .with_genesis_config(testnet_genesis(
+        default_funded_accounts.clone(),
+        para_id,
+        AccountId::from(hex!("f24FF3a9CF04c71Dbc94D0b566f7A27B94566cac")), // Alith
+    ))
+    .with_properties(properties)
+    .with_boot_nodes(boot_nodes)
+    .build()
 }
 
 pub fn local_testnet_config(para_id: ParaId, boot_nodes: Vec<String>) -> ChainSpec {
@@ -105,7 +101,7 @@ pub fn local_testnet_config(para_id: ParaId, boot_nodes: Vec<String>) -> ChainSp
     properties.insert("tokenDecimals".into(), 18.into());
     properties.insert("ss58Format".into(), 42.into());
     properties.insert("isEthereum".into(), true.into());
-    let protocol_id = Some(format!("container-chain-{}", para_id));
+    let protocol_id = format!("container-chain-{}", para_id);
 
     let mut default_funded_accounts = pre_funded_accounts();
     default_funded_accounts.sort();
@@ -118,55 +114,41 @@ pub fn local_testnet_config(para_id: ParaId, boot_nodes: Vec<String>) -> ChainSp
         })
         .collect();
 
-    ChainSpec::from_genesis(
-        // Name
-        &format!("Frontier Container {}", para_id),
-        // ID
-        &format!("frontier_container_{}", para_id),
-        ChainType::Local,
-        move || {
-            testnet_genesis(
-                default_funded_accounts.clone(),
-                para_id,
-                AccountId::from(hex!("f24FF3a9CF04c71Dbc94D0b566f7A27B94566cac")), // Alith
-            )
-        },
-        // Bootnodes
-        boot_nodes,
-        // Telemetry
-        None,
-        // Protocol ID
-        protocol_id.as_deref(),
-        // Fork ID
-        None,
-        // Properties
-        Some(properties),
-        // Extensions
+    ChainSpec::builder(
+        container_chain_template_frontier_runtime::WASM_BINARY
+            .expect("WASM binary was not built, please build it!"),
         Extensions {
             relay_chain: "rococo-local".into(), // You MUST set this to the correct network!
             para_id: para_id.into(),
         },
     )
+    .with_name(&format!("Frontier Container {}", para_id))
+    .with_id(&format!("frontier_container_{}", para_id))
+    .with_chain_type(ChainType::Local)
+    .with_genesis_config(testnet_genesis(
+        default_funded_accounts.clone(),
+        para_id,
+        AccountId::from(hex!("f24FF3a9CF04c71Dbc94D0b566f7A27B94566cac")), // Alith
+    ))
+    .with_properties(properties)
+    .with_protocol_id(&protocol_id)
+    .with_boot_nodes(boot_nodes)
+    .build()
 }
 
 fn testnet_genesis(
     endowed_accounts: Vec<AccountId>,
     id: ParaId,
     root_key: AccountId,
-) -> container_chain_template_frontier_runtime::RuntimeGenesisConfig {
+) -> serde_json::Value {
     // This is the simplest bytecode to revert without returning any data.
     // We will pre-deploy it under all of our precompiles to ensure they can be called from
     // within contracts.
     // (PUSH1 0x00 PUSH1 0x00 REVERT)
     let revert_bytecode = vec![0x60, 0x00, 0x60, 0x00, 0xFD];
 
-    container_chain_template_frontier_runtime::RuntimeGenesisConfig {
-        system: container_chain_template_frontier_runtime::SystemConfig {
-            code: container_chain_template_frontier_runtime::WASM_BINARY
-                .expect("WASM binary was not build, please build it!")
-                .to_vec(),
-            ..Default::default()
-        },
+    let g = container_chain_template_frontier_runtime::RuntimeGenesisConfig {
+        system: Default::default(),
         balances: container_chain_template_frontier_runtime::BalancesConfig {
             balances: endowed_accounts
                 .iter()
@@ -225,7 +207,9 @@ fn testnet_genesis(
         // This should initialize it to whatever we have set in the pallet
         polkadot_xcm: PolkadotXcmConfig::default(),
         tx_pause: Default::default(),
-    }
+    };
+
+    serde_json::to_value(&g).unwrap()
 }
 
 /// Get pre-funded accounts

container-chains/templates/frontier/node/src/cli.rs

@@ -47,7 +47,8 @@ pub enum Subcommand {
     PurgeChain(cumulus_client_cli::PurgeChainCmd),
 
     /// Export the genesis state of the parachain.
-    ExportGenesisState(cumulus_client_cli::ExportGenesisStateCommand),
+    #[command(alias = "export-genesis-state")]
+    ExportGenesisHead(cumulus_client_cli::ExportGenesisHeadCommand),
 
     /// Export the genesis wasm of the parachain.
     ExportGenesisWasm(cumulus_client_cli::ExportGenesisWasmCommand),

container-chains/templates/frontier/node/src/command.rs

@@ -21,10 +21,10 @@ use {
         service::{self, frontier_database_dir, NodeConfig},
     },
     container_chain_template_frontier_runtime::Block,
-    cumulus_client_cli::generate_genesis_block,
     cumulus_primitives_core::ParaId,
     frame_benchmarking_cli::{BenchmarkCmd, SUBSTRATE_REFERENCE_HARDWARE},
     log::{info, warn},
+    node_common::command::generate_genesis_block,
     node_common::service::NodeBuilderConfig as _,
     parity_scale_codec::Encode,
     polkadot_cli::IdentifyVariant,
@@ -235,11 +235,11 @@ pub fn run() -> Result<()> {
                 cmd.run(config, polkadot_config)
             })
         }
-        Some(Subcommand::ExportGenesisState(cmd)) => {
+        Some(Subcommand::ExportGenesisHead(cmd)) => {
             let runner = cli.create_runner(cmd)?;
             runner.sync_run(|mut config| {
                 let partials = NodeConfig::new_builder(&mut config, None)?;
-                cmd.run(&*config.chain_spec, &*partials.client)
+                cmd.run(partials.client)
             })
         }
         Some(Subcommand::ExportGenesisWasm(cmd)) => {

container-chains/templates/frontier/node/src/eth.rs

@@ -14,11 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Tanssi.  If not, see <http://www.gnu.org/licenses/>.
 
-// Frontier
-pub use {
-    fc_consensus::FrontierBlockImport,
-    fc_rpc_core::types::{FeeHistoryCache, FeeHistoryCacheLimit, FilterPool},
-};
 // Local
 use container_chain_template_frontier_runtime::opaque::Block;
 

container-chains/templates/frontier/node/src/rpc/eth.rs

@@ -25,7 +25,7 @@ use {
 // Frontier
 use fc_db::Backend as FrontierBackend;
 pub use {
-    fc_rpc::{EthBlockDataCacheTask, EthConfig, OverrideHandle, StorageOverride},
+    fc_rpc::{EthBlockDataCacheTask, OverrideHandle},
     fc_rpc_core::types::{FeeHistoryCache, FeeHistoryCacheLimit, FilterPool},
     fc_storage::overrides_handle,
 };

container-chains/templates/frontier/node/src/rpc/mod.rs

@@ -25,8 +25,8 @@ pub use sc_rpc::{DenyUnsafe, SubscriptionTaskExecutor};
 
 use {
     container_chain_template_frontier_runtime::{opaque::Block, AccountId, Hash, Index},
+    cumulus_client_parachain_inherent::ParachainInherentData,
     cumulus_primitives_core::{ParaId, PersistedValidationData},
-    cumulus_primitives_parachain_inherent::ParachainInherentData,
     cumulus_test_relay_sproof_builder::RelayStateSproofBuilder,
     fc_rpc::{EthTask, TxPool},
     fc_rpc_core::TxPoolApiServer,
@@ -45,14 +45,14 @@ use {
     sc_service::TaskManager,
     sc_transaction_pool::{ChainApi, Pool},
     sc_transaction_pool_api::TransactionPool,
-    sp_api::{CallApiAt, HeaderT, ProvideRuntimeApi},
+    sp_api::{CallApiAt, ProvideRuntimeApi},
     sp_block_builder::BlockBuilder,
     sp_blockchain::{
         Backend as BlockchainBackend, Error as BlockChainError, HeaderBackend, HeaderMetadata,
     },
     sp_consensus_aura::SlotDuration,
     sp_core::H256,
-    sp_runtime::traits::{BlakeTwo256, Block as BlockT},
+    sp_runtime::traits::{BlakeTwo256, Block as BlockT, Header as HeaderT},
     std::{sync::Arc, time::Duration},
 };
 pub struct DefaultEthConfig<C, BE>(std::marker::PhantomData<(C, BE)>);

container-chains/templates/frontier/node/src/service.rs

@@ -22,11 +22,9 @@ use {
     container_chain_template_frontier_runtime::{opaque::Block, RuntimeApi},
     cumulus_client_cli::CollatorOptions,
     cumulus_client_consensus_common::ParachainBlockImport as TParachainBlockImport,
+    cumulus_client_parachain_inherent::{MockValidationDataInherentDataProvider, MockXcmConfig},
     cumulus_client_service::prepare_node_config,
     cumulus_primitives_core::{relay_chain::well_known_keys as RelayWellKnownKeys, ParaId},
-    cumulus_primitives_parachain_inherent::{
-        MockValidationDataInherentDataProvider, MockXcmConfig,
-    },
     fc_consensus::FrontierBlockImport,
     fc_db::DatabaseSource,
     fc_rpc_core::types::{FeeHistoryCache, FilterPool},