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 = sc_service::new_native_or_wasm_executor(exec_params);217 let execution = ExecutionStrategy::NativeElseWasm;218219 let mut results = Vec::new();220221 for encoded_xt in encoded_xts {222 let encoded_bytes = encoded_xt.encode();223224 let xt_result = StateMachine::new(225 &proving_backend,226 &mut changes,227 &executor,228 "PovEstimateApi_pov_estimate",229 encoded_bytes.as_slice(),230 full_extensions(),231 &runtime_code,232 sp_core::testing::TaskExecutor::new(),233 )234 .execute(execution.into())235 .map_err(|e| anyhow!("failed to execute the extrinsic {:?}", e))?;236237 let xt_result = Decode::decode(&mut &*xt_result)238 .map_err(|e| anyhow!("failed to decode the extrinsic result {:?}", e))?;239240 results.push(xt_result);241 }242243 let root = proving_backend.root().clone();244245 let proof = proving_backend246 .extract_proof()247 .expect("A recorder was set and thus, a storage proof can be extracted; qed");248 let proof_size = proof.encoded_size();249250 let memory_db = proof.clone().into_memory_db();251252 let tree_db =253 TrieDBBuilder::<sp_trie::LayoutV1<HasherOf<Block>>>::new(&memory_db, &root).build();254255 let key_values = tree_db256 .iter()257 .map_err(|e| anyhow!("failed to retrieve tree db key values: {:?}", e))?258 .filter_map(|item| {259 let item = item.ok()?;260261 Some(TrieKeyValue {262 key: item.0,263 value: item.1,264 })265 })266 .collect();267268 let compact_proof = proof269 .clone()270 .into_compact_proof::<HasherOf<Block>>(pre_root)271 .map_err(|e| anyhow!("failed to generate compact proof {:?}", e))?;272 let compact_proof_size = compact_proof.encoded_size();273274 let compressed_proof = zstd::stream::encode_all(&compact_proof.encode()[..], 0)275 .map_err(|e| anyhow!("failed to generate compact proof {:?}", e))?;276 let compressed_proof_size = compressed_proof.len();277278 Ok(PovInfo {279 proof_size: proof_size as u64,280 compact_proof_size: compact_proof_size as u64,281 compressed_proof_size: compressed_proof_size as u64,282 results,283 key_values,284 })285}