git.delta.rocks / unique-network / refs/commits / 078678edc9f4

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/>.1617#[macro_export]18macro_rules! dispatch_unique_runtime {19	($collection:ident.$method:ident($($name:ident),*) $($rest:tt)*) => {{20		let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch($collection)?;21		let dispatch = collection.as_dyn();2223		Ok::<_, DispatchError>(dispatch.$method($($name),*) $($rest)*)24	}};25}2627#[macro_export]28macro_rules! impl_common_runtime_apis {29	(30		$(31			#![custom_apis]3233			$($custom_apis:tt)+34		)?35	) => {36		use sp_std::prelude::*;37		use sp_api::impl_runtime_apis;38		use sp_core::{crypto::KeyTypeId, OpaqueMetadata, H256, U256, H160};39		use sp_runtime::{40			Permill,41			traits::{Block as BlockT},42			transaction_validity::{TransactionSource, TransactionValidity},43			ApplyExtrinsicResult, DispatchError, ExtrinsicInclusionMode,44		};45		use frame_support::{46			pallet_prelude::Weight,47			traits::OnFinalize,48		};49		use fp_rpc::TransactionStatus;50		use pallet_transaction_payment::{51			FeeDetails, RuntimeDispatchInfo,52		};53		use pallet_evm::{54			Runner, account::CrossAccountId as _,55			Account as EVMAccount, FeeCalculator,56		};57		use runtime_common::{58			sponsoring::{SponsorshipPredict, UniqueSponsorshipPredict},59			dispatch::CollectionDispatch,60			config::ethereum::CrossAccountId,61		};62		use up_data_structs::*;6364		impl_runtime_apis! {65			$($($custom_apis)+)?6667			impl up_rpc::UniqueApi<Block, CrossAccountId, AccountId> for Runtime {68				fn account_tokens(collection: CollectionId, account: CrossAccountId) -> Result<Vec<TokenId>, DispatchError> {69					dispatch_unique_runtime!(collection.account_tokens(account))70				}71				fn collection_tokens(collection: CollectionId) -> Result<Vec<TokenId>, DispatchError> {72					dispatch_unique_runtime!(collection.collection_tokens())73				}74				fn token_exists(collection: CollectionId, token: TokenId) -> Result<bool, DispatchError> {75					dispatch_unique_runtime!(collection.token_exists(token))76				}7778				fn token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {79					dispatch_unique_runtime!(collection.token_owner(token).ok())80				}8182				fn token_owners(collection: CollectionId, token: TokenId) -> Result<Vec::<CrossAccountId>, DispatchError>  {83					dispatch_unique_runtime!(collection.token_owners(token))84				}8586				fn topmost_token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {87					let budget = budget::Value::new(10);8889					<pallet_structure::Pallet<Runtime>>::find_topmost_owner(collection, token, &budget)90				}91				fn token_children(collection: CollectionId, token: TokenId) -> Result<Vec<TokenChild>, DispatchError> {92					Ok(<pallet_nonfungible::Pallet<Runtime>>::token_children_ids(collection, token))93				}94				fn collection_properties(95					collection: CollectionId,96					keys: Option<Vec<Vec<u8>>>97				) -> Result<Vec<Property>, DispatchError> {98					let keys = keys.map(99						|keys| Common::bytes_keys_to_property_keys(keys)100					).transpose()?;101102					Common::filter_collection_properties(collection, keys)103				}104105				fn token_properties(106					collection: CollectionId,107					token_id: TokenId,108					keys: Option<Vec<Vec<u8>>>109				) -> Result<Vec<Property>, DispatchError> {110					let keys = keys.map(111						|keys| Common::bytes_keys_to_property_keys(keys)112					).transpose()?;113114					dispatch_unique_runtime!(collection.token_properties(token_id, keys))115				}116117				fn property_permissions(118					collection: CollectionId,119					keys: Option<Vec<Vec<u8>>>120				) -> Result<Vec<PropertyKeyPermission>, DispatchError> {121					let keys = keys.map(122						|keys| Common::bytes_keys_to_property_keys(keys)123					).transpose()?;124125					Common::filter_property_permissions(collection, keys)126				}127128				fn token_data(129					collection: CollectionId,130					token_id: TokenId,131					keys: Option<Vec<Vec<u8>>>132				) -> Result<TokenData<CrossAccountId>, DispatchError> {133					let token_data = TokenData {134						properties: Self::token_properties(collection, token_id, keys)?,135						owner: Self::token_owner(collection, token_id)?,136						pieces: Self::total_pieces(collection, token_id)?.unwrap_or(0),137					};138139					Ok(token_data)140				}141142				fn total_supply(collection: CollectionId) -> Result<u32, DispatchError> {143					dispatch_unique_runtime!(collection.total_supply())144				}145				fn account_balance(collection: CollectionId, account: CrossAccountId) -> Result<u32, DispatchError> {146					dispatch_unique_runtime!(collection.account_balance(account))147				}148				fn balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<u128, DispatchError> {149					dispatch_unique_runtime!(collection.balance(account, token))150				}151				fn allowance(152					collection: CollectionId,153					sender: CrossAccountId,154					spender: CrossAccountId,155					token: TokenId,156				) -> Result<u128, DispatchError> {157					dispatch_unique_runtime!(collection.allowance(sender, spender, token))158				}159160				fn adminlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {161					Ok(<pallet_common::Pallet<Runtime>>::adminlist(collection))162				}163				fn allowlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {164					Ok(<pallet_common::Pallet<Runtime>>::allowlist(collection))165				}166				fn allowed(collection: CollectionId, user: CrossAccountId) -> Result<bool, DispatchError> {167					Ok(<pallet_common::Pallet<Runtime>>::allowed(collection, user))168				}169				fn last_token_id(collection: CollectionId) -> Result<TokenId, DispatchError> {170					dispatch_unique_runtime!(collection.last_token_id())171				}172				fn collection_by_id(collection: CollectionId) -> Result<Option<RpcCollection<AccountId>>, DispatchError> {173					Ok(<pallet_common::Pallet<Runtime>>::rpc_collection(collection))174				}175				fn collection_stats() -> Result<CollectionStats, DispatchError> {176					Ok(<pallet_common::Pallet<Runtime>>::collection_stats())177				}178				fn next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<Option<u64>, DispatchError> {179					Ok(<UniqueSponsorshipPredict<Runtime> as SponsorshipPredict<Runtime>>::predict(180						collection,181						account,182						token183					))184				}185186				fn effective_collection_limits(collection: CollectionId) -> Result<Option<CollectionLimits>, DispatchError> {187					Ok(<pallet_common::Pallet<Runtime>>::effective_collection_limits(collection))188				}189190				fn total_pieces(collection: CollectionId, token_id: TokenId) -> Result<Option<u128>, DispatchError> {191					dispatch_unique_runtime!(collection.total_pieces(token_id))192				}193194				fn allowance_for_all(collection: CollectionId, owner: CrossAccountId, operator: CrossAccountId) -> Result<bool, DispatchError> {195					dispatch_unique_runtime!(collection.allowance_for_all(owner, operator))196				}197			}198199			impl app_promotion_rpc::AppPromotionApi<Block, BlockNumber, CrossAccountId, AccountId> for Runtime {200				#[allow(unused_variables)]201				fn total_staked(staker: Option<CrossAccountId>) -> Result<u128, DispatchError> {202					#[cfg(not(feature = "app-promotion"))]203					return unsupported!();204205					#[cfg(feature = "app-promotion")]206					return Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_total_staked(staker).unwrap_or_default());207				}208209				#[allow(unused_variables)]210				fn total_staked_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>, DispatchError> {211					#[cfg(not(feature = "app-promotion"))]212					return unsupported!();213214					#[cfg(feature = "app-promotion")]215					return Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_total_staked_per_block(staker));216				}217218				#[allow(unused_variables)]219				fn pending_unstake(staker: Option<CrossAccountId>) -> Result<u128, DispatchError> {220					#[cfg(not(feature = "app-promotion"))]221					return unsupported!();222223					#[cfg(feature = "app-promotion")]224					return Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_pending_unstake(staker));225				}226227				#[allow(unused_variables)]228				fn pending_unstake_per_block(staker: CrossAccountId) -> Result<Vec<(BlockNumber, u128)>, DispatchError> {229					#[cfg(not(feature = "app-promotion"))]230					return unsupported!();231232					#[cfg(feature = "app-promotion")]233					return Ok(<pallet_app_promotion::Pallet<Runtime>>::cross_id_pending_unstake_per_block(staker))234				}235			}236237			impl sp_api::Core<Block> for Runtime {238				fn version() -> RuntimeVersion {239					VERSION240				}241242				fn execute_block(block: Block) {243					Executive::execute_block(block)244				}245246				fn initialize_block(header: &<Block as BlockT>::Header) -> ExtrinsicInclusionMode {247					Executive::initialize_block(header)248				}249			}250251			impl sp_api::Metadata<Block> for Runtime {252				fn metadata() -> OpaqueMetadata {253					OpaqueMetadata::new(Runtime::metadata().into())254				}255256				fn metadata_at_version(version: u32) -> Option<OpaqueMetadata> {257					Runtime::metadata_at_version(version)258				}259260				fn metadata_versions() -> sp_std::vec::Vec<u32> {261					Runtime::metadata_versions()262				}263			}264265			impl sp_block_builder::BlockBuilder<Block> for Runtime {266				fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {267					Executive::apply_extrinsic(extrinsic)268				}269270				fn finalize_block() -> <Block as BlockT>::Header {271					Executive::finalize_block()272				}273274				fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {275					data.create_extrinsics()276				}277278				fn check_inherents(279					block: Block,280					data: sp_inherents::InherentData,281				) -> sp_inherents::CheckInherentsResult {282					data.check_extrinsics(&block)283				}284285				// fn random_seed() -> <Block as BlockT>::Hash {286				//	   RandomnessCollectiveFlip::random_seed().0287				// }288			}289290			impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {291				fn validate_transaction(292					source: TransactionSource,293					tx: <Block as BlockT>::Extrinsic,294					hash: <Block as BlockT>::Hash,295				) -> TransactionValidity {296					Executive::validate_transaction(source, tx, hash)297				}298			}299300			impl sp_offchain::OffchainWorkerApi<Block> for Runtime {301				fn offchain_worker(header: &<Block as BlockT>::Header) {302					Executive::offchain_worker(header)303				}304			}305306			impl fp_rpc::EthereumRuntimeRPCApi<Block> for Runtime {307				fn chain_id() -> u64 {308					<Runtime as pallet_evm::Config>::ChainId::get()309				}310311				fn account_basic(address: H160) -> EVMAccount {312					let (account, _) = EVM::account_basic(&address);313					account314				}315316				fn gas_price() -> U256 {317					let (price, _) = <Runtime as pallet_evm::Config>::FeeCalculator::min_gas_price();318					price319				}320321				fn account_code_at(address: H160) -> Vec<u8> {322					use pallet_evm::OnMethodCall;323					<Runtime as pallet_evm::Config>::OnMethodCall::get_code(&address)324						.unwrap_or_else(|| pallet_evm::AccountCodes::<Runtime>::get(address))325				}326327				fn author() -> H160 {328					<pallet_evm::Pallet<Runtime>>::find_author()329				}330331				fn storage_at(address: H160, index: U256) -> H256 {332					let mut tmp = [0u8; 32];333					index.to_big_endian(&mut tmp);334					pallet_evm::AccountStorages::<Runtime>::get(address, H256::from_slice(&tmp[..]))335				}336337				#[allow(clippy::redundant_closure)]338				fn call(339					from: H160,340					to: H160,341					data: Vec<u8>,342					value: U256,343					gas_limit: U256,344					max_fee_per_gas: Option<U256>,345					max_priority_fee_per_gas: Option<U256>,346					nonce: Option<U256>,347					estimate: bool,348					access_list: Option<Vec<(H160, Vec<H256>)>>,349				) -> Result<pallet_evm::CallInfo, sp_runtime::DispatchError> {350					let config = if estimate {351						let mut config = <Runtime as pallet_evm::Config>::config().clone();352						config.estimate = true;353						Some(config)354					} else {355						None356					};357358					let is_transactional = false;359					let validate = false;360					<Runtime as pallet_evm::Config>::Runner::call(361						CrossAccountId::from_eth(from),362						to,363						data,364						value,365						gas_limit.low_u64(),366						max_fee_per_gas,367						max_priority_fee_per_gas,368						nonce,369						access_list.unwrap_or_default(),370						is_transactional,371						validate,372						// TODO we probably want to support external cost recording in non-transactional calls373						None,374						None,375376						config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),377					).map_err(|err| err.error.into())378				}379380				#[allow(clippy::redundant_closure)]381				fn create(382					from: H160,383					data: Vec<u8>,384					value: U256,385					gas_limit: U256,386					max_fee_per_gas: Option<U256>,387					max_priority_fee_per_gas: Option<U256>,388					nonce: Option<U256>,389					estimate: bool,390					access_list: Option<Vec<(H160, Vec<H256>)>>,391				) -> Result<pallet_evm::CreateInfo, sp_runtime::DispatchError> {392					let config = if estimate {393						let mut config = <Runtime as pallet_evm::Config>::config().clone();394						config.estimate = true;395						Some(config)396					} else {397						None398					};399400					let is_transactional = false;401					let validate = false;402					<Runtime as pallet_evm::Config>::Runner::create(403						CrossAccountId::from_eth(from),404						data,405						value,406						gas_limit.low_u64(),407						max_fee_per_gas,408						max_priority_fee_per_gas,409						nonce,410						access_list.unwrap_or_default(),411						is_transactional,412						validate,413						// TODO we probably want to support external cost recording in non-transactional calls414						None,415						None,416417						config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),418					).map_err(|err| err.error.into())419				}420421				fn current_transaction_statuses() -> Option<Vec<TransactionStatus>> {422					pallet_ethereum::CurrentTransactionStatuses::<Runtime>::get()423				}424425				fn current_block() -> Option<pallet_ethereum::Block> {426					pallet_ethereum::CurrentBlock::<Runtime>::get()427				}428429				fn current_receipts() -> Option<Vec<pallet_ethereum::Receipt>> {430					pallet_ethereum::CurrentReceipts::<Runtime>::get()431				}432433				fn current_all() -> (434					Option<pallet_ethereum::Block>,435					Option<Vec<pallet_ethereum::Receipt>>,436					Option<Vec<TransactionStatus>>437				) {438					(439						pallet_ethereum::CurrentBlock::<Runtime>::get(),440						pallet_ethereum::CurrentReceipts::<Runtime>::get(),441						pallet_ethereum::CurrentTransactionStatuses::<Runtime>::get()442					)443				}444445				fn extrinsic_filter(xts: Vec<<Block as BlockT>::Extrinsic>) -> Vec<pallet_ethereum::Transaction> {446					xts.into_iter().filter_map(|xt| match xt.0.function {447						RuntimeCall::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction),448						_ => None449					}).collect()450				}451452				fn elasticity() -> Option<Permill> {453					None454				}455456				fn gas_limit_multiplier_support() {}457458				fn pending_block(459					xts: Vec<<Block as BlockT>::Extrinsic>,460				) -> (Option<pallet_ethereum::Block>, Option<Vec<TransactionStatus>>) {461					for ext in xts.into_iter() {462						let _ = Executive::apply_extrinsic(ext);463					}464465					Ethereum::on_finalize(System::block_number() + 1);466467					(468						pallet_ethereum::CurrentBlock::<Runtime>::get(),469						pallet_ethereum::CurrentTransactionStatuses::<Runtime>::get()470					)471				}472			}473474			impl sp_session::SessionKeys<Block> for Runtime {475				fn decode_session_keys(476					encoded: Vec<u8>,477				) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {478					SessionKeys::decode_into_raw_public_keys(&encoded)479				}480481				fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {482					SessionKeys::generate(seed)483				}484			}485486			impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {487				fn slot_duration() -> sp_consensus_aura::SlotDuration {488					#[cfg(not(feature = "lookahead"))]489					{490						sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())491					}492					#[cfg(feature = "lookahead")]493					{494						sp_consensus_aura::SlotDuration::from_millis(up_common::constants::SLOT_DURATION)495					}496				}497498				fn authorities() -> Vec<AuraId> {499					Aura::authorities().to_vec()500				}501			}502503			impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {504				fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {505					ParachainSystem::collect_collation_info(header)506				}507			}508509			impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {510				fn account_nonce(account: AccountId) -> Nonce {511					System::account_nonce(account)512				}513			}514515			impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {516				fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {517					TransactionPayment::query_info(uxt, len)518				}519				fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {520					TransactionPayment::query_fee_details(uxt, len)521				}522				fn query_weight_to_fee(weight: Weight) -> Balance {523					TransactionPayment::weight_to_fee(weight)524				}525				fn query_length_to_fee(length: u32) -> Balance {526					TransactionPayment::length_to_fee(length)527				}528			}529530			#[cfg(feature = "runtime-benchmarks")]531			impl frame_benchmarking::Benchmark<Block> for Runtime {532				fn benchmark_metadata(extra: bool) -> (533					Vec<frame_benchmarking::BenchmarkList>,534					Vec<frame_support::traits::StorageInfo>,535				) {536					use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList};537					use frame_support::traits::StorageInfoTrait;538					use pallet_xcm::benchmarking::Pallet as PalletXcmBenchmarks;539540					let mut list = Vec::<BenchmarkList>::new();541					list_benchmark!(list, extra, pallet_xcm, PalletXcmBenchmarks::<Runtime>);542543					list_benchmark!(list, extra, pallet_evm_migration, EvmMigration);544					list_benchmark!(list, extra, pallet_common, Common);545					list_benchmark!(list, extra, pallet_unique, Unique);546					list_benchmark!(list, extra, pallet_structure, Structure);547					list_benchmark!(list, extra, pallet_inflation, Inflation);548					list_benchmark!(list, extra, pallet_configuration, Configuration);549550					#[cfg(feature = "app-promotion")]551					list_benchmark!(list, extra, pallet_app_promotion, AppPromotion);552553					list_benchmark!(list, extra, pallet_fungible, Fungible);554					list_benchmark!(list, extra, pallet_nonfungible, Nonfungible);555556					#[cfg(feature = "refungible")]557					list_benchmark!(list, extra, pallet_refungible, Refungible);558559					#[cfg(feature = "collator-selection")]560					list_benchmark!(list, extra, pallet_collator_selection, CollatorSelection);561562					#[cfg(feature = "governance")]563					list_benchmark!(list, extra, pallet_identity, Identity);564565					#[cfg(feature = "foreign-assets")]566					list_benchmark!(list, extra, pallet_foreign_assets, ForeignAssets);567568					list_benchmark!(list, extra, pallet_maintenance, Maintenance);569570					// list_benchmark!(list, extra, pallet_evm_coder_substrate, EvmCoderSubstrate);571572					let storage_info = AllPalletsWithSystem::storage_info();573574					return (list, storage_info)575				}576577				fn dispatch_benchmark(578					config: frame_benchmarking::BenchmarkConfig579				) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {580					use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark};581					use sp_storage::TrackedStorageKey;582					use pallet_xcm::benchmarking::Pallet as PalletXcmBenchmarks;583584					let allowlist: Vec<TrackedStorageKey> = vec![585						// Total Issuance586						hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),587588						// Block Number589						hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),590						// Execution Phase591						hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),592						// Event Count593						hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),594						// System Events595						hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),596597						// Evm CurrentLogs598						hex_literal::hex!("1da53b775b270400e7e61ed5cbc5a146547f210cec367e9af919603343b9cb56").to_vec().into(),599600						// Transactional depth601						hex_literal::hex!("3a7472616e73616374696f6e5f6c6576656c3a").to_vec().into(),602					];603604					let mut batches = Vec::<BenchmarkBatch>::new();605					let params = (&config, &allowlist);606607					add_benchmark!(params, batches, pallet_xcm, PalletXcmBenchmarks::<Runtime>);608609					add_benchmark!(params, batches, pallet_evm_migration, EvmMigration);610					add_benchmark!(params, batches, pallet_common, Common);611					add_benchmark!(params, batches, pallet_unique, Unique);612					add_benchmark!(params, batches, pallet_structure, Structure);613					add_benchmark!(params, batches, pallet_inflation, Inflation);614					add_benchmark!(params, batches, pallet_configuration, Configuration);615616					#[cfg(feature = "app-promotion")]617					add_benchmark!(params, batches, pallet_app_promotion, AppPromotion);618619					add_benchmark!(params, batches, pallet_fungible, Fungible);620					add_benchmark!(params, batches, pallet_nonfungible, Nonfungible);621622					#[cfg(feature = "refungible")]623					add_benchmark!(params, batches, pallet_refungible, Refungible);624625					#[cfg(feature = "collator-selection")]626					add_benchmark!(params, batches, pallet_collator_selection, CollatorSelection);627628					#[cfg(feature = "governance")]629					add_benchmark!(params, batches, pallet_identity, Identity);630631					#[cfg(feature = "foreign-assets")]632					add_benchmark!(params, batches, pallet_foreign_assets, ForeignAssets);633634					add_benchmark!(params, batches, pallet_maintenance, Maintenance);635636					// add_benchmark!(params, batches, pallet_evm_coder_substrate, EvmCoderSubstrate);637638					if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }639					Ok(batches)640				}641			}642643			impl up_pov_estimate_rpc::PovEstimateApi<Block> for Runtime {644				#[allow(unused_variables)]645				fn pov_estimate(uxt: Vec<u8>) -> ApplyExtrinsicResult {646					#[cfg(feature = "pov-estimate")]647					{648						use parity_scale_codec::Decode;649650						let uxt_decode = <<Block as BlockT>::Extrinsic as Decode>::decode(&mut &*uxt)651							.map_err(|_| DispatchError::Other("failed to decode the extrinsic"));652653						let uxt = match uxt_decode {654							Ok(uxt) => uxt,655							Err(err) => return Ok(err.into()),656						};657658						Executive::apply_extrinsic(uxt)659					}660661					#[cfg(not(feature = "pov-estimate"))]662					return Ok(unsupported!());663				}664			}665666			#[cfg(feature = "try-runtime")]667			impl frame_try_runtime::TryRuntime<Block> for Runtime {668				fn on_runtime_upgrade(checks: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) {669					log::info!("try-runtime::on_runtime_upgrade unique-chain.");670					let weight = Executive::try_runtime_upgrade(checks).unwrap();671					(weight, $crate::config::substrate::RuntimeBlockWeights::get().max_block)672				}673674				fn execute_block(675					block: Block,676					state_root_check: bool,677					signature_check: bool,678					select: frame_try_runtime::TryStateSelect679				) -> Weight {680					log::info!(681						target: "node-runtime",682						"try-runtime: executing block {:?} / root checks: {:?} / try-state-select: {:?}",683						block.header.hash(),684						state_root_check,685						select,686					);687688					Executive::try_execute_block(block, state_root_check, signature_check, select).unwrap()689				}690			}691692			#[cfg(feature = "lookahead")]693			impl cumulus_primitives_aura::AuraUnincludedSegmentApi<Block> for Runtime {694				fn can_build_upon(695					included_hash: <Block as BlockT>::Hash,696					slot: cumulus_primitives_aura::Slot,697				) -> bool {698					$crate::config::parachain::ConsensusHook::can_build_upon(included_hash, slot)699				}700			}701702			/// Should never be used, yet still required because of https://github.com/paritytech/polkadot-sdk/issues/27703			/// Not allowed to panic, because rpc may be called using native runtime, thus causing thread panic.704			impl fp_rpc::ConvertTransactionRuntimeApi<Block> for Runtime {705				fn convert_transaction(706					transaction: pallet_ethereum::Transaction707				) -> <Block as BlockT>::Extrinsic {708					UncheckedExtrinsic::new_unsigned(709						pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),710					)711				}712			}713		}714	}715}