1#[macro_export]2macro_rules! impl_common_runtime_apis {3 (4 $(5 #![custom_apis]67 $($custom_apis:tt)+8 )?9 ) => {10 impl_runtime_apis! {11 $($($custom_apis)+)?1213 impl up_rpc::UniqueApi<Block, CrossAccountId, AccountId> for Runtime {14 fn account_tokens(collection: CollectionId, account: CrossAccountId) -> Result<Vec<TokenId>, DispatchError> {15 dispatch_unique_runtime!(collection.account_tokens(account))16 }17 fn collection_tokens(collection: CollectionId) -> Result<Vec<TokenId>, DispatchError> {18 dispatch_unique_runtime!(collection.collection_tokens())19 }20 fn token_exists(collection: CollectionId, token: TokenId) -> Result<bool, DispatchError> {21 dispatch_unique_runtime!(collection.token_exists(token))22 }2324 fn token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {25 dispatch_unique_runtime!(collection.token_owner(token))26 }27 fn topmost_token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {28 let budget = up_data_structs::budget::Value::new(10);2930 Ok(Some(<pallet_structure::Pallet<Runtime>>::find_topmost_owner(collection, token, &budget)?))31 }32 fn token_children(collection: CollectionId, token: TokenId) -> Result<Vec<TokenChild>, DispatchError> {33 Ok(<pallet_nonfungible::Pallet<Runtime>>::token_children_ids(collection, token))34 }35 fn collection_properties(36 collection: CollectionId,37 keys: Option<Vec<Vec<u8>>>38 ) -> Result<Vec<Property>, DispatchError> {39 let keys = keys.map(40 |keys| Common::bytes_keys_to_property_keys(keys)41 ).transpose()?;4243 Common::filter_collection_properties(collection, keys)44 }4546 fn token_properties(47 collection: CollectionId,48 token_id: TokenId,49 keys: Option<Vec<Vec<u8>>>50 ) -> Result<Vec<Property>, DispatchError> {51 let keys = keys.map(52 |keys| Common::bytes_keys_to_property_keys(keys)53 ).transpose()?;5455 dispatch_unique_runtime!(collection.token_properties(token_id, keys))56 }5758 fn property_permissions(59 collection: CollectionId,60 keys: Option<Vec<Vec<u8>>>61 ) -> Result<Vec<PropertyKeyPermission>, DispatchError> {62 let keys = keys.map(63 |keys| Common::bytes_keys_to_property_keys(keys)64 ).transpose()?;6566 Common::filter_property_permissions(collection, keys)67 }6869 fn token_data(70 collection: CollectionId,71 token_id: TokenId,72 keys: Option<Vec<Vec<u8>>>73 ) -> Result<TokenData<CrossAccountId>, DispatchError> {74 let token_data = TokenData {75 properties: Self::token_properties(collection, token_id, keys)?,76 owner: Self::token_owner(collection, token_id)?77 };7879 Ok(token_data)80 }8182 fn total_supply(collection: CollectionId) -> Result<u32, DispatchError> {83 dispatch_unique_runtime!(collection.total_supply())84 }85 fn account_balance(collection: CollectionId, account: CrossAccountId) -> Result<u32, DispatchError> {86 dispatch_unique_runtime!(collection.account_balance(account))87 }88 fn balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<u128, DispatchError> {89 dispatch_unique_runtime!(collection.balance(account, token))90 }91 fn allowance(92 collection: CollectionId,93 sender: CrossAccountId,94 spender: CrossAccountId,95 token: TokenId,96 ) -> Result<u128, DispatchError> {97 dispatch_unique_runtime!(collection.allowance(sender, spender, token))98 }99100 fn adminlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {101 Ok(<pallet_common::Pallet<Runtime>>::adminlist(collection))102 }103 fn allowlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {104 Ok(<pallet_common::Pallet<Runtime>>::allowlist(collection))105 }106 fn allowed(collection: CollectionId, user: CrossAccountId) -> Result<bool, DispatchError> {107 Ok(<pallet_common::Pallet<Runtime>>::allowed(collection, user))108 }109 fn last_token_id(collection: CollectionId) -> Result<TokenId, DispatchError> {110 dispatch_unique_runtime!(collection.last_token_id())111 }112 fn collection_by_id(collection: CollectionId) -> Result<Option<RpcCollection<AccountId>>, DispatchError> {113 Ok(<pallet_common::Pallet<Runtime>>::rpc_collection(collection))114 }115 fn collection_stats() -> Result<CollectionStats, DispatchError> {116 Ok(<pallet_common::Pallet<Runtime>>::collection_stats())117 }118 fn next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<Option<u64>, DispatchError> {119 Ok(<$crate::sponsoring::UniqueSponsorshipPredict<Runtime> as120 $crate::sponsoring::SponsorshipPredict<Runtime>>::predict(121 collection,122 account,123 token))124 }125126 fn effective_collection_limits(collection: CollectionId) -> Result<Option<CollectionLimits>, DispatchError> {127 Ok(<pallet_common::Pallet<Runtime>>::effective_collection_limits(collection))128 }129 }130131 impl rmrk_rpc::RmrkApi<132 Block,133 AccountId,134 RmrkCollectionInfo<AccountId>,135 RmrkInstanceInfo<AccountId>,136 RmrkResourceInfo,137 RmrkPropertyInfo,138 RmrkBaseInfo<AccountId>,139 RmrkPartType,140 RmrkTheme141 > for Runtime {142 fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {143 Ok(RmrkCore::last_collection_idx())144 }145146 fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {147 use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};148 use pallet_common::CommonCollectionOperations;149150 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {151 Ok(c) => c,152 Err(_) => return Ok(None),153 };154155 let nfts_count = collection.total_supply();156157 Ok(Some(RmrkCollectionInfo {158 issuer: collection.owner.clone(),159 metadata: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::Metadata)?,160 max: collection.limits.token_limit,161 symbol: RmrkCore::rebind(&collection.token_prefix)?,162 nfts_count163 }))164 }165166 fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {167 use up_data_structs::mapping::TokenAddressMapping;168 use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};169 use pallet_common::CommonCollectionOperations;170171 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {172 Ok(c) => c,173 Err(_) => return Ok(None),174 };175176 let nft_id = TokenId(nft_by_id);177 if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }178179 let owner = match collection.token_owner(nft_id) {180 Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {181 Some((col, tok)) => {182 let rmrk_collection = RmrkCore::rmrk_collection_id(col)?;183184 RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)185 }186 None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())187 },188 None => return Ok(None)189 };190191 let allowance = pallet_nonfungible::Allowance::<Runtime>::get((collection_id, nft_id));192193 Ok(Some(RmrkInstanceInfo {194 owner: owner,195 royalty: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::RoyaltyInfo)?,196 metadata: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Metadata)?,197 equipped: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Equipped)?,198 pending: allowance.is_some(),199 }))200 }201202 fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {203 use pallet_proxy_rmrk_core::misc::CollectionType;204 use pallet_common::CommonCollectionOperations;205206 let cross_account_id = CrossAccountId::from_sub(account_id);207208 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {209 Ok(c) => c,210 Err(_) => return Ok(Vec::new()),211 };212213 Ok(214 collection.account_tokens(cross_account_id)215 .into_iter()216 .map(|token| token.0)217 .collect()218 )219 }220221 fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {222 let collection_id = match RmrkCore::unique_collection_id(collection_id) {223 Ok(id) => id,224 Err(_) => return Ok(Vec::new())225 };226 let nft_id = TokenId(nft_id);227 if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(Vec::new()); }228229 Ok(230 pallet_nonfungible::TokenChildren::<Runtime>::iter_prefix((collection_id, nft_id))231 .filter_map(|((child_collection, child_token), _)| {232 let rmrk_child_collection = RmrkCore::rmrk_collection_id(233 child_collection234 ).ok()?;235236 Some(RmrkNftChild {237 collection_id: rmrk_child_collection,238 nft_id: child_token.0,239 })240 }).collect()241 )242 }243244 fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {245 use pallet_proxy_rmrk_core::misc::CollectionType;246247 let collection_id = match RmrkCore::unique_collection_id(collection_id) {248 Ok(id) => id,249 Err(_) => return Ok(Vec::new())250 };251 if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() {252 return Ok(Vec::new());253 }254255 let properties = RmrkCore::filter_user_properties(256 collection_id,257 None,258 filter_keys,259 |key, value| RmrkPropertyInfo {260 key,261 value262 }263 )?;264265 Ok(properties)266 }267268 fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {269 use pallet_proxy_rmrk_core::misc::NftType;270271 let collection_id = match RmrkCore::unique_collection_id(collection_id) {272 Ok(id) => id,273 Err(_) => return Ok(Vec::new())274 };275 let token_id = TokenId(nft_id);276277 if RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {278 return Ok(Vec::new());279 }280281 let properties = RmrkCore::filter_user_properties(282 collection_id,283 Some(token_id),284 filter_keys,285 |key, value| RmrkPropertyInfo {286 key,287 value288 }289 )?;290291 Ok(properties)292 }293294 fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {295 use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType}};296 use pallet_common::CommonCollectionOperations;297298 let collection_id = match RmrkCore::unique_collection_id(collection_id) {299 Ok(id) => id,300 Err(_) => return Ok(Vec::new())301 };302 if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }303304 let nft_id = TokenId(nft_id);305 if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }306307 let res_collection_id: CollectionId = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)?;308 let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;309310 let resources = resource_collection311 .collection_tokens()312 .iter()313 .filter_map(|(res_id)| Some(RmrkResourceInfo {314 id: res_id.0,315 pending: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).unwrap(),316 pending_removal: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).unwrap(),317 resource: match RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::ResourceType).unwrap() {318 ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {319 src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).unwrap(),320 metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).unwrap(),321 license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).unwrap(),322 thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).unwrap(),323 }),324 ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {325 parts: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Parts).unwrap(),326 base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).unwrap(),327 src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).unwrap(),328 metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).unwrap(),329 license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).unwrap(),330 thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).unwrap(),331 }),332 ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {333 base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).unwrap(),334 src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).unwrap(),335 metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).unwrap(),336 slot: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Slot).unwrap(),337 license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).unwrap(),338 thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).unwrap(),339 }),340 },341 }))342 .collect();343344 Ok(resources)345 }346347 fn nft_resource_priorities(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceId>, DispatchError> {348 use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};349350 let collection_id = match RmrkCore::unique_collection_id(collection_id) {351 Ok(id) => id,352 Err(_) => return Ok(Vec::new())353 };354 if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }355356 let nft_id = TokenId(nft_id);357 if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }358359 360361362363364365366367368369370371 let priorities = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;372373 Ok(priorities)374 }375376 fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {377 use pallet_proxy_rmrk_core::{378 RmrkProperty, misc::{CollectionType},379 };380381 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {382 Ok(c) => c,383 Err(_) => return Ok(None),384 };385386 Ok(Some(RmrkBaseInfo {387 issuer: collection.owner.clone(),388 base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,389 symbol: RmrkCore::rebind(&collection.token_prefix)?,390 }))391 }392393 fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {394 use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};395 use pallet_common::CommonCollectionOperations;396397 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {398 Ok(c) => c,399 Err(_) => return Ok(Vec::new()),400 };401 402 let parts = collection.collection_tokens()403 .into_iter()404 .filter_map(|token_id| {405 let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;406407 match nft_type {408 NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {409 id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,410 src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,411 z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,412 })),413 NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {414 id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,415 src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,416 z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,417 equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,418 })),419 _ => None420 }421 })422 .collect();423424 Ok(parts)425 }426427 fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {428 use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};429 use pallet_common::CommonCollectionOperations;430431 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {432 Ok(c) => c,433 Err(_) => return Ok(Vec::new()),434 };435436 let theme_names = collection.collection_tokens()437 .iter()438 .filter_map(|token_id| {439 let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).unwrap();440441 match nft_type {442 Theme => Some(443 RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).unwrap()444 ),445 _ => None446 }447 })448 .collect();449450 Ok(theme_names)451 }452453 fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {454 use pallet_proxy_rmrk_core::{455 RmrkProperty,456 misc::{CollectionType, NftType}457 };458 use pallet_common::CommonCollectionOperations;459460 let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {461 Ok(c) => c,462 Err(_) => return Ok(None),463 };464465 let theme_info = collection.collection_tokens()466 .into_iter()467 .find_map(|token_id| {468 RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;469470 let name: RmrkString = RmrkCore::get_nft_property_decoded(471 collection_id, token_id, RmrkProperty::ThemeName472 ).ok()?;473474 if name == theme_name {475 Some((name, token_id))476 } else {477 None478 }479 });480481 let (name, theme_id) = match theme_info {482 Some((name, theme_id)) => (name, theme_id),483 None => return Ok(None)484 };485486 let properties = RmrkCore::filter_user_properties(487 collection_id,488 Some(theme_id),489 filter_keys,490 |key, value| RmrkThemeProperty {491 key,492 value493 }494 )?;495496 let inherit = RmrkCore::get_nft_property_decoded(497 collection_id,498 theme_id,499 RmrkProperty::ThemeInherit500 )?;501502 let theme = RmrkTheme {503 name,504 properties,505 inherit,506 };507508 Ok(Some(theme))509 }510 }511512 impl sp_api::Core<Block> for Runtime {513 fn version() -> RuntimeVersion {514 VERSION515 }516517 fn execute_block(block: Block) {518 Executive::execute_block(block)519 }520521 fn initialize_block(header: &<Block as BlockT>::Header) {522 Executive::initialize_block(header)523 }524 }525526 impl sp_api::Metadata<Block> for Runtime {527 fn metadata() -> OpaqueMetadata {528 OpaqueMetadata::new(Runtime::metadata().into())529 }530 }531532 impl sp_block_builder::BlockBuilder<Block> for Runtime {533 fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {534 Executive::apply_extrinsic(extrinsic)535 }536537 fn finalize_block() -> <Block as BlockT>::Header {538 Executive::finalize_block()539 }540541 fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {542 data.create_extrinsics()543 }544545 fn check_inherents(546 block: Block,547 data: sp_inherents::InherentData,548 ) -> sp_inherents::CheckInherentsResult {549 data.check_extrinsics(&block)550 }551552 553 554 555 }556557 impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {558 fn validate_transaction(559 source: TransactionSource,560 tx: <Block as BlockT>::Extrinsic,561 hash: <Block as BlockT>::Hash,562 ) -> TransactionValidity {563 Executive::validate_transaction(source, tx, hash)564 }565 }566567 impl sp_offchain::OffchainWorkerApi<Block> for Runtime {568 fn offchain_worker(header: &<Block as BlockT>::Header) {569 Executive::offchain_worker(header)570 }571 }572573 impl fp_rpc::EthereumRuntimeRPCApi<Block> for Runtime {574 fn chain_id() -> u64 {575 <Runtime as pallet_evm::Config>::ChainId::get()576 }577578 fn account_basic(address: H160) -> EVMAccount {579 let (account, _) = EVM::account_basic(&address);580 account581 }582583 fn gas_price() -> U256 {584 let (price, _) = <Runtime as pallet_evm::Config>::FeeCalculator::min_gas_price();585 price586 }587588 fn account_code_at(address: H160) -> Vec<u8> {589 EVM::account_codes(address)590 }591592 fn author() -> H160 {593 <pallet_evm::Pallet<Runtime>>::find_author()594 }595596 fn storage_at(address: H160, index: U256) -> H256 {597 let mut tmp = [0u8; 32];598 index.to_big_endian(&mut tmp);599 EVM::account_storages(address, H256::from_slice(&tmp[..]))600 }601602 #[allow(clippy::redundant_closure)]603 fn call(604 from: H160,605 to: H160,606 data: Vec<u8>,607 value: U256,608 gas_limit: U256,609 max_fee_per_gas: Option<U256>,610 max_priority_fee_per_gas: Option<U256>,611 nonce: Option<U256>,612 estimate: bool,613 access_list: Option<Vec<(H160, Vec<H256>)>>,614 ) -> Result<pallet_evm::CallInfo, sp_runtime::DispatchError> {615 let config = if estimate {616 let mut config = <Runtime as pallet_evm::Config>::config().clone();617 config.estimate = true;618 Some(config)619 } else {620 None621 };622623 let is_transactional = false;624 <Runtime as pallet_evm::Config>::Runner::call(625 CrossAccountId::from_eth(from),626 to,627 data,628 value,629 gas_limit.low_u64(),630 max_fee_per_gas,631 max_priority_fee_per_gas,632 nonce,633 access_list.unwrap_or_default(),634 is_transactional,635 config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),636 ).map_err(|err| err.error.into())637 }638639 #[allow(clippy::redundant_closure)]640 fn create(641 from: H160,642 data: Vec<u8>,643 value: U256,644 gas_limit: U256,645 max_fee_per_gas: Option<U256>,646 max_priority_fee_per_gas: Option<U256>,647 nonce: Option<U256>,648 estimate: bool,649 access_list: Option<Vec<(H160, Vec<H256>)>>,650 ) -> Result<pallet_evm::CreateInfo, sp_runtime::DispatchError> {651 let config = if estimate {652 let mut config = <Runtime as pallet_evm::Config>::config().clone();653 config.estimate = true;654 Some(config)655 } else {656 None657 };658659 let is_transactional = false;660 <Runtime as pallet_evm::Config>::Runner::create(661 CrossAccountId::from_eth(from),662 data,663 value,664 gas_limit.low_u64(),665 max_fee_per_gas,666 max_priority_fee_per_gas,667 nonce,668 access_list.unwrap_or_default(),669 is_transactional,670 config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),671 ).map_err(|err| err.error.into())672 }673674 fn current_transaction_statuses() -> Option<Vec<TransactionStatus>> {675 Ethereum::current_transaction_statuses()676 }677678 fn current_block() -> Option<pallet_ethereum::Block> {679 Ethereum::current_block()680 }681682 fn current_receipts() -> Option<Vec<pallet_ethereum::Receipt>> {683 Ethereum::current_receipts()684 }685686 fn current_all() -> (687 Option<pallet_ethereum::Block>,688 Option<Vec<pallet_ethereum::Receipt>>,689 Option<Vec<TransactionStatus>>690 ) {691 (692 Ethereum::current_block(),693 Ethereum::current_receipts(),694 Ethereum::current_transaction_statuses()695 )696 }697698 fn extrinsic_filter(xts: Vec<<Block as sp_api::BlockT>::Extrinsic>) -> Vec<pallet_ethereum::Transaction> {699 xts.into_iter().filter_map(|xt| match xt.0.function {700 Call::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction),701 _ => None702 }).collect()703 }704705 fn elasticity() -> Option<Permill> {706 None707 }708 }709710 impl fp_rpc::ConvertTransactionRuntimeApi<Block> for Runtime {711 fn convert_transaction(transaction: pallet_ethereum::Transaction) -> <Block as BlockT>::Extrinsic {712 UncheckedExtrinsic::new_unsigned(713 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),714 )715 }716 }717718 impl sp_session::SessionKeys<Block> for Runtime {719 fn decode_session_keys(720 encoded: Vec<u8>,721 ) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {722 SessionKeys::decode_into_raw_public_keys(&encoded)723 }724725 fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {726 SessionKeys::generate(seed)727 }728 }729730 impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {731 fn slot_duration() -> sp_consensus_aura::SlotDuration {732 sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())733 }734735 fn authorities() -> Vec<AuraId> {736 Aura::authorities().to_vec()737 }738 }739740 impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {741 fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {742 ParachainSystem::collect_collation_info(header)743 }744 }745746 impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {747 fn account_nonce(account: AccountId) -> Index {748 System::account_nonce(account)749 }750 }751752 impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {753 fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {754 TransactionPayment::query_info(uxt, len)755 }756 fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {757 TransactionPayment::query_fee_details(uxt, len)758 }759 }760761 762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802 #[cfg(feature = "runtime-benchmarks")]803 impl frame_benchmarking::Benchmark<Block> for Runtime {804 fn benchmark_metadata(extra: bool) -> (805 Vec<frame_benchmarking::BenchmarkList>,806 Vec<frame_support::traits::StorageInfo>,807 ) {808 use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList};809 use frame_support::traits::StorageInfoTrait;810811 let mut list = Vec::<BenchmarkList>::new();812813 list_benchmark!(list, extra, pallet_evm_migration, EvmMigration);814 list_benchmark!(list, extra, pallet_common, Common);815 list_benchmark!(list, extra, pallet_unique, Unique);816 list_benchmark!(list, extra, pallet_structure, Structure);817 list_benchmark!(list, extra, pallet_inflation, Inflation);818 list_benchmark!(list, extra, pallet_fungible, Fungible);819 list_benchmark!(list, extra, pallet_refungible, Refungible);820 list_benchmark!(list, extra, pallet_nonfungible, Nonfungible);821 822823 let storage_info = AllPalletsReversedWithSystemFirst::storage_info();824825 return (list, storage_info)826 }827828 fn dispatch_benchmark(829 config: frame_benchmarking::BenchmarkConfig830 ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {831 use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey};832833 let allowlist: Vec<TrackedStorageKey> = vec![834 835 hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),836837 838 hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),839 840 hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),841 842 hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),843 844 hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),845846 847 hex_literal::hex!("1da53b775b270400e7e61ed5cbc5a146547f210cec367e9af919603343b9cb56").to_vec().into(),848849 850 hex_literal::hex!("3a7472616e73616374696f6e5f6c6576656c3a").to_vec().into(),851 ];852853 let mut batches = Vec::<BenchmarkBatch>::new();854 let params = (&config, &allowlist);855856 add_benchmark!(params, batches, pallet_evm_migration, EvmMigration);857 add_benchmark!(params, batches, pallet_common, Common);858 add_benchmark!(params, batches, pallet_unique, Unique);859 add_benchmark!(params, batches, pallet_structure, Structure);860 add_benchmark!(params, batches, pallet_inflation, Inflation);861 add_benchmark!(params, batches, pallet_fungible, Fungible);862 add_benchmark!(params, batches, pallet_refungible, Refungible);863 add_benchmark!(params, batches, pallet_nonfungible, Nonfungible);864 865866 if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }867 Ok(batches)868 }869 }870871 #[cfg(feature = "try-runtime")]872 impl frame_try_runtime::TryRuntime<Block> for Runtime {873 fn on_runtime_upgrade() -> (Weight, Weight) {874 log::info!("try-runtime::on_runtime_upgrade unique-chain.");875 let weight = Executive::try_runtime_upgrade().unwrap();876 (weight, RuntimeBlockWeights::get().max_block)877 }878879 fn execute_block_no_check(block: Block) -> Weight {880 Executive::execute_block_no_check(block)881 }882 }883 }884 }885}