git.delta.rocks / unique-network / refs/commits / be09f662cdcf

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617use 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 = "unique_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 = BlockId::<Block>::hash(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}