Polkadot v1.6.0 upgrade

client/consensus/Cargo.toml

@@ -37,8 +37,8 @@ cumulus-client-collator = { workspace = true }
 cumulus-client-consensus-aura = { workspace = true }
 cumulus-client-consensus-common = { workspace = true }
 cumulus-client-consensus-proposer = { workspace = true }
+cumulus-client-parachain-inherent = { workspace = true }
 cumulus-primitives-core = { workspace = true }
-cumulus-primitives-parachain-inherent = { workspace = true }
 cumulus-relay-chain-interface = { workspace = true }
 
 # Polkadot

client/consensus/src/collators.rs

@@ -19,10 +19,10 @@ pub mod basic;
 use cumulus_client_collator::service::ServiceInterface as CollatorServiceInterface;
 use cumulus_client_consensus_common::ParachainCandidate;
 use cumulus_client_consensus_proposer::ProposerInterface;
+use cumulus_client_parachain_inherent::{ParachainInherentData, ParachainInherentDataProvider};
 use cumulus_primitives_core::{
     relay_chain::Hash as PHash, DigestItem, ParachainBlockData, PersistedValidationData,
 };
-use cumulus_primitives_parachain_inherent::ParachainInherentData;
 use cumulus_relay_chain_interface::RelayChainInterface;
 use parity_scale_codec::{Codec, Encode};
 
@@ -113,7 +113,7 @@ where
         parent_hash: Block::Hash,
         _timestamp: impl Into<Option<Timestamp>>,
     ) -> Result<(ParachainInherentData, InherentData), Box<dyn Error + Send + Sync + 'static>> {
-        let paras_inherent_data = ParachainInherentData::create_at(
+        let paras_inherent_data = ParachainInherentDataProvider::create_at(
             relay_parent,
             &self.relay_client,
             validation_data,
@@ -158,12 +158,14 @@ where
         inherent_data: (ParachainInherentData, InherentData),
         proposal_duration: Duration,
         max_pov_size: usize,
-    ) -> Result<(Collation, ParachainBlockData<Block>, Block::Hash), Box<dyn Error + Send + 'static>>
-    {
+    ) -> Result<
+        Option<(Collation, ParachainBlockData<Block>, Block::Hash)>,
+        Box<dyn Error + Send + 'static>,
+    > {
         let mut digest = additional_pre_digest.into().unwrap_or_default();
         digest.append(&mut slot_claim.pre_digest);
 
-        let proposal = self
+        let maybe_proposal = self
             .proposer
             .propose(
                 &parent_header,
@@ -176,6 +178,11 @@ where
             .await
             .map_err(|e| Box::new(e) as Box<dyn Error + Send>)?;
 
+        let proposal = match maybe_proposal {
+            None => return Ok(None),
+            Some(p) => p,
+        };
+
         let sealed_importable = seal_tanssi::<_, P>(
             proposal.block,
             proposal.storage_changes,
@@ -223,7 +230,7 @@ where
                 );
             }
 
-            Ok((collation, block_data, post_hash))
+            Ok(Some((collation, block_data, post_hash)))
         } else {
             Err(
                 Box::<dyn Error + Send + Sync>::from("Unable to produce collation")

client/consensus/src/collators/basic.rs

@@ -223,7 +223,7 @@ where
                     .await
             );
 
-            let (collation, _, post_hash) = try_request!(
+            let maybe_collation = try_request!(
                 collator
                     .collate(
                         &parent_header,
@@ -240,11 +240,17 @@ where
                     .await
             );
 
-            let result_sender = Some(collator.collator_service().announce_with_barrier(post_hash));
-            request.complete(Some(CollationResult {
-                collation,
-                result_sender,
-            }));
+            if let Some((collation, _, post_hash)) = maybe_collation {
+                let result_sender =
+                    Some(collator.collator_service().announce_with_barrier(post_hash));
+                request.complete(Some(CollationResult {
+                    collation,
+                    result_sender,
+                }));
+            } else {
+                request.complete(None);
+                tracing::debug!(target: crate::LOG_TARGET, "No block proposal");
+            }
         }
     }
 }

client/consensus/src/consensus_orchestrator.rs

@@ -29,11 +29,6 @@ use {
     sp_runtime::traits::Block as BlockT,
 };
 
-pub use {
-    sc_consensus_aura::{slot_duration, AuraVerifier, BuildAuraWorkerParams, SlotProportion},
-    sc_consensus_slots::InherentDataProviderExt,
-};
-
 #[async_trait::async_trait]
 pub trait RetrieveAuthoritiesFromOrchestrator<Block: BlockT, ExtraArgs, A>: Send + Sync {
     /// Create the inherent data providers at the given `parent` block using the given `extra_args`.

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

@@ -43,7 +43,7 @@ use {
     polkadot_primitives::{
         Hash as PHash, OccupiedCoreAssumption, PersistedValidationData, ValidatorId,
     },
-    sc_block_builder::BlockBuilderProvider,
+    sc_block_builder::BlockBuilderBuilder,
     sc_client_api::HeaderBackend,
     sc_consensus::{BoxJustificationImport, ForkChoiceStrategy},
     sc_keystore::LocalKeystore,
@@ -373,7 +373,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();
         let (_relay_parent_storage_root, proof) =
             RelayStateSproofBuilder::default().into_state_root_and_proof();
 
@@ -636,6 +643,7 @@ async fn collate_returns_correct_block() {
         )
         .await
         .unwrap()
+        .unwrap()
         .1;
 
     // The returned block should be imported and we should be able to get its header by now.

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

@@ -549,10 +549,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, features = [ "arbitrary_precision" ]}
 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 }