git.delta.rocks / unique-network / refs/commits / 32d10d5b642a

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: CollectionId = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)?;343                    let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;344345                    let resources = resource_collection346                        .collection_tokens()347                        .iter()348                        .filter_map(|(res_id)| Some(RmrkResourceInfo {349                            id: res_id.0,350                            pending: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).ok()?,351                            pending_removal: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).ok()?,352                            resource: match RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::ResourceType).ok()? {353                                ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {354                                    src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,355                                    metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,356                                    license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,357                                    thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,358                                }),359                                ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {360                                    parts: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Parts).ok()?,361                                    base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,362                                    src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,363                                    metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,364                                    license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,365                                    thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,366                                }),367                                ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {368                                    base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,369                                    src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,370                                    metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,371                                    slot: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Slot).ok()?,372                                    license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,373                                    thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,374                                }),375                            },376                        }))377                        .collect();378379                    Ok(resources)380                }381382                fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {383                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};384385                    let collection_id = match RmrkCore::unique_collection_id(collection_id) {386                        Ok(id) => id,387                        Err(_) => return Ok(None)388                    };389                    if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }390391                    let nft_id = TokenId(nft_id);392                    if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }393394                    let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;395                    Ok(396                        priorities.into_iter()397                            .enumerate()398                            .find(|(_, id)| *id == resource_id)399                            .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)400                    )401                }402403                fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {404                    use pallet_proxy_rmrk_core::{405                        RmrkProperty, misc::{CollectionType},406                    };407408                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {409                        Ok(c) => c,410                        Err(_) => return Ok(None),411                    };412413                    Ok(Some(RmrkBaseInfo {414                        issuer: collection.owner.clone(),415                        base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,416                        symbol: RmrkCore::rebind(&collection.token_prefix)?,417                    }))418                }419420                fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {421                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};422                    use pallet_common::CommonCollectionOperations;423424                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {425                        Ok(c) => c,426                        Err(_) => return Ok(Vec::new()),427                    };428429                    let parts = collection.collection_tokens()430                        .into_iter()431                        .filter_map(|token_id| {432                            let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;433434                            match nft_type {435                                NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {436                                    id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,437                                    src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,438                                    z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,439                                })),440                                NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {441                                    id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,442                                    src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,443                                    z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,444                                    equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,445                                })),446                                _ => None447                            }448                        })449                        .collect();450451                    Ok(parts)452                }453454                fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {455                    use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};456                    use pallet_common::CommonCollectionOperations;457458                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {459                        Ok(c) => c,460                        Err(_) => return Ok(Vec::new()),461                    };462463                    let theme_names = collection.collection_tokens()464                        .iter()465                        .filter_map(|token_id| {466                            let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).ok()?;467468                            match nft_type {469                                Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),470                                _ => None471                            }472                        })473                        .collect();474475                    Ok(theme_names)476                }477478                fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {479                    use pallet_proxy_rmrk_core::{480                        RmrkProperty,481                        misc::{CollectionType, NftType}482                    };483                    use pallet_common::CommonCollectionOperations;484485                    let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {486                        Ok(c) => c,487                        Err(_) => return Ok(None),488                    };489490                    let theme_info = collection.collection_tokens()491                        .into_iter()492                        .find_map(|token_id| {493                            RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;494495                            let name: RmrkString = RmrkCore::get_nft_property_decoded(496                                collection_id, token_id, RmrkProperty::ThemeName497                            ).ok()?;498499                            if name == theme_name {500                                Some((name, token_id))501                            } else {502                                None503                            }504                        });505506                    let (name, theme_id) = match theme_info {507                        Some((name, theme_id)) => (name, theme_id),508                        None => return Ok(None)509                    };510511                    let properties = RmrkCore::filter_user_properties(512                        collection_id,513                        Some(theme_id),514                        filter_keys,515                        |key, value| RmrkThemeProperty {516                            key,517                            value518                        }519                    )?;520521                    let inherit = RmrkCore::get_nft_property_decoded(522                        collection_id,523                        theme_id,524                        RmrkProperty::ThemeInherit525                    )?;526527                    let theme = RmrkTheme {528                        name,529                        properties,530                        inherit,531                    };532533                    Ok(Some(theme))534                }535            }536537            impl sp_api::Core<Block> for Runtime {538                fn version() -> RuntimeVersion {539                    VERSION540                }541542                fn execute_block(block: Block) {543                    Executive::execute_block(block)544                }545546                fn initialize_block(header: &<Block as BlockT>::Header) {547                    Executive::initialize_block(header)548                }549            }550551            impl sp_api::Metadata<Block> for Runtime {552                fn metadata() -> OpaqueMetadata {553                    OpaqueMetadata::new(Runtime::metadata().into())554                }555            }556557            impl sp_block_builder::BlockBuilder<Block> for Runtime {558                fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {559                    Executive::apply_extrinsic(extrinsic)560                }561562                fn finalize_block() -> <Block as BlockT>::Header {563                    Executive::finalize_block()564                }565566                fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {567                    data.create_extrinsics()568                }569570                fn check_inherents(571                    block: Block,572                    data: sp_inherents::InherentData,573                ) -> sp_inherents::CheckInherentsResult {574                    data.check_extrinsics(&block)575                }576577                // fn random_seed() -> <Block as BlockT>::Hash {578                //     RandomnessCollectiveFlip::random_seed().0579                // }580            }581582            impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {583                fn validate_transaction(584                    source: TransactionSource,585                    tx: <Block as BlockT>::Extrinsic,586                    hash: <Block as BlockT>::Hash,587                ) -> TransactionValidity {588                    Executive::validate_transaction(source, tx, hash)589                }590            }591592            impl sp_offchain::OffchainWorkerApi<Block> for Runtime {593                fn offchain_worker(header: &<Block as BlockT>::Header) {594                    Executive::offchain_worker(header)595                }596            }597598            impl fp_rpc::EthereumRuntimeRPCApi<Block> for Runtime {599                fn chain_id() -> u64 {600                    <Runtime as pallet_evm::Config>::ChainId::get()601                }602603                fn account_basic(address: H160) -> EVMAccount {604                    let (account, _) = EVM::account_basic(&address);605                    account606                }607608                fn gas_price() -> U256 {609                    let (price, _) = <Runtime as pallet_evm::Config>::FeeCalculator::min_gas_price();610                    price611                }612613                fn account_code_at(address: H160) -> Vec<u8> {614                    EVM::account_codes(address)615                }616617                fn author() -> H160 {618                    <pallet_evm::Pallet<Runtime>>::find_author()619                }620621                fn storage_at(address: H160, index: U256) -> H256 {622                    let mut tmp = [0u8; 32];623                    index.to_big_endian(&mut tmp);624                    EVM::account_storages(address, H256::from_slice(&tmp[..]))625                }626627                #[allow(clippy::redundant_closure)]628                fn call(629                    from: H160,630                    to: H160,631                    data: Vec<u8>,632                    value: U256,633                    gas_limit: U256,634                    max_fee_per_gas: Option<U256>,635                    max_priority_fee_per_gas: Option<U256>,636                    nonce: Option<U256>,637                    estimate: bool,638                    access_list: Option<Vec<(H160, Vec<H256>)>>,639                ) -> Result<pallet_evm::CallInfo, sp_runtime::DispatchError> {640                    let config = if estimate {641                        let mut config = <Runtime as pallet_evm::Config>::config().clone();642                        config.estimate = true;643                        Some(config)644                    } else {645                        None646                    };647648                    let is_transactional = false;649                    <Runtime as pallet_evm::Config>::Runner::call(650                        CrossAccountId::from_eth(from),651                        to,652                        data,653                        value,654                        gas_limit.low_u64(),655                        max_fee_per_gas,656                        max_priority_fee_per_gas,657                        nonce,658                        access_list.unwrap_or_default(),659                        is_transactional,660                        config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),661                    ).map_err(|err| err.error.into())662                }663664                #[allow(clippy::redundant_closure)]665                fn create(666                    from: H160,667                    data: Vec<u8>,668                    value: U256,669                    gas_limit: U256,670                    max_fee_per_gas: Option<U256>,671                    max_priority_fee_per_gas: Option<U256>,672                    nonce: Option<U256>,673                    estimate: bool,674                    access_list: Option<Vec<(H160, Vec<H256>)>>,675                ) -> Result<pallet_evm::CreateInfo, sp_runtime::DispatchError> {676                    let config = if estimate {677                        let mut config = <Runtime as pallet_evm::Config>::config().clone();678                        config.estimate = true;679                        Some(config)680                    } else {681                        None682                    };683684                    let is_transactional = false;685                    <Runtime as pallet_evm::Config>::Runner::create(686                        CrossAccountId::from_eth(from),687                        data,688                        value,689                        gas_limit.low_u64(),690                        max_fee_per_gas,691                        max_priority_fee_per_gas,692                        nonce,693                        access_list.unwrap_or_default(),694                        is_transactional,695                        config.as_ref().unwrap_or_else(|| <Runtime as pallet_evm::Config>::config()),696                    ).map_err(|err| err.error.into())697                }698699                fn current_transaction_statuses() -> Option<Vec<TransactionStatus>> {700                    Ethereum::current_transaction_statuses()701                }702703                fn current_block() -> Option<pallet_ethereum::Block> {704                    Ethereum::current_block()705                }706707                fn current_receipts() -> Option<Vec<pallet_ethereum::Receipt>> {708                    Ethereum::current_receipts()709                }710711                fn current_all() -> (712                    Option<pallet_ethereum::Block>,713                    Option<Vec<pallet_ethereum::Receipt>>,714                    Option<Vec<TransactionStatus>>715                ) {716                    (717                        Ethereum::current_block(),718                        Ethereum::current_receipts(),719                        Ethereum::current_transaction_statuses()720                    )721                }722723                fn extrinsic_filter(xts: Vec<<Block as sp_api::BlockT>::Extrinsic>) -> Vec<pallet_ethereum::Transaction> {724                    xts.into_iter().filter_map(|xt| match xt.0.function {725                        Call::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction),726                        _ => None727                    }).collect()728                }729730                fn elasticity() -> Option<Permill> {731                    None732                }733            }734735            impl fp_rpc::ConvertTransactionRuntimeApi<Block> for Runtime {736                fn convert_transaction(transaction: pallet_ethereum::Transaction) -> <Block as BlockT>::Extrinsic  {737                    UncheckedExtrinsic::new_unsigned(738                        pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),739                    )740                }741            }742743            impl sp_session::SessionKeys<Block> for Runtime {744                fn decode_session_keys(745                    encoded: Vec<u8>,746                ) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {747                    SessionKeys::decode_into_raw_public_keys(&encoded)748                }749750                fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {751                    SessionKeys::generate(seed)752                }753            }754755            impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {756                fn slot_duration() -> sp_consensus_aura::SlotDuration {757                    sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())758                }759760                fn authorities() -> Vec<AuraId> {761                    Aura::authorities().to_vec()762                }763            }764765            impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {766                fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {767                    ParachainSystem::collect_collation_info(header)768                }769            }770771            impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {772                fn account_nonce(account: AccountId) -> Index {773                    System::account_nonce(account)774                }775            }776777            impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {778                fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {779                    TransactionPayment::query_info(uxt, len)780                }781                fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {782                    TransactionPayment::query_fee_details(uxt, len)783                }784            }785786            /*787            impl pallet_contracts_rpc_runtime_api::ContractsApi<Block, AccountId, Balance, BlockNumber, Hash>788                for Runtime789            {790                fn call(791                    origin: AccountId,792                    dest: AccountId,793                    value: Balance,794                    gas_limit: u64,795                    input_data: Vec<u8>,796                ) -> pallet_contracts_primitives::ContractExecResult {797                    Contracts::bare_call(origin, dest, value, gas_limit, input_data, false)798                }799800                fn instantiate(801                    origin: AccountId,802                    endowment: Balance,803                    gas_limit: u64,804                    code: pallet_contracts_primitives::Code<Hash>,805                    data: Vec<u8>,806                    salt: Vec<u8>,807                ) -> pallet_contracts_primitives::ContractInstantiateResult<AccountId, BlockNumber>808                {809                    Contracts::bare_instantiate(origin, endowment, gas_limit, code, data, salt, true, false)810                }811812                fn get_storage(813                    address: AccountId,814                    key: [u8; 32],815                ) -> pallet_contracts_primitives::GetStorageResult {816                    Contracts::get_storage(address, key)817                }818819                fn rent_projection(820                    address: AccountId,821                ) -> pallet_contracts_primitives::RentProjectionResult<BlockNumber> {822                    Contracts::rent_projection(address)823                }824            }825            */826827            #[cfg(feature = "runtime-benchmarks")]828            impl frame_benchmarking::Benchmark<Block> for Runtime {829                fn benchmark_metadata(extra: bool) -> (830                    Vec<frame_benchmarking::BenchmarkList>,831                    Vec<frame_support::traits::StorageInfo>,832                ) {833                    use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList};834                    use frame_support::traits::StorageInfoTrait;835836                    let mut list = Vec::<BenchmarkList>::new();837838                    list_benchmark!(list, extra, pallet_evm_migration, EvmMigration);839                    list_benchmark!(list, extra, pallet_common, Common);840                    list_benchmark!(list, extra, pallet_unique, Unique);841                    list_benchmark!(list, extra, pallet_structure, Structure);842                    list_benchmark!(list, extra, pallet_inflation, Inflation);843                    list_benchmark!(list, extra, pallet_fungible, Fungible);844                    list_benchmark!(list, extra, pallet_refungible, Refungible);845                    list_benchmark!(list, extra, pallet_nonfungible, Nonfungible);846                    list_benchmark!(list, extra, pallet_proxy_rmrk_core, RmrkCore);847                    // list_benchmark!(list, extra, pallet_evm_coder_substrate, EvmCoderSubstrate);848849                    let storage_info = AllPalletsReversedWithSystemFirst::storage_info();850851                    return (list, storage_info)852                }853854                fn dispatch_benchmark(855                    config: frame_benchmarking::BenchmarkConfig856                ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {857                    use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey};858859                    let allowlist: Vec<TrackedStorageKey> = vec![860                        // Total Issuance861                        hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(),862863                        // Block Number864                        hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(),865                        // Execution Phase866                        hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(),867                        // Event Count868                        hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(),869                        // System Events870                        hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(),871872                        // Evm CurrentLogs873                        hex_literal::hex!("1da53b775b270400e7e61ed5cbc5a146547f210cec367e9af919603343b9cb56").to_vec().into(),874875                        // Transactional depth876                        hex_literal::hex!("3a7472616e73616374696f6e5f6c6576656c3a").to_vec().into(),877                    ];878879                    let mut batches = Vec::<BenchmarkBatch>::new();880                    let params = (&config, &allowlist);881882                    add_benchmark!(params, batches, pallet_evm_migration, EvmMigration);883                    add_benchmark!(params, batches, pallet_common, Common);884                    add_benchmark!(params, batches, pallet_unique, Unique);885                    add_benchmark!(params, batches, pallet_structure, Structure);886                    add_benchmark!(params, batches, pallet_inflation, Inflation);887                    add_benchmark!(params, batches, pallet_fungible, Fungible);888                    add_benchmark!(params, batches, pallet_refungible, Refungible);889                    add_benchmark!(params, batches, pallet_nonfungible, Nonfungible);890                    add_benchmark!(params, batches, pallet_proxy_rmrk_core, RmrkCore);891                    // add_benchmark!(params, batches, pallet_evm_coder_substrate, EvmCoderSubstrate);892893                    if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) }894                    Ok(batches)895                }896            }897898            #[cfg(feature = "try-runtime")]899            impl frame_try_runtime::TryRuntime<Block> for Runtime {900                fn on_runtime_upgrade() -> (Weight, Weight) {901                    log::info!("try-runtime::on_runtime_upgrade unique-chain.");902                    let weight = Executive::try_runtime_upgrade().unwrap();903                    (weight, RuntimeBlockWeights::get().max_block)904                }905906                fn execute_block_no_check(block: Block) -> Weight {907                    Executive::execute_block_no_check(block)908                }909            }910        }911    }912}