Implementation of RFC-123

cumulus/client/consensus/aura/src/collators/basic.rs

@@ -175,12 +175,18 @@ where
 				continue;
 			}
 
-			let Ok(Some(code)) =
-				params.para_client.state_at(parent_hash).map_err(drop).and_then(|s| {
-					s.storage(&sp_core::storage::well_known_keys::CODE).map_err(drop)
-				})
-			else {
-				continue;
+			let code = {
+				let Ok(state) = params.para_client.state_at(parent_hash) else { continue };
+				let Ok(pending) = state.storage(&sp_core::storage::well_known_keys::PENDING_CODE)
+				else {
+					continue;
+				};
+				let Some(code) = pending.or_else(|| {
+					state.storage(&sp_core::storage::well_known_keys::CODE).ok().flatten()
+				}) else {
+					continue;
+				};
+				code
 			};
 
 			super::check_validation_code_or_log(

cumulus/client/relay-chain-inprocess-interface/src/lib.rs

@@ -86,7 +86,7 @@ impl RelayChainInProcessInterface {
 #[async_trait]
 impl RelayChainInterface for RelayChainInProcessInterface {
 	async fn version(&self, relay_parent: PHash) -> RelayChainResult<RuntimeVersion> {
-		Ok(self.full_client.runtime_version_at(relay_parent)?)
+		Ok(self.full_client.runtime_version_at(relay_parent, CallContext::Offchain)?)
 	}
 
 	async fn retrieve_dmq_contents(

cumulus/pallets/parachain-system/src/lib.rs

@@ -801,8 +801,8 @@ pub mod pallet {
 	/// applied.
 	///
 	/// As soon as the relay chain gives us the go-ahead signal, we will overwrite the
-	/// [`:code`][sp_core::storage::well_known_keys::CODE] which will result the next block process
-	/// with the new validation code. This concludes the upgrade process.
+	/// [`:pending_code`][sp_core::storage::well_known_keys::PENDING_CODE] which will result the
+	/// next block to be processed with the new validation code. This concludes the upgrade process.
 	#[pallet::storage]
 	pub type PendingValidationCode<T: Config> = StorageValue<_, Vec<u8>, ValueQuery>;
 

cumulus/pallets/parachain-system/src/mock.rs

@@ -455,6 +455,7 @@ impl BlockTests {
 			}
 
 			// clean up
+			System::maybe_apply_pending_code_upgrade();
 			let header = System::finalize();
 			let head_data = relay_chain::HeadData(header.encode());
 			parent_head_data = head_data.clone();

cumulus/pallets/parachain-system/src/tests.rs

@@ -872,7 +872,7 @@ fn hrmp_outbound_respects_used_bandwidth() {
 fn runtime_upgrade_events() {
 	BlockTests::new()
 		.with_relay_sproof_builder(|_, block_number, builder| {
-			if block_number > 1 {
+			if block_number == 2 {
 				builder.upgrade_go_ahead = Some(relay_chain::UpgradeGoAhead::GoAhead);
 			}
 		})
@@ -895,8 +895,9 @@ fn runtime_upgrade_events() {
 			|| {
 				let events = System::events();
 
+				// system_version 1: update_code_in_storage writes :code directly,
+				// emitting both the digest and CodeUpdated event in the same block.
 				assert_eq!(events[0].event, RuntimeEvent::System(frame_system::Event::CodeUpdated));
-
 				assert_eq!(
 					events[1].event,
 					RuntimeEvent::ParachainSystem(crate::Event::ValidationFunctionApplied {

cumulus/pallets/parachain-system/src/validate_block/implementation.rs

@@ -240,7 +240,13 @@ where
 			},
 		);
 
-		if overlay.storage(well_known_keys::CODE).is_some() && num_blocks > 1 {
+		let code_upgrade_detected =
+			if <PSC as frame_system::Config>::Version::get().system_version >= 3 {
+				overlay.storage(well_known_keys::PENDING_CODE).is_some()
+			} else {
+				overlay.storage(well_known_keys::CODE).is_some()
+			};
+		if code_upgrade_detected && num_blocks > 1 {
 			panic!("When applying a runtime upgrade, only one block per PoV is allowed. Received {num_blocks}.")
 		}
 		run_with_externalities_and_recorder::<B, _, _>(

cumulus/test/runtime/src/lib.rs

@@ -203,7 +203,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	impl_version: 1,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 1,
-	system_version: 1,
+	system_version: 3,
 };
 
 #[cfg(any(feature = "increment-spec-version", feature = "elastic-scaling"))]
@@ -217,7 +217,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	impl_version: 1,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 1,
-	system_version: 1,
+	system_version: 3,
 };
 
 pub const EPOCH_DURATION_IN_BLOCKS: u32 = 10 * MINUTES;

prdoc/pr_6029.prdoc

@@ -0,0 +1,45 @@
+title: Implementation of RFC-123
+doc:
+- audience: Node Dev
+  description: |-
+    Store a runtime upgrade in `:pending_code` before moving it to `:code` in the next block. It's gated by `system_version` of the runtime
+    and is activated for runtimes with `system_version` >= 3.
+crates:
+- name: sc-service
+  bump: major
+- name: cumulus-client-collator
+  bump: patch
+- name: cumulus-client-consensus-aura
+  bump: patch
+- name: cumulus-pallet-parachain-system
+  bump: patch
+- name: frame-executive
+  bump: minor
+- name: frame-support
+  bump: patch
+- name: frame-system
+  bump: minor
+- name: sp-core
+  bump: patch
+- name: sp-state-machine
+  bump: major
+- name: sp-storage
+  bump: minor
+- name: frame-benchmarking-cli
+  bump: patch
+- name: frame-system-benchmarking
+  bump: patch
+- name: cumulus-relay-chain-inprocess-interface
+  bump: patch
+- name: sc-client-api
+  bump: major
+- name: sc-rpc-spec-v2
+  bump: patch
+- name: sc-rpc
+  bump: patch
+- name: sp-api-proc-macro
+  bump: major
+- name: sp-api
+  bump: major
+- name: sp-version
+  bump: major

substrate/bin/node/bench/src/construct.rs

@@ -34,6 +34,7 @@ use sc_transaction_pool_api::{
 	TransactionStatusStreamFor, TxHash, TxInvalidityReportMap,
 };
 use sp_consensus::{Environment, ProposeArgs, Proposer};
+use sp_core::traits::CallContext;
 use sp_inherents::InherentDataProvider;
 use sp_runtime::OpaqueExtrinsic;
 
@@ -112,7 +113,7 @@ impl core::Benchmark for ConstructionBenchmark {
 
 		let _ = context
 			.client
-			.runtime_version_at(context.client.chain_info().genesis_hash)
+			.runtime_version_at(context.client.chain_info().genesis_hash, CallContext::Offchain)
 			.expect("Failed to get runtime version")
 			.spec_version;
 

substrate/bin/node/bench/src/import.rs

@@ -35,6 +35,7 @@ use std::borrow::Cow;
 use node_primitives::Block;
 use node_testing::bench::{BenchDb, BlockType, DatabaseType, KeyTypes};
 use sc_client_api::backend::Backend;
+use sp_core::traits::CallContext;
 
 use crate::{
 	common::SizeType,
@@ -99,7 +100,7 @@ impl core::Benchmark for ImportBenchmark {
 
 		let _ = context
 			.client
-			.runtime_version_at(context.client.chain_info().genesis_hash)
+			.runtime_version_at(context.client.chain_info().genesis_hash, CallContext::Offchain)
 			.expect("Failed to get runtime version")
 			.spec_version;
 

substrate/bin/node/bench/src/txpool.rs

@@ -27,6 +27,7 @@ use node_testing::bench::{BenchDb, BlockType, DatabaseType, KeyTypes};
 
 use sc_transaction_pool::BasicPool;
 use sc_transaction_pool_api::{TransactionPool, TransactionSource};
+use sp_core::traits::CallContext;
 
 use crate::core::{self, Mode, Path};
 
@@ -61,7 +62,7 @@ impl core::Benchmark for PoolBenchmark {
 
 		let _ = context
 			.client
-			.runtime_version_at(genesis_hash)
+			.runtime_version_at(genesis_hash, CallContext::Offchain)
 			.expect("Failed to get runtime version")
 			.spec_version;
 

substrate/bin/node/cli/src/service.rs

@@ -900,7 +900,7 @@ mod tests {
 	use sc_service_test::TestNetNode;
 	use sc_transaction_pool_api::ChainEvent;
 	use sp_consensus::{BlockOrigin, Environment, Proposer};
-	use sp_core::crypto::Pair;
+	use sp_core::{crypto::Pair, traits::CallContext};
 	use sp_inherents::InherentDataProvider;
 	use sp_keyring::Sr25519Keyring;
 	use sp_keystore::KeystorePtr;
@@ -1081,7 +1081,10 @@ mod tests {
 				let genesis_hash = service.client().block_hash(0).unwrap().unwrap();
 				let best_hash = service.client().chain_info().best_hash;
 				let (spec_version, transaction_version) = {
-					let version = service.client().runtime_version_at(best_hash).unwrap();
+					let version = service
+						.client()
+						.runtime_version_at(best_hash, CallContext::Offchain)
+						.unwrap();
 					(version.spec_version, version.transaction_version)
 				};
 				let signer = charlie.clone();

substrate/bin/node/testing/src/bench.rs

@@ -275,7 +275,7 @@ impl<'a> BlockContentIterator<'a> {
 	fn new(content: BlockContent, keyring: &'a BenchKeyring, client: &Client) -> Self {
 		let genesis_hash = client.chain_info().genesis_hash;
 		let runtime_version = client
-			.runtime_version_at(genesis_hash)
+			.runtime_version_at(genesis_hash, sp_api::CallContext::Offchain)
 			.expect("There should be runtime version at 0");
 
 		BlockContentIterator { iteration: 0, content, keyring, runtime_version, genesis_hash }

substrate/client/api/src/call_executor.rs

@@ -81,7 +81,11 @@ pub trait CallExecutor<B: BlockT>: RuntimeVersionOf {
 	/// Extract RuntimeVersion of given block
 	///
 	/// No changes are made.
-	fn runtime_version(&self, at_hash: B::Hash) -> Result<RuntimeVersion, sp_blockchain::Error>;
+	fn runtime_version(
+		&self,
+		at_hash: B::Hash,
+		call_context: CallContext,
+	) -> Result<RuntimeVersion, sp_blockchain::Error>;
 
 	/// Prove the execution of the given `method`.
 	///

substrate/client/rpc-spec-v2/src/chain_head/chain_head_follow.rs

@@ -249,7 +249,7 @@ where
 			return None;
 		}
 
-		let block_rt = match self.client.runtime_version_at(block) {
+		let block_rt = match self.client.runtime_version_at(block, sp_api::CallContext::Offchain) {
 			Ok(rt) => rt,
 			Err(err) => return Some(err.into()),
 		};
@@ -262,7 +262,8 @@ where
 			},
 		};
 
-		let parent_rt = match self.client.runtime_version_at(parent) {
+		let parent_rt = match self.client.runtime_version_at(parent, sp_api::CallContext::Offchain)
+		{
 			Ok(rt) => rt,
 			Err(err) => return Some(err.into()),
 		};

substrate/client/rpc-spec-v2/src/chain_head/test_utils.rs

@@ -26,7 +26,7 @@ use sc_client_api::{
 	StaleBlock, StorageData, StorageEventStream, StorageKey, StorageProvider,
 };
 use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
-use sp_api::{CallApiAt, CallApiAtParams};
+use sp_api::{CallApiAt, CallApiAtParams, CallContext};
 use sp_blockchain::{BlockStatus, CachedHeaderMetadata, HeaderBackend, HeaderMetadata, Info};
 use sp_consensus::BlockOrigin;
 use sp_runtime::{
@@ -241,8 +241,12 @@ impl<Block: BlockT, Client: CallApiAt<Block>> CallApiAt<Block> for ChainHeadMock
 		self.client.call_api_at(params)
 	}
 
-	fn runtime_version_at(&self, hash: Block::Hash) -> Result<RuntimeVersion, sp_api::ApiError> {
-		self.client.runtime_version_at(hash)
+	fn runtime_version_at(
+		&self,
+		hash: Block::Hash,
+		call_context: CallContext,
+	) -> Result<RuntimeVersion, sp_api::ApiError> {
+		self.client.runtime_version_at(hash, call_context)
 	}
 
 	fn state_at(&self, at: Block::Hash) -> Result<Self::StateBackend, sp_api::ApiError> {

substrate/client/rpc/src/state/state_full.rs

@@ -333,7 +333,9 @@ where
 		block: Option<Block::Hash>,
 	) -> std::result::Result<RuntimeVersion, Error> {
 		self.block_or_best(block).map_err(client_err).and_then(|block| {
-			self.client.runtime_version_at(block).map_err(|e| Error::Client(Box::new(e)))
+			self.client
+				.runtime_version_at(block, CallContext::Offchain)
+				.map_err(|e| Error::Client(Box::new(e)))
 		})
 	}
 
@@ -380,7 +382,9 @@ where
 	fn subscribe_runtime_version(&self, pending: PendingSubscriptionSink) {
 		let initial = match self
 			.block_or_best(None)
-			.and_then(|block| self.client.runtime_version_at(block).map_err(Into::into))
+			.and_then(|block| {
+				self.client.runtime_version_at(block, CallContext::Offchain).map_err(Into::into)
+			})
 			.map_err(|e| Error::Client(Box::new(e)))
 		{
 			Ok(initial) => initial,
@@ -398,8 +402,9 @@ where
 			.import_notification_stream()
 			.filter(|n| future::ready(n.is_new_best))
 			.filter_map(move |n| {
-				let version =
-					client.runtime_version_at(n.hash).map_err(|e| Error::Client(Box::new(e)));
+				let version = client
+					.runtime_version_at(n.hash, CallContext::Offchain)
+					.map_err(|e| Error::Client(Box::new(e)));
 
 				match version {
 					Ok(version) if version != previous_version => {