Removal of execution strategies (#14387)

* Start * More work! * Moar * More changes * More fixes * More worrk * More fixes * More fixes to make it compile * Adds `NoOffchainStorage` * Pass the extensions * Small basti making small progress * Fix merge errors and remove `ExecutionContext` * Move registration of `ReadRuntimeVersionExt` to `ExecutionExtension` Instead of registering `ReadRuntimeVersionExt` in `sp-state-machine` it is moved to `ExecutionExtension` which provides the default extensions. * Fix compilation * Register the global extensions inside runtime api instance * Fixes * Fix `generate_initial_session_keys` by passing the keystore extension * Fix the grandpa tests * Fix more tests * Fix more tests * Don't set any heap pages if there isn't an override * Fix small fallout * FMT * Fix tests * More tests * Offchain worker custom extensions * More fixes * Make offchain tx pool creation reusable Introduces an `OffchainTransactionPoolFactory` for creating offchain transactions pools that can be registered in the runtime externalities context. This factory will be required for a later pr to make the creation of offchain transaction pools easier. * Fixes * Fixes * Set offchain transaction pool in BABE before using it in the runtime * Add the `offchain_tx_pool` to Grandpa as well * Fix the nodes * Print some error when using the old warnings * Fix merge issues * Fix compilation * Rename `babe_link` * Rename to `offchain_tx_pool_factory` * Cleanup * FMT * Fix benchmark name * Fix `try-runtime` * Remove `--execution` CLI args * Make clippy happy * Forward bls functions * Fix docs * Update UI tests * Update client/api/src/execution_extensions.rs Co-authored-by: Michal Kucharczyk <1728078+michalkucharczyk@users.noreply.github.com> * Apply suggestions from code review Co-authored-by: Koute <koute@users.noreply.github.com> * Update client/cli/src/params/import_params.rs Co-authored-by: Koute <koute@users.noreply.github.com> * Update client/api/src/execution_extensions.rs Co-authored-by: Koute <koute@users.noreply.github.com> * Pass the offchain storage to the MMR RPC * Update client/api/src/execution_extensions.rs Co-authored-by: Sebastian Kunert <skunert49@gmail.com> * Review comments * Fixes --------- Co-authored-by: Michal Kucharczyk <1728078+michalkucharczyk@users.noreply.github.com> Co-authored-by: Koute <koute@users.noreply.github.com> Co-authored-by: Sebastian Kunert <skunert49@gmail.com>
2026-04-29 23:07:57 +00:00 · 2023-07-11 16:21:38 +02:00
parent a2b01c061b
commit 5eb816d7a6
96 changed files with 1175 additions and 1499 deletions
@@ -315,7 +315,6 @@ impl<'a> ToClientSideDecl<'a> {
 			fn __runtime_api_internal_call_api_at(
 				&self,
 				at: #block_hash,
-				context: #crate_::ExecutionContext,
 				params: std::vec::Vec<u8>,
 				fn_name: &dyn Fn(#crate_::RuntimeVersion) -> &'static str,
 			) -> std::result::Result<std::vec::Vec<u8>, #crate_::ApiError>;
@@ -335,9 +334,8 @@ impl<'a> ToClientSideDecl<'a> {

 		items.into_iter().for_each(|i| match i {
 			TraitItem::Fn(method) => {
-				let (fn_decl, fn_decl_ctx) = self.fold_trait_item_fn(method, trait_generics_num);
+				let fn_decl = self.create_method_decl(method, trait_generics_num);
 				result.push(fn_decl.into());
-				result.push(fn_decl_ctx.into());
 			},
 			r => result.push(r),
 		});
@@ -345,41 +343,12 @@ impl<'a> ToClientSideDecl<'a> {
 		result
 	}

-	fn fold_trait_item_fn(
-		&mut self,
-		method: TraitItemFn,
-		trait_generics_num: usize,
-	) -> (TraitItemFn, TraitItemFn) {
-		let crate_ = self.crate_;
-		let context = quote!( #crate_::ExecutionContext::OffchainCall(None) );
-		let fn_decl = self.create_method_decl(method.clone(), context, trait_generics_num);
-		let fn_decl_ctx = self.create_method_decl_with_context(method, trait_generics_num);
-
-		(fn_decl, fn_decl_ctx)
-	}
-
-	fn create_method_decl_with_context(
-		&mut self,
-		method: TraitItemFn,
-		trait_generics_num: usize,
-	) -> TraitItemFn {
-		let crate_ = self.crate_;
-		let context_arg: syn::FnArg = parse_quote!( context: #crate_::ExecutionContext );
-		let mut fn_decl_ctx = self.create_method_decl(method, quote!(context), trait_generics_num);
-		fn_decl_ctx.sig.ident =
-			Ident::new(&format!("{}_with_context", &fn_decl_ctx.sig.ident), Span::call_site());
-		fn_decl_ctx.sig.inputs.insert(2, context_arg);
-
-		fn_decl_ctx
-	}
-
 	/// Takes the method declared by the user and creates the declaration we require for the runtime
 	/// api client side. This method will call by default the `method_runtime_api_impl` for doing
 	/// the actual call into the runtime.
 	fn create_method_decl(
 		&mut self,
 		mut method: TraitItemFn,
-		context: TokenStream,
 		trait_generics_num: usize,
 	) -> TraitItemFn {
 		let params = match extract_parameter_names_types_and_borrows(
@@ -467,7 +436,6 @@ impl<'a> ToClientSideDecl<'a> {
 				<Self as #trait_name<#( #underscores ),*>>::__runtime_api_internal_call_api_at(
 					self,
 					__runtime_api_at_param__,
-					#context,
 					__runtime_api_impl_params_encoded__,
 					&|_version| {
 						#(
@@ -224,8 +224,8 @@ fn generate_runtime_api_base_structures() -> Result<TokenStream> {

 	Ok(quote!(
 		pub struct RuntimeApi {}
-		/// Implements all runtime apis for the client side.
 		#crate_::std_enabled! {
+			/// Implements all runtime apis for the client side.
 			pub struct RuntimeApiImpl<Block: #crate_::BlockT, C: #crate_::CallApiAt<Block> + 'static> {
 				call: &'static C,
 				transaction_depth: std::cell::RefCell<u16>,
@@ -234,6 +234,9 @@ fn generate_runtime_api_base_structures() -> Result<TokenStream> {
 					#crate_::StorageTransactionCache<Block, C::StateBackend>
 				>,
 				recorder: std::option::Option<#crate_::ProofRecorder<Block>>,
+				call_context: #crate_::CallContext,
+				extensions: std::cell::RefCell<#crate_::Extensions>,
+				extensions_generated_for: std::cell::RefCell<std::option::Option<Block::Hash>>,
 			}

 			impl<Block: #crate_::BlockT, C: #crate_::CallApiAt<Block>> #crate_::ApiExt<Block> for
@@ -321,6 +324,14 @@ fn generate_runtime_api_base_structures() -> Result<TokenStream> {
 							state_version,
 						)
 					}
+
+				fn set_call_context(&mut self, call_context: #crate_::CallContext) {
+					self.call_context = call_context;
+				}
+
+				fn register_extension<E: #crate_::Extension>(&mut self, extension: E) {
+					std::cell::RefCell::borrow_mut(&self.extensions).register(extension);
+				}
 			}

 			impl<Block: #crate_::BlockT, C> #crate_::ConstructRuntimeApi<Block, C>
@@ -339,6 +350,9 @@ fn generate_runtime_api_base_structures() -> Result<TokenStream> {
 						changes: std::default::Default::default(),
 						recorder: std::default::Default::default(),
 						storage_transaction_cache: std::default::Default::default(),
+						call_context: #crate_::CallContext::Offchain,
+						extensions: std::default::Default::default(),
+						extensions_generated_for: std::default::Default::default(),
 					}.into()
 				}
 			}
@@ -480,7 +494,6 @@ impl<'a> ApiRuntimeImplToApiRuntimeApiImpl<'a> {
 			fn __runtime_api_internal_call_api_at(
 				&self,
 				at: <__SrApiBlock__ as #crate_::BlockT>::Hash,
-				context: #crate_::ExecutionContext,
 				params: std::vec::Vec<u8>,
 				fn_name: &dyn Fn(#crate_::RuntimeVersion) -> &'static str,
 			) -> std::result::Result<std::vec::Vec<u8>, #crate_::ApiError> {
@@ -498,14 +511,34 @@ impl<'a> ApiRuntimeImplToApiRuntimeApiImpl<'a> {
 						at,
 					)?;

+					match &mut *std::cell::RefCell::borrow_mut(&self.extensions_generated_for) {
+						Some(generated_for) => {
+							if *generated_for != at {
+								return std::result::Result::Err(
+									#crate_::ApiError::UsingSameInstanceForDifferentBlocks
+								)
+							}
+						},
+						generated_for @ None => {
+							#crate_::CallApiAt::<__SrApiBlock__>::initialize_extensions(
+								self.call,
+								at,
+								&mut std::cell::RefCell::borrow_mut(&self.extensions),
+							)?;
+
+							*generated_for = Some(at);
+						}
+					}
+
 					let params = #crate_::CallApiAtParams {
 						at,
 						function: (*fn_name)(version),
 						arguments: params,
 						overlayed_changes: &self.changes,
 						storage_transaction_cache: &self.storage_transaction_cache,
-						context,
+						call_context: self.call_context,
 						recorder: &self.recorder,
+						extensions: &self.extensions,
 					};

 					#crate_::CallApiAt::<__SrApiBlock__>::call_api_at(
@@ -121,13 +121,20 @@ fn implement_common_api_traits(block_type: TypePath, self_ty: Type) -> Result<To
 			> where Self: Sized {
 				unimplemented!("`into_storage_changes` not implemented for runtime api mocks")
 			}
+
+			fn set_call_context(&mut self, _: #crate_::CallContext) {
+				unimplemented!("`set_call_context` not implemented for runtime api mocks")
+			}
+
+			fn register_extension<E: #crate_::Extension>(&mut self, _: E) {
+				unimplemented!("`register_extension` not implemented for runtime api mocks")
+			}
 		}

 		impl #crate_::Core<#block_type> for #self_ty {
 			fn __runtime_api_internal_call_api_at(
 				&self,
 				_: <#block_type as #crate_::BlockT>::Hash,
-				_: #crate_::ExecutionContext,
 				_: std::vec::Vec<u8>,
 				_: &dyn Fn(#crate_::RuntimeVersion) -> &'static str,
 			) -> std::result::Result<std::vec::Vec<u8>, #crate_::ApiError> {
@@ -141,14 +148,6 @@ fn implement_common_api_traits(block_type: TypePath, self_ty: Type) -> Result<To
 				unimplemented!("`Core::version` not implemented for runtime api mocks")
 			}

-			fn version_with_context(
-				&self,
-				_: <#block_type as #crate_::BlockT>::Hash,
-				_: #crate_::ExecutionContext,
-			) -> std::result::Result<#crate_::RuntimeVersion, #crate_::ApiError> {
-				unimplemented!("`Core::version` not implemented for runtime api mocks")
-			}
-
 			fn execute_block(
 				&self,
 				_: <#block_type as #crate_::BlockT>::Hash,
@@ -157,15 +156,6 @@ fn implement_common_api_traits(block_type: TypePath, self_ty: Type) -> Result<To
 				unimplemented!("`Core::execute_block` not implemented for runtime api mocks")
 			}

-			fn execute_block_with_context(
-				&self,
-				_: <#block_type as #crate_::BlockT>::Hash,
-				_: #crate_::ExecutionContext,
-				_: #block_type,
-			) -> std::result::Result<(), #crate_::ApiError> {
-				unimplemented!("`Core::execute_block` not implemented for runtime api mocks")
-			}
-
 			fn initialize_block(
 				&self,
 				_: <#block_type as #crate_::BlockT>::Hash,
@@ -173,15 +163,6 @@ fn implement_common_api_traits(block_type: TypePath, self_ty: Type) -> Result<To
 			) -> std::result::Result<(), #crate_::ApiError> {
 				unimplemented!("`Core::initialize_block` not implemented for runtime api mocks")
 			}
-
-			fn initialize_block_with_context(
-				&self,
-				_: <#block_type as #crate_::BlockT>::Hash,
-				_: #crate_::ExecutionContext,
-				_: &<#block_type as #crate_::BlockT>::Header,
-			) -> std::result::Result<(), #crate_::ApiError> {
-				unimplemented!("`Core::initialize_block` not implemented for runtime api mocks")
-			}
 		}
 	))
 }
@@ -255,26 +236,12 @@ impl<'a> FoldRuntimeApiImpl<'a> {

 		let crate_ = generate_crate_access();

-		// We also need to overwrite all the `_with_context` methods. To do this,
-		// we clone all methods and add them again with the new name plus one more argument.
-		impl_item.items.extend(impl_item.items.clone().into_iter().filter_map(|i| {
-			if let syn::ImplItem::Fn(mut m) = i {
-				m.sig.ident = quote::format_ident!("{}_with_context", m.sig.ident);
-				m.sig.inputs.insert(2, parse_quote!( _: #crate_::ExecutionContext ));
-
-				Some(m.into())
-			} else {
-				None
-			}
-		}));
-
 		let block_type = self.block_type;

 		impl_item.items.push(parse_quote! {
 			fn __runtime_api_internal_call_api_at(
 				&self,
 				_: <#block_type as #crate_::BlockT>::Hash,
-				_: #crate_::ExecutionContext,
 				_: std::vec::Vec<u8>,
 				_: &dyn Fn(#crate_::RuntimeVersion) -> &'static str,
 			) -> std::result::Result<std::vec::Vec<u8>, #crate_::ApiError> {