1234567891011121314151617use std::sync::Arc;1819use codec::{Encode, Decode};20use sp_externalities::Extensions;2122use up_pov_estimate_rpc::{PovEstimateApi as PovEstimateRuntimeApi};23use up_common::types::opaque::RuntimeId;2425use sc_service::{NativeExecutionDispatch, config::ExecutionStrategy};26use sp_state_machine::{StateMachine, TrieBackendBuilder};27use trie_db::{Trie, TrieDBBuilder};2829use jsonrpsee::{core::RpcResult as Result, proc_macros::rpc};30use anyhow::anyhow;3132use sc_client_api::backend::Backend;33use sp_blockchain::HeaderBackend;34use sp_core::{35 Bytes,36 offchain::{37 testing::{TestOffchainExt, TestTransactionPoolExt},38 OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,39 },40 testing::TaskExecutor,41 traits::TaskExecutorExt,42};43use sp_keystore::{testing::KeyStore, KeystoreExt};44use sp_api::{AsTrieBackend, BlockId, BlockT, ProvideRuntimeApi};4546use sc_executor::NativeElseWasmExecutor;47use sc_rpc_api::DenyUnsafe;4849use sp_runtime::traits::Header;5051use up_pov_estimate_rpc::{PovInfo, TrieKeyValue};5253use crate::define_struct_for_server_api;5455type HasherOf<Block> = <<Block as BlockT>::Header as Header>::Hashing;56type StateOf<Block> = <sc_service::TFullBackend<Block> as Backend<Block>>::State;5758pub struct ExecutorParams {59 pub wasm_method: sc_service::config::WasmExecutionMethod,60 pub default_heap_pages: Option<u64>,61 pub max_runtime_instances: usize,62 pub runtime_cache_size: u8,63}6465#[cfg(feature = "unique-runtime")]66pub struct UniqueRuntimeExecutor;6768#[cfg(feature = "quartz-runtime")]69pub struct QuartzRuntimeExecutor;7071pub struct OpalRuntimeExecutor;7273#[cfg(feature = "unique-runtime")]74impl NativeExecutionDispatch for UniqueRuntimeExecutor {75 type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;7677 fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {78 unique_runtime::api::dispatch(method, data)79 }8081 fn native_version() -> sc_executor::NativeVersion {82 unique_runtime::native_version()83 }84}8586#[cfg(feature = "quartz-runtime")]87impl NativeExecutionDispatch for QuartzRuntimeExecutor {88 type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;8990 fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {91 quartz_runtime::api::dispatch(method, data)92 }9394 fn native_version() -> sc_executor::NativeVersion {95 quartz_runtime::native_version()96 }97}9899impl NativeExecutionDispatch for OpalRuntimeExecutor {100 type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;101102 fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {103 opal_runtime::api::dispatch(method, data)104 }105106 fn native_version() -> sc_executor::NativeVersion {107 opal_runtime::native_version()108 }109}110111#[cfg(feature = "pov-estimate")]112define_struct_for_server_api! {113 PovEstimate {114 client: Arc<Client>,115 backend: Arc<sc_service::TFullBackend<Block>>,116 deny_unsafe: DenyUnsafe,117 exec_params: ExecutorParams,118 runtime_id: RuntimeId,119 }120}121122#[rpc(server)]123#[async_trait]124pub trait PovEstimateApi<BlockHash> {125 #[method(name = "povinfo_estimateExtrinsicPoV")]126 fn estimate_extrinsic_pov(127 &self,128 encoded_xts: Vec<Bytes>,129 at: Option<BlockHash>,130 ) -> Result<PovInfo>;131}132133#[allow(deprecated)]134#[cfg(feature = "pov-estimate")]135impl<C, Block> PovEstimateApiServer<<Block as BlockT>::Hash> for PovEstimate<C, Block>136where137 Block: BlockT,138 C: 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,139 C::Api: PovEstimateRuntimeApi<Block>,140{141 fn estimate_extrinsic_pov(142 &self,143 encoded_xts: Vec<Bytes>,144 at: Option<<Block as BlockT>::Hash>,145 ) -> Result<PovInfo> {146 self.deny_unsafe.check_if_safe()?;147148 let at = at.unwrap_or_else(|| self.client.info().best_hash);149 let state = self150 .backend151 .state_at(at)152 .map_err(|_| anyhow!("unable to fetch the state at {at:?}"))?;153154 match &self.runtime_id {155 #[cfg(feature = "unique-runtime")]156 RuntimeId::Unique => execute_extrinsic_in_sandbox::<Block, UniqueRuntimeExecutor>(157 state,158 &self.exec_params,159 encoded_xts,160 ),161162 #[cfg(feature = "quartz-runtime")]163 RuntimeId::Quartz => execute_extrinsic_in_sandbox::<Block, QuartzRuntimeExecutor>(164 state,165 &self.exec_params,166 encoded_xts,167 ),168169 RuntimeId::Opal => execute_extrinsic_in_sandbox::<Block, OpalRuntimeExecutor>(170 state,171 &self.exec_params,172 encoded_xts,173 ),174175 runtime_id => Err(anyhow!("unknown runtime id {:?}", runtime_id).into()),176 }177 }178}179180fn full_extensions() -> Extensions {181 let mut extensions = Extensions::default();182 extensions.register(TaskExecutorExt::new(TaskExecutor::new()));183 let (offchain, _offchain_state) = TestOffchainExt::new();184 let (pool, _pool_state) = TestTransactionPoolExt::new();185 extensions.register(OffchainDbExt::new(offchain.clone()));186 extensions.register(OffchainWorkerExt::new(offchain));187 extensions.register(KeystoreExt(std::sync::Arc::new(KeyStore::new())));188 extensions.register(TransactionPoolExt::new(pool));189190 extensions191}192193fn execute_extrinsic_in_sandbox<Block, D>(194 state: StateOf<Block>,195 exec_params: &ExecutorParams,196 encoded_xts: Vec<Bytes>,197) -> Result<PovInfo>198where199 Block: BlockT,200 D: NativeExecutionDispatch + 'static,201{202 let backend = state.as_trie_backend().clone();203 let mut changes = Default::default();204 let runtime_code_backend = sp_state_machine::backend::BackendRuntimeCode::new(backend);205206 let proving_backend = TrieBackendBuilder::wrap(&backend)207 .with_recorder(Default::default())208 .build();209210 let runtime_code = runtime_code_backend211 .runtime_code()212 .map_err(|_| anyhow!("runtime code backend creation failed"))?;213214 let pre_root = *backend.root();215216 let executor = NativeElseWasmExecutor::<D>::new(217 exec_params.wasm_method,218 exec_params.default_heap_pages,219 exec_params.max_runtime_instances,220 exec_params.runtime_cache_size,221 );222 let execution = ExecutionStrategy::NativeElseWasm;223224 let mut results = Vec::new();225226 for encoded_xt in encoded_xts {227 let encoded_bytes = encoded_xt.encode();228229 let xt_result = StateMachine::new(230 &proving_backend,231 &mut changes,232 &executor,233 "PovEstimateApi_pov_estimate",234 encoded_bytes.as_slice(),235 full_extensions(),236 &runtime_code,237 sp_core::testing::TaskExecutor::new(),238 )239 .execute(execution.into())240 .map_err(|e| anyhow!("failed to execute the extrinsic {:?}", e))?;241242 let xt_result = Decode::decode(&mut &*xt_result)243 .map_err(|e| anyhow!("failed to decode the extrinsic result {:?}", e))?;244245 results.push(xt_result);246 }247248 let root = proving_backend.root().clone();249250 let proof = proving_backend251 .extract_proof()252 .expect("A recorder was set and thus, a storage proof can be extracted; qed");253 let proof_size = proof.encoded_size();254255 let memory_db = proof.clone().into_memory_db();256257 let tree_db =258 TrieDBBuilder::<sp_trie::LayoutV1<HasherOf<Block>>>::new(&memory_db, &root).build();259260 let key_values = tree_db261 .iter()262 .map_err(|e| anyhow!("failed to retrieve tree db key values: {:?}", e))?263 .filter_map(|item| {264 let item = item.ok()?;265266 Some(TrieKeyValue {267 key: item.0,268 value: item.1,269 })270 })271 .collect();272273 let compact_proof = proof274 .clone()275 .into_compact_proof::<HasherOf<Block>>(pre_root)276 .map_err(|e| anyhow!("failed to generate compact proof {:?}", e))?;277 let compact_proof_size = compact_proof.encoded_size();278279 let compressed_proof = zstd::stream::encode_all(&compact_proof.encode()[..], 0)280 .map_err(|e| anyhow!("failed to generate compact proof {:?}", e))?;281 let compressed_proof_size = compressed_proof.len();282283 Ok(PovInfo {284 proof_size: proof_size as u64,285 compact_proof_size: compact_proof_size as u64,286 compressed_proof_size: compressed_proof_size as u64,287 results,288 key_values,289 })290}