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

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! impl_common_runtime_apis {19    (20        $(21            #![custom_apis]2223            $($custom_apis:tt)+24        )?25    ) => {26        impl_runtime_apis! {27            $($($custom_apis)+)?2829            impl up_rpc::UniqueApi<Block, CrossAccountId, AccountId> for Runtime {30                fn account_tokens(collection: CollectionId, account: CrossAccountId) -> Result<Vec<TokenId>, DispatchError> {31                    dispatch_unique_runtime!(collection.account_tokens(account))32                }33                fn collection_tokens(collection: CollectionId) -> Result<Vec<TokenId>, DispatchError> {34                    dispatch_unique_runtime!(collection.collection_tokens())35                }36                fn token_exists(collection: CollectionId, token: TokenId) -> Result<bool, DispatchError> {37                    dispatch_unique_runtime!(collection.token_exists(token))38                }3940                fn token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {41                    dispatch_unique_runtime!(collection.token_owner(token))42                }43                fn topmost_token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {44                    let budget = up_data_structs::budget::Value::new(10);4546                    Ok(Some(<pallet_structure::Pallet<Runtime>>::find_topmost_owner(collection, token, &budget)?))47                }48                fn token_children(collection: CollectionId, token: TokenId) -> Result<Vec<TokenChild>, DispatchError> {49                    Ok(<pallet_nonfungible::Pallet<Runtime>>::token_children_ids(collection, token))50                }51                fn collection_properties(52                    collection: CollectionId,53                    keys: Option<Vec<Vec<u8>>>54                ) -> Result<Vec<Property>, DispatchError> {55                    let keys = keys.map(56                        |keys| Common::bytes_keys_to_property_keys(keys)57                    ).transpose()?;5859                    Common::filter_collection_properties(collection, keys)60                }6162                fn token_properties(63                    collection: CollectionId,64                    token_id: TokenId,65                    keys: Option<Vec<Vec<u8>>>66                ) -> Result<Vec<Property>, DispatchError> {67                    let keys = keys.map(68                        |keys| Common::bytes_keys_to_property_keys(keys)69                    ).transpose()?;7071                    dispatch_unique_runtime!(collection.token_properties(token_id, keys))72                }7374                fn property_permissions(75                    collection: CollectionId,76                    keys: Option<Vec<Vec<u8>>>77                ) -> Result<Vec<PropertyKeyPermission>, DispatchError> {78                    let keys = keys.map(79                        |keys| Common::bytes_keys_to_property_keys(keys)80                    ).transpose()?;8182                    Common::filter_property_permissions(collection, keys)83                }8485                fn token_data(86                    collection: CollectionId,87                    token_id: TokenId,88                    keys: Option<Vec<Vec<u8>>>89                ) -> Result<TokenData<CrossAccountId>, DispatchError> {90                    let token_data = TokenData {91                        properties: Self::token_properties(collection, token_id, keys)?,92                        owner: Self::token_owner(collection, token_id)?93                    };9495                    Ok(token_data)96                }9798                fn total_supply(collection: CollectionId) -> Result<u32, DispatchError> {99                    dispatch_unique_runtime!(collection.total_supply())100                }101                fn account_balance(collection: CollectionId, account: CrossAccountId) -> Result<u32, DispatchError> {102                    dispatch_unique_runtime!(collection.account_balance(account))103                }104                fn balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<u128, DispatchError> {105                    dispatch_unique_runtime!(collection.balance(account, token))106                }107                fn allowance(108                    collection: CollectionId,109                    sender: CrossAccountId,110                    spender: CrossAccountId,111                    token: TokenId,112                ) -> Result<u128, DispatchError> {113                    dispatch_unique_runtime!(collection.allowance(sender, spender, token))114                }115116                fn adminlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {117                    Ok(<pallet_common::Pallet<Runtime>>::adminlist(collection))118                }119                fn allowlist(collection: CollectionId) -> Result<Vec<CrossAccountId>, DispatchError> {120                    Ok(<pallet_common::Pallet<Runtime>>::allowlist(collection))121                }122                fn allowed(collection: CollectionId, user: CrossAccountId) -> Result<bool, DispatchError> {123                    Ok(<pallet_common::Pallet<Runtime>>::allowed(collection, user))124                }125                fn last_token_id(collection: CollectionId) -> Result<TokenId, DispatchError> {126                    dispatch_unique_runtime!(collection.last_token_id())127                }128                fn collection_by_id(collection: CollectionId) -> Result<Option<RpcCollection<AccountId>>, DispatchError> {129                    Ok(<pallet_common::Pallet<Runtime>>::rpc_collection(collection))130                }131                fn collection_stats() -> Result<CollectionStats, DispatchError> {132                    Ok(<pallet_common::Pallet<Runtime>>::collection_stats())133                }134                fn next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<Option<u64>, DispatchError> {135                    Ok(<$crate::sponsoring::UniqueSponsorshipPredict<Runtime> as136                            $crate::sponsoring::SponsorshipPredict<Runtime>>::predict(137                        collection,138                        account,139                        token))140                }141142                fn effective_collection_limits(collection: CollectionId) -> Result<Option<CollectionLimits>, DispatchError> {143                    Ok(<pallet_common::Pallet<Runtime>>::effective_collection_limits(collection))144                }145            }146147            impl rmrk_rpc::RmrkApi<148                Block,149                AccountId,150                RmrkCollectionInfo<AccountId>,151                RmrkInstanceInfo<AccountId>,152                RmrkResourceInfo,153                RmrkPropertyInfo,154                RmrkBaseInfo<AccountId>,155                RmrkPartType,156                RmrkTheme157            > for Runtime {158                fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {159                    Ok(RmrkCore::last_collection_idx())160                }161162                fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {163                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};164                    use pallet_common::CommonCollectionOperations;165166                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {167                        Ok(c) => c,168                        Err(_) => return Ok(None),169                    };170171                    let nfts_count = collection.total_supply();172173                    Ok(Some(RmrkCollectionInfo {174                        issuer: collection.owner.clone(),175                        metadata: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::Metadata)?,176                        max: collection.limits.token_limit,177                        symbol: RmrkCore::rebind(&collection.token_prefix)?,178                        nfts_count179                    }))180                }181182                fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {183                    use up_data_structs::mapping::TokenAddressMapping;184                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};185                    use pallet_common::CommonCollectionOperations;186187                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {188                        Ok(c) => c,189                        Err(_) => return Ok(None),190                    };191192                    let nft_id = TokenId(nft_by_id);193                    if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }194195                    let owner = match collection.token_owner(nft_id) {196                        Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {197                            Some((col, tok)) => {198                                let rmrk_collection = RmrkCore::rmrk_collection_id(col)?;199200                                RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)201                            }202                            None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())203                        },204                        None => return Ok(None)205                    };206207                    Ok(Some(RmrkInstanceInfo {208                        owner: owner,209                        royalty: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::RoyaltyInfo)?,210                        metadata: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Metadata)?,211                        equipped: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Equipped)?,212                        pending: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::PendingNftAccept)?,213                    }))214                }215216                fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {217                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};218                    use pallet_common::CommonCollectionOperations;219220                    let cross_account_id = CrossAccountId::from_sub(account_id);221222                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {223                        Ok(c) => c,224                        Err(_) => return Ok(Vec::new()),225                    };226227                    let tokens = collection.account_tokens(cross_account_id)228                        .into_iter()229                        .filter(|token| {230                            let is_pending = RmrkCore::get_nft_property_decoded(231                                collection_id,232                                *token,233                                RmrkProperty::PendingNftAccept234                            ).unwrap_or(true);235236                            !is_pending237                        })238                        .map(|token| token.0)239                        .collect();240241                    Ok(tokens)242                }243244                fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {245                    use pallet_proxy_rmrk_core::RmrkProperty;246247                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {248                        Ok(id) => id,249                        Err(_) => return Ok(Vec::new())250                    };251                    let nft_id = TokenId(nft_id);252                    if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(Vec::new()); }253254                    Ok(255                        pallet_nonfungible::TokenChildren::<Runtime>::iter_prefix((collection_id, nft_id))256                            .filter_map(|((child_collection, child_token), _)| {257                                let is_pending = RmrkCore::get_nft_property_decoded(258                                    child_collection,259                                    child_token,260                                    RmrkProperty::PendingNftAccept261                                ).ok()?;262263                                if is_pending {264                                    return None;265                                }266267                                let rmrk_child_collection = RmrkCore::rmrk_collection_id(268                                    child_collection269                                ).ok()?;270271                                Some(RmrkNftChild {272                                    collection_id: rmrk_child_collection,273                                    nft_id: child_token.0,274                                })275                            }).collect()276                    )277                }278279                fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {280                    use pallet_proxy_rmrk_core::misc::CollectionType;281282                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {283                        Ok(id) => id,284                        Err(_) => return Ok(Vec::new())285                    };286                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() {287                        return Ok(Vec::new());288                    }289290                    let properties = RmrkCore::filter_user_properties(291                        collection_id,292                        /* token_id = */ None,293                        filter_keys,294                        |key, value| RmrkPropertyInfo {295                            key,296                            value297                        }298                    )?;299300                    Ok(properties)301                }302303                fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {304                    use pallet_proxy_rmrk_core::misc::NftType;305306                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {307                        Ok(id) => id,308                        Err(_) => return Ok(Vec::new())309                    };310                    let token_id = TokenId(nft_id);311312                    if RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {313                        return Ok(Vec::new());314                    }315316		            let properties = RmrkCore::filter_user_properties(317                        collection_id,318                        Some(token_id),319                        filter_keys,320                        |key, value| RmrkPropertyInfo {321                            key,322                            value323                        }324                    )?;325326                    Ok(properties)327                }328329                fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {330                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType}};331                    use pallet_common::CommonCollectionOperations;332333                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {334                        Ok(id) => id,335                        Err(_) => return Ok(Vec::new())336                    };337                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }338339                    let nft_id = TokenId(nft_id);340                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }341342                    let res_collection_id: Option<CollectionId> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)?;343344                    let res_collection_id = match res_collection_id {345                        Some(id) => id,346                        None => return Ok(Vec::new())347                    };348349                    let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;350351                    let resources = resource_collection352                        .collection_tokens()353                        .iter()354                        .filter_map(|(res_id)| Some(RmrkResourceInfo {355                            id: res_id.0,356                            pending: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).ok()?,357                            pending_removal: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).ok()?,358                            resource: match RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::ResourceType).ok()? {359                                ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {360                                    src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,361                                    metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,362                                    license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,363                                    thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,364                                }),365                                ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {366                                    parts: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Parts).ok()?,367                                    base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,368                                    src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,369                                    metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,370                                    license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,371                                    thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,372                                }),373                                ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {374                                    base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,375                                    src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,376                                    metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,377                                    slot: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Slot).ok()?,378                                    license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,379                                    thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,380                                }),381                            },382                        }))383                        .collect();384385                    Ok(resources)386                }387388                fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {389                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};390391                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {392                        Ok(id) => id,393                        Err(_) => return Ok(None)394                    };395                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }396397                    let nft_id = TokenId(nft_id);398                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }399400                    let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;401                    Ok(402                        priorities.into_iter()403                            .enumerate()404                            .find(|(_, id)| *id == resource_id)405                            .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)406                    )407                }408409                fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {410                    use pallet_proxy_rmrk_core::{411                        RmrkProperty, misc::{CollectionType},412                    };413414                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {415                        Ok(c) => c,416                        Err(_) => return Ok(None),417                    };418419                    Ok(Some(RmrkBaseInfo {420                        issuer: collection.owner.clone(),421                        base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,422                        symbol: RmrkCore::rebind(&collection.token_prefix)?,423                    }))424                }425426                fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {427                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};428                    use pallet_common::CommonCollectionOperations;429430                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {431                        Ok(c) => c,432                        Err(_) => return Ok(Vec::new()),433                    };434435                    let parts = collection.collection_tokens()436                        .into_iter()437                        .filter_map(|token_id| {438                            let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;439440                            match nft_type {441                                NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {442                                    id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,443                                    src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,444                                    z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,445                                })),446                                NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {447                                    id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,448                                    src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,449                                    z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,450                                    equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,451                                })),452                                _ => None453                            }454                        })455                        .collect();456457                    Ok(parts)458                }459460                fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {461                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};462                    use pallet_common::CommonCollectionOperations;463464                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {465                        Ok(c) => c,466                        Err(_) => return Ok(Vec::new()),467                    };468469                    let theme_names = collection.collection_tokens()470                        .iter()471                        .filter_map(|token_id| {472                            let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).ok()?;473474                            match nft_type {475                                Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),476                                _ => None477                            }478                        })479                        .collect();480481                    Ok(theme_names)482                }483484                fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {485                    use pallet_proxy_rmrk_core::{486                        RmrkProperty,487                        misc::{CollectionType, NftType}488                    };489                    use pallet_common::CommonCollectionOperations;490491                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {492                        Ok(c) => c,493                        Err(_) => return Ok(None),494                    };495496                    let theme_info = collection.collection_tokens()497                        .into_iter()498                        .find_map(|token_id| {499                            RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;500501                            let name: RmrkString = RmrkCore::get_nft_property_decoded(502                                collection_id, token_id, RmrkProperty::ThemeName503                            ).ok()?;504505                            if name == theme_name {506                                Some((name, token_id))507                            } else {508                                None509                            }510                        });511512                    let (name, theme_id) = match theme_info {513                        Some((name, theme_id)) => (name, theme_id),514                        None => return Ok(None)515                    };516517                    let properties = RmrkCore::filter_user_properties(518                        collection_id,519                        Some(theme_id),520                        filter_keys,521                        |key, value| RmrkThemeProperty {522                            key,523                            value524                        }525                    )?;526527                    let inherit = RmrkCore::get_nft_property_decoded(528                        collection_id,529                        theme_id,530                        RmrkProperty::ThemeInherit531                    )?;532533                    let theme = RmrkTheme {534                        name,535                        properties,536                        inherit,537                    };538539                    Ok(Some(theme))540                }541            }542543            impl sp_api::Core<Block> for Runtime {544                fn version() -> RuntimeVersion {545                    VERSION546                }547548                fn execute_block(block: Block) {549                    Executive::execute_block(block)550                }551552                fn initialize_block(header: &<Block as BlockT>::Header) {553                    Executive::initialize_block(header)554                }555            }556557            impl sp_api::Metadata<Block> for Runtime {558                fn metadata() -> OpaqueMetadata {559                    OpaqueMetadata::new(Runtime::metadata().into())560                }561            }562563            impl sp_block_builder::BlockBuilder<Block> for Runtime {564                fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {565                    Executive::apply_extrinsic(extrinsic)566                }567568                fn finalize_block() -> <Block as BlockT>::Header {569                    Executive::finalize_block()570                }571572                fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {573                    data.create_extrinsics()574                }575576                fn check_inherents(577                    block: Block,578                    data: sp_inherents::InherentData,579                ) -> sp_inherents::CheckInherentsResult {580                    data.check_extrinsics(&block)581                }582583                // fn random_seed() -> <Block as BlockT>::Hash {584                //     RandomnessCollectiveFlip::random_seed().0585                // }586            }587588            impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {589                fn validate_transaction(590                    source: TransactionSource,591                    tx: <Block as BlockT>::Extrinsic,592                    hash: <Block as BlockT>::Hash,593                ) -> TransactionValidity {594                    Executive::validate_transaction(source, tx, hash)595                }596            }597598            impl sp_offchain::OffchainWorkerApi<Block> for Runtime {599                fn offchain_worker(header: &<Block as BlockT>::Header) {600                    Executive::offchain_worker(header)601                }602            }603604            impl fp_rpc::EthereumRuntimeRPCApi<Block> for Runtime {605                fn chain_id() -> u64 {606                    <Runtime as pallet_evm::Config>::ChainId::get()607                }608609                fn account_basic(address: H160) -> EVMAccount {610                    let (account, _) = EVM::account_basic(&address);611                    account612                }613614                fn gas_price() -> U256 {615                    let (price, _) = <Runtime as pallet_evm::Config>::FeeCalculator::min_gas_price();616                    price617                }618619                fn account_code_at(address: H160) -> Vec<u8> {620                    EVM::account_codes(address)621                }622623                fn author() -> H160 {624                    <pallet_evm::Pallet<Runtime>>::find_author()625                }626627                fn storage_at(address: H160, index: U256) -> H256 {628                    let mut tmp = [0u8; 32];629                    index.to_big_endian(&mut tmp);630                    EVM::account_storages(address, H256::from_slice(&tmp[..]))631                }632633                #[allow(clippy::redundant_closure)]634                fn call(635                    from: H160,636                    to: H160,637                    data: Vec<u8>,638                    value: U256,639                    gas_limit: U256,640                    max_fee_per_gas: Option<U256>,641                    max_priority_fee_per_gas: Option<U256>,642                    nonce: Option<U256>,643                    estimate: bool,644                    access_list: Option<Vec<(H160, Vec<H256>)>>,645                ) -> Result<pallet_evm::CallInfo, sp_runtime::DispatchError> {646                    let config = if estimate {647                        let mut config = <Runtime as pallet_evm::Config>::config().clone();648                        config.estimate = true;649                        Some(config)650                    } else {651                        None652                    };653654                    let is_transactional = false;655                    <Runtime as pallet_evm::Config>::Runner::call(656                        CrossAccountId::from_eth(from),657                        to,658                        data,659                        value,660                        gas_limit.low_u64(),661                        max_fee_per_gas,662                        max_priority_fee_per_gas,663                        nonce,664                        access_list.unwrap_or_default(),665                        is_transactional,666                        config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),667                    ).map_err(|err| err.error.into())668                }669670                #[allow(clippy::redundant_closure)]671                fn create(672                    from: H160,673                    data: Vec<u8>,674                    value: U256,675                    gas_limit: U256,676                    max_fee_per_gas: Option<U256>,677                    max_priority_fee_per_gas: Option<U256>,678                    nonce: Option<U256>,679                    estimate: bool,680                    access_list: Option<Vec<(H160, Vec<H256>)>>,681                ) -> Result<pallet_evm::CreateInfo, sp_runtime::DispatchError> {682                    let config = if estimate {683                        let mut config = <Runtime as pallet_evm::Config>::config().clone();684                        config.estimate = true;685                        Some(config)686                    } else {687                        None688                    };689690                    let is_transactional = false;691                    <Runtime as pallet_evm::Config>::Runner::create(692                        CrossAccountId::from_eth(from),693                        data,694                        value,695                        gas_limit.low_u64(),696                        max_fee_per_gas,697                        max_priority_fee_per_gas,698                        nonce,699                        access_list.unwrap_or_default(),700                        is_transactional,701                        config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),702                    ).map_err(|err| err.error.into())703                }704705                fn current_transaction_statuses() -> Option<Vec<TransactionStatus>> {706                    Ethereum::current_transaction_statuses()707                }708709                fn current_block() -> Option<pallet_ethereum::Block> {710                    Ethereum::current_block()711                }712713                fn current_receipts() -> Option<Vec<pallet_ethereum::Receipt>> {714                    Ethereum::current_receipts()715                }716717                fn current_all() -> (718                    Option<pallet_ethereum::Block>,719                    Option<Vec<pallet_ethereum::Receipt>>,720                    Option<Vec<TransactionStatus>>721                ) {722                    (723                        Ethereum::current_block(),724                        Ethereum::current_receipts(),725                        Ethereum::current_transaction_statuses()726                    )727                }728729                fn extrinsic_filter(xts: Vec<<Block as sp_api::BlockT>::Extrinsic>) -> Vec<pallet_ethereum::Transaction> {730                    xts.into_iter().filter_map(|xt| match xt.0.function {731                        Call::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction),732                        _ => None733                    }).collect()734                }735736                fn elasticity() -> Option<Permill> {737                    None738                }739            }740741            impl fp_rpc::ConvertTransactionRuntimeApi<Block> for Runtime {742                fn convert_transaction(transaction: pallet_ethereum::Transaction) -> <Block as BlockT>::Extrinsic  {743                    UncheckedExtrinsic::new_unsigned(744                        pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),745                    )746                }747            }748749            impl sp_session::SessionKeys<Block> for Runtime {750                fn decode_session_keys(751                    encoded: Vec<u8>,752                ) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {753                    SessionKeys::decode_into_raw_public_keys(&encoded)754                }755756                fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {757                    SessionKeys::generate(seed)758                }759            }760761            impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {762                fn slot_duration() -> sp_consensus_aura::SlotDuration {763                    sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())764                }765766                fn authorities() -> Vec<AuraId> {767                    Aura::authorities().to_vec()768                }769            }770771            impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {772                fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {773                    ParachainSystem::collect_collation_info(header)774                }775            }776777            impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {778                fn account_nonce(account: AccountId) -> Index {779                    System::account_nonce(account)780                }781            }782783            impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {784                fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {785                    TransactionPayment::query_info(uxt, len)786                }787                fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {788                    TransactionPayment::query_fee_details(uxt, len)789                }790            }791792            /*793            impl pallet_contracts_rpc_runtime_api::ContractsApi<Block, AccountId, Balance, BlockNumber, Hash>794                for Runtime795            {796                fn call(797                    origin: AccountId,798                    dest: AccountId,799                    value: Balance,800                    gas_limit: u64,801                    input_data: Vec<u8>,802                ) -> pallet_contracts_primitives::ContractExecResult {803                    Contracts::bare_call(origin, dest, value, gas_limit, input_data, false)804                }805806                fn instantiate(807                    origin: AccountId,808                    endowment: Balance,809                    gas_limit: u64,810                    code: pallet_contracts_primitives::Code<Hash>,811                    data: Vec<u8>,812                    salt: Vec<u8>,813                ) -> pallet_contracts_primitives::ContractInstantiateResult<AccountId, BlockNumber>814                {815                    Contracts::bare_instantiate(origin, endowment, gas_limit, code, data, salt, true, false)816                }817818                fn get_storage(819                    address: AccountId,820                    key: [u8; 32],821                ) -> pallet_contracts_primitives::GetStorageResult {822                    Contracts::get_storage(address, key)823                }824825                fn rent_projection(826                    address: AccountId,827                ) -> pallet_contracts_primitives::RentProjectionResult<BlockNumber> {828                    Contracts::rent_projection(address)829                }830            }831            */832833            #[cfg(feature = "runtime-benchmarks")]834            impl frame_benchmarking::Benchmark<Block> for Runtime {835                fn benchmark_metadata(extra: bool) -> (836                    Vec<frame_benchmarking::BenchmarkList>,837                    Vec<frame_support::traits::StorageInfo>,838                ) {839                    use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList};840                    use frame_support::traits::StorageInfoTrait;841842                    let mut list = Vec::<BenchmarkList>::new();843844                    list_benchmark!(list, extra, pallet_evm_migration, EvmMigration);845                    list_benchmark!(list, extra, pallet_common, Common);846                    list_benchmark!(list, extra, pallet_unique, Unique);847                    list_benchmark!(list, extra, pallet_structure, Structure);848                    list_benchmark!(list, extra, pallet_inflation, Inflation);849                    list_benchmark!(list, extra, pallet_fungible, Fungible);850                    list_benchmark!(list, extra, pallet_refungible, Refungible);851                    list_benchmark!(list, extra, pallet_nonfungible, Nonfungible);852                    list_benchmark!(list, extra, pallet_unique_scheduler, Scheduler);853                    list_benchmark!(list, extra, pallet_proxy_rmrk_core, RmrkCore);854                    // list_benchmark!(list, extra, pallet_evm_coder_substrate, EvmCoderSubstrate);855856                    let storage_info = AllPalletsReversedWithSystemFirst::storage_info();857858                    return (list, storage_info)859                }860861                fn dispatch_benchmark(862                    config: frame_benchmarking::BenchmarkConfig863                ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {864                    use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey};865866                    let allowlist: Vec<TrackedStorageKey> = vec![867                        // Total Issuance868                        hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),869870                        // Block Number871                        hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),872                        // Execution Phase873                        hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),874                        // Event Count875                        hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),876                        // System Events877                        hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),878879                        // Evm CurrentLogs880                        hex_literal::hex!("1da53b775b270400e7e61ed5cbc5a146547f210cec367e9af919603343b9cb56").to_vec().into(),881882                        // Transactional depth883                        hex_literal::hex!("3a7472616e73616374696f6e5f6c6576656c3a").to_vec().into(),884                    ];885886                    let mut batches = Vec::<BenchmarkBatch>::new();887                    let params = (&config, &allowlist);888889                    add_benchmark!(params, batches, pallet_evm_migration, EvmMigration);890                    add_benchmark!(params, batches, pallet_common, Common);891                    add_benchmark!(params, batches, pallet_unique, Unique);892                    add_benchmark!(params, batches, pallet_structure, Structure);893                    add_benchmark!(params, batches, pallet_inflation, Inflation);894                    add_benchmark!(params, batches, pallet_fungible, Fungible);895                    add_benchmark!(params, batches, pallet_refungible, Refungible);896                    add_benchmark!(params, batches, pallet_nonfungible, Nonfungible);897                    add_benchmark!(params, batches, pallet_unique_scheduler, Scheduler);898                    add_benchmark!(params, batches, pallet_proxy_rmrk_core, RmrkCore);899                    // add_benchmark!(params, batches, pallet_evm_coder_substrate, EvmCoderSubstrate);900901                    if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }902                    Ok(batches)903                }904            }905906            #[cfg(feature = "try-runtime")]907            impl frame_try_runtime::TryRuntime<Block> for Runtime {908                fn on_runtime_upgrade() -> (Weight, Weight) {909                    log::info!("try-runtime::on_runtime_upgrade unique-chain.");910                    let weight = Executive::try_runtime_upgrade().unwrap();911                    (weight, RuntimeBlockWeights::get().max_block)912                }913914                fn execute_block_no_check(block: Block) -> Weight {915                    Executive::execute_block_no_check(block)916                }917            }918        }919    }920}