difftreelog
Merge pull request #385 from UniqueNetwork/feature/conditional-rmrk
in: master
feat(rmrk): remove RMRK proxy from unique runtime
10 files changed
node/rpc/Cargo.tomldiffbeforeafterboth--- a/node/rpc/Cargo.toml
+++ b/node/rpc/Cargo.toml
@@ -63,3 +63,4 @@
[features]
default = []
std = []
+unique-runtime = []
node/rpc/src/lib.rsdiffbeforeafterboth--- a/node/rpc/src/lib.rs
+++ b/node/rpc/src/lib.rs
@@ -169,7 +169,11 @@
Eth, EthApiServer, EthDevSigner, EthFilter, EthFilterApiServer, EthPubSub,
EthPubSubApiServer, EthSigner, Net, NetApiServer, Web3, Web3ApiServer,
};
- use uc_rpc::{UniqueApiServer, Unique, RmrkApiServer, Rmrk};
+ use uc_rpc::{UniqueApiServer, Unique};
+
+ #[cfg(not(feature = "unique-runtime"))]
+ use uc_rpc::{RmrkApiServer, Rmrk};
+
// use pallet_contracts_rpc::{Contracts, ContractsApi};
use pallet_transaction_payment_rpc::{TransactionPaymentRpc, TransactionPaymentApiServer};
use substrate_frame_rpc_system::{SystemRpc, SystemApiServer};
@@ -223,6 +227,8 @@
)?;
io.merge(Unique::new(client.clone()).into_rpc())?;
+
+ #[cfg(not(feature = "unique-runtime"))]
io.merge(Rmrk::new(client.clone()).into_rpc())?;
if let Some(filter_pool) = filter_pool {
runtime/common/src/runtime_apis.rsdiffbeforeafterboth--- a/runtime/common/src/runtime_apis.rs
+++ b/runtime/common/src/runtime_apis.rs
@@ -144,402 +144,6 @@
}
}
- impl rmrk_rpc::RmrkApi<
- Block,
- AccountId,
- RmrkCollectionInfo<AccountId>,
- RmrkInstanceInfo<AccountId>,
- RmrkResourceInfo,
- RmrkPropertyInfo,
- RmrkBaseInfo<AccountId>,
- RmrkPartType,
- RmrkTheme
- > for Runtime {
- fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
- Ok(RmrkCore::last_collection_idx())
- }
-
- fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let nfts_count = collection.total_supply();
-
- Ok(Some(RmrkCollectionInfo {
- issuer: collection.owner.clone(),
- metadata: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::Metadata)?,
- max: collection.limits.token_limit,
- symbol: RmrkCore::rebind(&collection.token_prefix)?,
- nfts_count
- }))
- }
-
- fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {
- use up_data_structs::mapping::TokenAddressMapping;
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let nft_id = TokenId(nft_by_id);
- if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }
-
- let owner = match collection.token_owner(nft_id) {
- Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {
- Some((col, tok)) => {
- let rmrk_collection = RmrkCore::rmrk_collection_id(col)?;
-
- RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)
- }
- None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())
- },
- None => return Ok(None)
- };
-
- Ok(Some(RmrkInstanceInfo {
- owner: owner,
- royalty: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::RoyaltyInfo)?,
- metadata: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Metadata)?,
- equipped: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Equipped)?,
- pending: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::PendingNftAccept)?,
- }))
- }
-
- fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let cross_account_id = CrossAccountId::from_sub(account_id);
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let tokens = collection.account_tokens(cross_account_id)
- .into_iter()
- .filter(|token| {
- let is_pending = RmrkCore::get_nft_property_decoded(
- collection_id,
- *token,
- RmrkProperty::PendingNftAccept
- ).unwrap_or(true);
-
- !is_pending
- })
- .map(|token| token.0)
- .collect();
-
- Ok(tokens)
- }
-
- fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {
- use pallet_proxy_rmrk_core::RmrkProperty;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- let nft_id = TokenId(nft_id);
- if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(Vec::new()); }
-
- Ok(
- pallet_nonfungible::TokenChildren::<Runtime>::iter_prefix((collection_id, nft_id))
- .filter_map(|((child_collection, child_token), _)| {
- let is_pending = RmrkCore::get_nft_property_decoded(
- child_collection,
- child_token,
- RmrkProperty::PendingNftAccept
- ).ok()?;
-
- if is_pending {
- return None;
- }
-
- let rmrk_child_collection = RmrkCore::rmrk_collection_id(
- child_collection
- ).ok()?;
-
- Some(RmrkNftChild {
- collection_id: rmrk_child_collection,
- nft_id: child_token.0,
- })
- }).collect()
- )
- }
-
- fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::CollectionType;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() {
- return Ok(Vec::new());
- }
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- /* token_id = */ None,
- filter_keys,
- |key, value| RmrkPropertyInfo {
- key,
- value
- }
- )?;
-
- Ok(properties)
- }
-
- fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::misc::NftType;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- let token_id = TokenId(nft_id);
-
- if RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {
- return Ok(Vec::new());
- }
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- Some(token_id),
- filter_keys,
- |key, value| RmrkPropertyInfo {
- key,
- value
- }
- )?;
-
- Ok(properties)
- }
-
- fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType}};
- use pallet_common::CommonCollectionOperations;
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(Vec::new())
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }
-
- let nft_id = TokenId(nft_id);
- if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }
-
- let res_collection_id: Option<CollectionId> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)?;
-
- let res_collection_id = match res_collection_id {
- Some(id) => id,
- None => return Ok(Vec::new())
- };
-
- let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;
-
- let resources = resource_collection
- .collection_tokens()
- .iter()
- .filter_map(|(res_id)| Some(RmrkResourceInfo {
- id: res_id.0,
- pending: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).ok()?,
- pending_removal: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).ok()?,
- resource: match RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::ResourceType).ok()? {
- ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {
- src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
- metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
- license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
- thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
- }),
- ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {
- parts: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Parts).ok()?,
- base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
- src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
- metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
- license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
- thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
- }),
- ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {
- base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
- src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
- metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
- slot: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Slot).ok()?,
- license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
- thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
- }),
- },
- }))
- .collect();
-
- Ok(resources)
- }
-
- fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
-
- let collection_id = match RmrkCore::unique_collection_id(collection_id) {
- Ok(id) => id,
- Err(_) => return Ok(None)
- };
- if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }
-
- let nft_id = TokenId(nft_id);
- if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }
-
- let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;
- Ok(
- priorities.into_iter()
- .enumerate()
- .find(|(_, id)| *id == resource_id)
- .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)
- )
- }
-
- fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {
- use pallet_proxy_rmrk_core::{
- RmrkProperty, misc::{CollectionType},
- };
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- Ok(Some(RmrkBaseInfo {
- issuer: collection.owner.clone(),
- base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,
- symbol: RmrkCore::rebind(&collection.token_prefix)?,
- }))
- }
-
- fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let parts = collection.collection_tokens()
- .into_iter()
- .filter_map(|token_id| {
- let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;
-
- match nft_type {
- NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {
- id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
- src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
- z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
- })),
- NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {
- id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
- src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
- z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
- equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,
- })),
- _ => None
- }
- })
- .collect();
-
- Ok(parts)
- }
-
- fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
- use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(Vec::new()),
- };
-
- let theme_names = collection.collection_tokens()
- .iter()
- .filter_map(|token_id| {
- let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).ok()?;
-
- match nft_type {
- Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),
- _ => None
- }
- })
- .collect();
-
- Ok(theme_names)
- }
-
- fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {
- use pallet_proxy_rmrk_core::{
- RmrkProperty,
- misc::{CollectionType, NftType}
- };
- use pallet_common::CommonCollectionOperations;
-
- let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
- Ok(c) => c,
- Err(_) => return Ok(None),
- };
-
- let theme_info = collection.collection_tokens()
- .into_iter()
- .find_map(|token_id| {
- RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;
-
- let name: RmrkString = RmrkCore::get_nft_property_decoded(
- collection_id, token_id, RmrkProperty::ThemeName
- ).ok()?;
-
- if name == theme_name {
- Some((name, token_id))
- } else {
- None
- }
- });
-
- let (name, theme_id) = match theme_info {
- Some((name, theme_id)) => (name, theme_id),
- None => return Ok(None)
- };
-
- let properties = RmrkCore::filter_user_properties(
- collection_id,
- Some(theme_id),
- filter_keys,
- |key, value| RmrkThemeProperty {
- key,
- value
- }
- )?;
-
- let inherit = RmrkCore::get_nft_property_decoded(
- collection_id,
- theme_id,
- RmrkProperty::ThemeInherit
- )?;
-
- let theme = RmrkTheme {
- name,
- properties,
- inherit,
- };
-
- Ok(Some(theme))
- }
- }
-
impl sp_api::Core<Block> for Runtime {
fn version() -> RuntimeVersion {
VERSION
runtime/opal/src/lib.rsdiffbeforeafterboth--- a/runtime/opal/src/lib.rs
+++ b/runtime/opal/src/lib.rs
@@ -1315,7 +1315,405 @@
}};
}
-impl_common_runtime_apis!();
+impl_common_runtime_apis! {
+ #![custom_apis]
+
+ impl rmrk_rpc::RmrkApi<
+ Block,
+ AccountId,
+ RmrkCollectionInfo<AccountId>,
+ RmrkInstanceInfo<AccountId>,
+ RmrkResourceInfo,
+ RmrkPropertyInfo,
+ RmrkBaseInfo<AccountId>,
+ RmrkPartType,
+ RmrkTheme
+ > for Runtime {
+ fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
+ Ok(RmrkCore::last_collection_idx())
+ }
+
+ fn collection_by_id(collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {
+ use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
+ use pallet_common::CommonCollectionOperations;
+
+ let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ let nfts_count = collection.total_supply();
+
+ Ok(Some(RmrkCollectionInfo {
+ issuer: collection.owner.clone(),
+ metadata: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::Metadata)?,
+ max: collection.limits.token_limit,
+ symbol: RmrkCore::rebind(&collection.token_prefix)?,
+ nfts_count
+ }))
+ }
+
+ fn nft_by_id(collection_id: RmrkCollectionId, nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {
+ use up_data_structs::mapping::TokenAddressMapping;
+ use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
+ use pallet_common::CommonCollectionOperations;
+
+ let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ let nft_id = TokenId(nft_by_id);
+ if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(None); }
+
+ let owner = match collection.token_owner(nft_id) {
+ Some(owner) => match <Runtime as pallet_common::Config>::CrossTokenAddressMapping::address_to_token(&owner) {
+ Some((col, tok)) => {
+ let rmrk_collection = RmrkCore::rmrk_collection_id(col)?;
+
+ RmrkAccountIdOrCollectionNftTuple::CollectionAndNftTuple(rmrk_collection, tok.0)
+ }
+ None => RmrkAccountIdOrCollectionNftTuple::AccountId(owner.as_sub().clone())
+ },
+ None => return Ok(None)
+ };
+
+ Ok(Some(RmrkInstanceInfo {
+ owner: owner,
+ royalty: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::RoyaltyInfo)?,
+ metadata: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Metadata)?,
+ equipped: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Equipped)?,
+ pending: RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::PendingNftAccept)?,
+ }))
+ }
+
+ fn account_tokens(account_id: AccountId, collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {
+ use pallet_proxy_rmrk_core::{RmrkProperty, misc::CollectionType};
+ use pallet_common::CommonCollectionOperations;
+
+ let cross_account_id = CrossAccountId::from_sub(account_id);
+
+ let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(collection_id, CollectionType::Regular) {
+ Ok(c) => c,
+ Err(_) => return Ok(Vec::new()),
+ };
+
+ let tokens = collection.account_tokens(cross_account_id)
+ .into_iter()
+ .filter(|token| {
+ let is_pending = RmrkCore::get_nft_property_decoded(
+ collection_id,
+ *token,
+ RmrkProperty::PendingNftAccept
+ ).unwrap_or(true);
+
+ !is_pending
+ })
+ .map(|token| token.0)
+ .collect();
+
+ Ok(tokens)
+ }
+
+ fn nft_children(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {
+ use pallet_proxy_rmrk_core::RmrkProperty;
+
+ let collection_id = match RmrkCore::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new())
+ };
+ let nft_id = TokenId(nft_id);
+ if !RmrkCore::nft_exists(collection_id, nft_id) { return Ok(Vec::new()); }
+
+ Ok(
+ pallet_nonfungible::TokenChildren::<Runtime>::iter_prefix((collection_id, nft_id))
+ .filter_map(|((child_collection, child_token), _)| {
+ let is_pending = RmrkCore::get_nft_property_decoded(
+ child_collection,
+ child_token,
+ RmrkProperty::PendingNftAccept
+ ).ok()?;
+
+ if is_pending {
+ return None;
+ }
+
+ let rmrk_child_collection = RmrkCore::rmrk_collection_id(
+ child_collection
+ ).ok()?;
+
+ Some(RmrkNftChild {
+ collection_id: rmrk_child_collection,
+ nft_id: child_token.0,
+ })
+ }).collect()
+ )
+ }
+
+ fn collection_properties(collection_id: RmrkCollectionId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+ use pallet_proxy_rmrk_core::misc::CollectionType;
+
+ let collection_id = match RmrkCore::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new())
+ };
+ if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let properties = RmrkCore::filter_user_properties(
+ collection_id,
+ /* token_id = */ None,
+ filter_keys,
+ |key, value| RmrkPropertyInfo {
+ key,
+ value
+ }
+ )?;
+
+ Ok(properties)
+ }
+
+ fn nft_properties(collection_id: RmrkCollectionId, nft_id: RmrkNftId, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+ use pallet_proxy_rmrk_core::misc::NftType;
+
+ let collection_id = match RmrkCore::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new())
+ };
+ let token_id = TokenId(nft_id);
+
+ if RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Regular).is_err() {
+ return Ok(Vec::new());
+ }
+
+ let properties = RmrkCore::filter_user_properties(
+ collection_id,
+ Some(token_id),
+ filter_keys,
+ |key, value| RmrkPropertyInfo {
+ key,
+ value
+ }
+ )?;
+
+ Ok(properties)
+ }
+
+ fn nft_resources(collection_id: RmrkCollectionId, nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
+ use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType, ResourceType}};
+ use pallet_common::CommonCollectionOperations;
+
+ let collection_id = match RmrkCore::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(Vec::new())
+ };
+ if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(Vec::new()); }
+
+ let nft_id = TokenId(nft_id);
+ if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(Vec::new()); }
+
+ let res_collection_id: Option<CollectionId> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourceCollection)?;
+
+ let res_collection_id = match res_collection_id {
+ Some(id) => id,
+ None => return Ok(Vec::new())
+ };
+
+ let resource_collection = RmrkCore::get_typed_nft_collection(res_collection_id, CollectionType::Resource)?;
+
+ let resources = resource_collection
+ .collection_tokens()
+ .iter()
+ .filter_map(|res_id| Some(RmrkResourceInfo {
+ id: res_id.0,
+ pending: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceAccept).ok()?,
+ pending_removal: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::PendingResourceRemoval).ok()?,
+ resource: match RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::ResourceType).ok()? {
+ ResourceType::Basic => RmrkResourceTypes::Basic(RmrkBasicResource {
+ src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
+ metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
+ license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
+ thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
+ }),
+ ResourceType::Composable => RmrkResourceTypes::Composable(RmrkComposableResource {
+ parts: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Parts).ok()?,
+ base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
+ src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
+ metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
+ license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
+ thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
+ }),
+ ResourceType::Slot => RmrkResourceTypes::Slot(RmrkSlotResource {
+ base: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Base).ok()?,
+ src: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Src).ok()?,
+ metadata: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Metadata).ok()?,
+ slot: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Slot).ok()?,
+ license: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::License).ok()?,
+ thumb: RmrkCore::get_nft_property_decoded(res_collection_id, *res_id, RmrkProperty::Thumb).ok()?,
+ }),
+ },
+ }))
+ .collect();
+
+ Ok(resources)
+ }
+
+ fn nft_resource_priority(collection_id: RmrkCollectionId, nft_id: RmrkNftId, resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {
+ use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
+
+ let collection_id = match RmrkCore::unique_collection_id(collection_id) {
+ Ok(id) => id,
+ Err(_) => return Ok(None)
+ };
+ if RmrkCore::ensure_collection_type(collection_id, CollectionType::Regular).is_err() { return Ok(None); }
+
+ let nft_id = TokenId(nft_id);
+ if RmrkCore::ensure_nft_type(collection_id, nft_id, NftType::Regular).is_err() { return Ok(None); }
+
+ let priorities: Vec<_> = RmrkCore::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::ResourcePriorities)?;
+ Ok(
+ priorities.into_iter()
+ .enumerate()
+ .find(|(_, id)| *id == resource_id)
+ .map(|(priority, _): (usize, RmrkResourceId)| priority as u32)
+ )
+ }
+
+ fn base(base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {
+ use pallet_proxy_rmrk_core::{
+ RmrkProperty, misc::{CollectionType},
+ };
+
+ let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ Ok(Some(RmrkBaseInfo {
+ issuer: collection.owner.clone(),
+ base_type: RmrkCore::get_collection_property_decoded(collection_id, RmrkProperty::BaseType)?,
+ symbol: RmrkCore::rebind(&collection.token_prefix)?,
+ }))
+ }
+
+ fn base_parts(base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
+ use pallet_proxy_rmrk_core::{RmrkProperty, misc::{CollectionType, NftType}};
+ use pallet_common::CommonCollectionOperations;
+
+ let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
+ Ok(c) => c,
+ Err(_) => return Ok(Vec::new()),
+ };
+
+ let parts = collection.collection_tokens()
+ .into_iter()
+ .filter_map(|token_id| {
+ let nft_type = RmrkCore::get_nft_type(collection_id, token_id).ok()?;
+
+ match nft_type {
+ NftType::FixedPart => Some(RmrkPartType::FixedPart(RmrkFixedPart {
+ id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
+ src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
+ z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
+ })),
+ NftType::SlotPart => Some(RmrkPartType::SlotPart(RmrkSlotPart {
+ id: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ExternalPartId).ok()?,
+ src: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::Src).ok()?,
+ z: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::ZIndex).ok()?,
+ equippable: RmrkCore::get_nft_property_decoded(collection_id, token_id, RmrkProperty::EquippableList).ok()?,
+ })),
+ _ => None
+ }
+ })
+ .collect();
+
+ Ok(parts)
+ }
+
+ fn theme_names(base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
+ use pallet_proxy_rmrk_core::{RmrkProperty, misc::{NftType, CollectionType}};
+ use pallet_common::CommonCollectionOperations;
+
+ let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
+ Ok(c) => c,
+ Err(_) => return Ok(Vec::new()),
+ };
+
+ let theme_names = collection.collection_tokens()
+ .iter()
+ .filter_map(|token_id| {
+ let nft_type = RmrkCore::get_nft_type(collection_id, *token_id).ok()?;
+
+ match nft_type {
+ NftType::Theme => RmrkCore::get_nft_property_decoded(collection_id, *token_id, RmrkProperty::ThemeName).ok(),
+ _ => None
+ }
+ })
+ .collect();
+
+ Ok(theme_names)
+ }
+
+ fn theme(base_id: RmrkBaseId, theme_name: RmrkThemeName, filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {
+ use pallet_proxy_rmrk_core::{
+ RmrkProperty,
+ misc::{CollectionType, NftType}
+ };
+ use pallet_common::CommonCollectionOperations;
+
+ let (collection, collection_id) = match RmrkCore::get_typed_nft_collection_mapped(base_id, CollectionType::Base) {
+ Ok(c) => c,
+ Err(_) => return Ok(None),
+ };
+
+ let theme_info = collection.collection_tokens()
+ .into_iter()
+ .find_map(|token_id| {
+ RmrkCore::ensure_nft_type(collection_id, token_id, NftType::Theme).ok()?;
+
+ let name: RmrkString = RmrkCore::get_nft_property_decoded(
+ collection_id, token_id, RmrkProperty::ThemeName
+ ).ok()?;
+
+ if name == theme_name {
+ Some((name, token_id))
+ } else {
+ None
+ }
+ });
+
+ let (name, theme_id) = match theme_info {
+ Some((name, theme_id)) => (name, theme_id),
+ None => return Ok(None)
+ };
+
+ let properties = RmrkCore::filter_user_properties(
+ collection_id,
+ Some(theme_id),
+ filter_keys,
+ |key, value| RmrkThemeProperty {
+ key,
+ value
+ }
+ )?;
+
+ let inherit = RmrkCore::get_nft_property_decoded(
+ collection_id,
+ theme_id,
+ RmrkProperty::ThemeInherit
+ )?;
+
+ let theme = RmrkTheme {
+ name,
+ properties,
+ inherit,
+ };
+
+ Ok(Some(theme))
+ }
+ }
+}
struct CheckInherents;
runtime/quartz/src/lib.rsdiffbeforeafterboth1// 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//! The Substrate Node Template runtime. This can be compiled with `#[no_std]`, ready for Wasm.1819#![cfg_attr(not(feature = "std"), no_std)]20// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.21#![recursion_limit = "1024"]22#![allow(clippy::from_over_into, clippy::identity_op)]23#![allow(clippy::fn_to_numeric_cast_with_truncation)]24// Make the WASM binary available.25#[cfg(feature = "std")]26include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));2728use sp_api::impl_runtime_apis;29use sp_core::{crypto::KeyTypeId, OpaqueMetadata, H256, U256, H160};30use sp_runtime::DispatchError;31use fp_self_contained::*;32// #[cfg(any(feature = "std", test))]33// pub use sp_runtime::BuildStorage;3435use sp_runtime::{36 Permill, Perbill, Percent, create_runtime_str, generic, impl_opaque_keys,37 traits::{AccountIdLookup, BlakeTwo256, Block as BlockT, AccountIdConversion, Zero, Member},38 transaction_validity::{TransactionSource, TransactionValidity},39 ApplyExtrinsicResult, RuntimeAppPublic,40};4142use sp_std::prelude::*;4344#[cfg(feature = "std")]45use sp_version::NativeVersion;46use sp_version::RuntimeVersion;47pub use pallet_transaction_payment::{48 Multiplier, TargetedFeeAdjustment, FeeDetails, RuntimeDispatchInfo,49};50// A few exports that help ease life for downstream crates.51pub use pallet_balances::Call as BalancesCall;52pub use pallet_evm::{53 EnsureAddressTruncated, HashedAddressMapping, Runner, account::CrossAccountId as _,54 OnMethodCall, Account as EVMAccount, FeeCalculator, GasWeightMapping,55};56pub use frame_support::{57 construct_runtime, match_types,58 dispatch::DispatchResult,59 PalletId, parameter_types, StorageValue, ConsensusEngineId,60 traits::{61 tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Everything,62 Currency, ExistenceRequirement, Get, IsInVec, KeyOwnerProofSystem, LockIdentifier,63 OnUnbalanced, Randomness, FindAuthor, ConstU32, Imbalance, PrivilegeCmp,64 },65 weights::{66 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},67 DispatchClass, DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,68 WeightToFeePolynomial, WeightToFeeCoefficient, WeightToFeeCoefficients, ConstantMultiplier,69 },70};71use pallet_unique_scheduler::DispatchCall;72use up_data_structs::{73 CollectionId, TokenId, TokenData, Property, PropertyKeyPermission, CollectionLimits,74 CollectionStats, RpcCollection,75 mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},76 TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,77 RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkThemeProperty, RmrkCollectionId,78 RmrkNftId, RmrkAccountIdOrCollectionNftTuple, RmrkNftChild, RmrkPropertyKey, RmrkResourceTypes,79 RmrkBasicResource, RmrkComposableResource, RmrkSlotResource, RmrkResourceId, RmrkBaseId,80 RmrkFixedPart, RmrkSlotPart, RmrkString,81};8283// use pallet_contracts::weights::WeightInfo;84// #[cfg(any(feature = "std", test))]85use frame_system::{86 self as frame_system, EnsureRoot, EnsureSigned,87 limits::{BlockWeights, BlockLength},88};89use sp_arithmetic::{90 traits::{BaseArithmetic, Unsigned},91};92use smallvec::smallvec;93use codec::{Encode, Decode};94use fp_rpc::TransactionStatus;95use sp_runtime::{96 traits::{97 Applyable, BlockNumberProvider, Dispatchable, PostDispatchInfoOf, DispatchInfoOf,98 Saturating, CheckedConversion,99 },100 generic::Era,101 transaction_validity::TransactionValidityError,102 DispatchErrorWithPostInfo, SaturatedConversion,103};104105// pub use pallet_timestamp::Call as TimestampCall;106pub use sp_consensus_aura::sr25519::AuthorityId as AuraId;107108// Polkadot imports109use pallet_xcm::XcmPassthrough;110use polkadot_parachain::primitives::Sibling;111use xcm::v1::{BodyId, Junction::*, MultiLocation, NetworkId, Junctions::*};112use xcm_builder::{113 AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter,114 EnsureXcmOrigin, FixedWeightBounds, LocationInverter, NativeAsset, ParentAsSuperuser,115 RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia,116 SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,117 ParentIsPreset,118};119use xcm_executor::{Config, XcmExecutor, Assets};120use sp_std::{cmp::Ordering, marker::PhantomData};121122use xcm::latest::{123 // Xcm,124 AssetId::{Concrete},125 Fungibility::Fungible as XcmFungible,126 MultiAsset,127 Error as XcmError,128};129use xcm_executor::traits::{MatchesFungible, WeightTrader};130131use unique_runtime_common::{132 impl_common_runtime_apis,133 types::*,134 constants::*,135 dispatch::{CollectionDispatchT, CollectionDispatch},136 sponsoring::UniqueSponsorshipHandler,137 eth_sponsoring::UniqueEthSponsorshipHandler,138 weights::CommonWeights,139};140141pub const RUNTIME_NAME: &str = "quartz";142pub const TOKEN_SYMBOL: &str = "QTZ";143144type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Runtime>;145146impl RuntimeInstance for Runtime {147 type CrossAccountId = self::CrossAccountId;148149 type TransactionConverter = self::TransactionConverter;150151 fn get_transaction_converter() -> TransactionConverter {152 TransactionConverter153 }154}155156/// The type for looking up accounts. We don't expect more than 4 billion of them, but you157/// never know...158pub type AccountIndex = u32;159160/// Balance of an account.161pub type Balance = u128;162163/// Index of a transaction in the chain.164pub type Index = u32;165166/// A hash of some data used by the chain.167pub type Hash = sp_core::H256;168169/// Digest item type.170pub type DigestItem = generic::DigestItem;171172/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know173/// the specifics of the runtime. They can then be made to be agnostic over specific formats174/// of data like extrinsics, allowing for them to continue syncing the network through upgrades175/// to even the core data structures.176pub mod opaque {177 use sp_std::prelude::*;178 use sp_runtime::impl_opaque_keys;179 use super::Aura;180181 pub use unique_runtime_common::types::*;182183 impl_opaque_keys! {184 pub struct SessionKeys {185 pub aura: Aura,186 }187 }188}189190/// This runtime version.191pub const VERSION: RuntimeVersion = RuntimeVersion {192 spec_name: create_runtime_str!(RUNTIME_NAME),193 impl_name: create_runtime_str!(RUNTIME_NAME),194 authoring_version: 1,195 spec_version: 922000,196 impl_version: 0,197 apis: RUNTIME_API_VERSIONS,198 transaction_version: 1,199 state_version: 0,200};201202#[derive(codec::Encode, codec::Decode)]203pub enum XCMPMessage<XAccountId, XBalance> {204 /// Transfer tokens to the given account from the Parachain account.205 TransferToken(XAccountId, XBalance),206}207208/// The version information used to identify this runtime when compiled natively.209#[cfg(feature = "std")]210pub fn native_version() -> NativeVersion {211 NativeVersion {212 runtime_version: VERSION,213 can_author_with: Default::default(),214 }215}216217type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;218219pub struct DealWithFees;220impl OnUnbalanced<NegativeImbalance> for DealWithFees {221 fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {222 if let Some(fees) = fees_then_tips.next() {223 // for fees, 100% to treasury224 let mut split = fees.ration(100, 0);225 if let Some(tips) = fees_then_tips.next() {226 // for tips, if any, 100% to treasury227 tips.ration_merge_into(100, 0, &mut split);228 }229 Treasury::on_unbalanced(split.0);230 // Author::on_unbalanced(split.1);231 }232 }233}234235parameter_types! {236 pub const BlockHashCount: BlockNumber = 2400;237 pub RuntimeBlockLength: BlockLength =238 BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);239 pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);240 pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;241 pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()242 .base_block(BlockExecutionWeight::get())243 .for_class(DispatchClass::all(), |weights| {244 weights.base_extrinsic = ExtrinsicBaseWeight::get();245 })246 .for_class(DispatchClass::Normal, |weights| {247 weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);248 })249 .for_class(DispatchClass::Operational, |weights| {250 weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);251 // Operational transactions have some extra reserved space, so that they252 // are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.253 weights.reserved = Some(254 MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT255 );256 })257 .avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)258 .build_or_panic();259 pub const Version: RuntimeVersion = VERSION;260 pub const SS58Prefix: u8 = 255;261}262263parameter_types! {264 pub const ChainId: u64 = 8881;265}266267pub struct FixedFee;268impl FeeCalculator for FixedFee {269 fn min_gas_price() -> (U256, u64) {270 (MIN_GAS_PRICE.into(), 0)271 }272}273274// Assuming slowest ethereum opcode is SSTORE, with gas price of 20000 as our worst case275// (contract, which only writes a lot of data),276// approximating on top of our real store write weight277parameter_types! {278 pub const WritesPerSecond: u64 = WEIGHT_PER_SECOND / <Runtime as frame_system::Config>::DbWeight::get().write;279 pub const GasPerSecond: u64 = WritesPerSecond::get() * 20000;280 pub const WeightPerGas: u64 = WEIGHT_PER_SECOND / GasPerSecond::get();281}282283/// Limiting EVM execution to 50% of block for substrate users and management tasks284/// EVM transaction consumes more weight than substrate's, so we can't rely on them being285/// scheduled fairly286const EVM_DISPATCH_RATIO: Perbill = Perbill::from_percent(50);287parameter_types! {288 pub BlockGasLimit: U256 = U256::from(NORMAL_DISPATCH_RATIO * EVM_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT / WeightPerGas::get());289}290291pub enum FixedGasWeightMapping {}292impl GasWeightMapping for FixedGasWeightMapping {293 fn gas_to_weight(gas: u64) -> Weight {294 gas.saturating_mul(WeightPerGas::get())295 }296 fn weight_to_gas(weight: Weight) -> u64 {297 weight / WeightPerGas::get()298 }299}300301impl pallet_evm::account::Config for Runtime {302 type CrossAccountId = pallet_evm::account::BasicCrossAccountId<Self>;303 type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;304 type EvmBackwardsAddressMapping = fp_evm_mapping::MapBackwardsAddressTruncated;305}306307impl pallet_evm::Config for Runtime {308 type BlockGasLimit = BlockGasLimit;309 type FeeCalculator = FixedFee;310 type GasWeightMapping = FixedGasWeightMapping;311 type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping<Self>;312 type CallOrigin = EnsureAddressTruncated<Self>;313 type WithdrawOrigin = EnsureAddressTruncated<Self>;314 type AddressMapping = HashedAddressMapping<Self::Hashing>;315 type PrecompilesType = ();316 type PrecompilesValue = ();317 type Currency = Balances;318 type Event = Event;319 type OnMethodCall = (320 pallet_evm_migration::OnMethodCall<Self>,321 pallet_evm_contract_helpers::HelpersOnMethodCall<Self>,322 CollectionDispatchT<Self>,323 pallet_unique::eth::CollectionHelpersOnMethodCall<Self>,324 );325 type OnCreate = pallet_evm_contract_helpers::HelpersOnCreate<Self>;326 type ChainId = ChainId;327 type Runner = pallet_evm::runner::stack::Runner<Self>;328 type OnChargeTransaction = pallet_evm::EVMCurrencyAdapter<Balances, DealWithFees>;329 type TransactionValidityHack = pallet_evm_transaction_payment::TransactionValidityHack<Self>;330 type FindAuthor = EthereumFindAuthor<Aura>;331}332333impl pallet_evm_migration::Config for Runtime {334 type WeightInfo = pallet_evm_migration::weights::SubstrateWeight<Self>;335}336337pub struct EthereumFindAuthor<F>(core::marker::PhantomData<F>);338impl<F: FindAuthor<u32>> FindAuthor<H160> for EthereumFindAuthor<F> {339 fn find_author<'a, I>(digests: I) -> Option<H160>340 where341 I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,342 {343 if let Some(author_index) = F::find_author(digests) {344 let authority_id = Aura::authorities()[author_index as usize].clone();345 return Some(H160::from_slice(&authority_id.to_raw_vec()[4..24]));346 }347 None348 }349}350351impl pallet_ethereum::Config for Runtime {352 type Event = Event;353 type StateRoot = pallet_ethereum::IntermediateStateRoot<Self>;354}355356impl pallet_randomness_collective_flip::Config for Runtime {}357358impl frame_system::Config for Runtime {359 /// The data to be stored in an account.360 type AccountData = pallet_balances::AccountData<Balance>;361 /// The identifier used to distinguish between accounts.362 type AccountId = AccountId;363 /// The basic call filter to use in dispatchable.364 type BaseCallFilter = Everything;365 /// Maximum number of block number to block hash mappings to keep (oldest pruned first).366 type BlockHashCount = BlockHashCount;367 /// The maximum length of a block (in bytes).368 type BlockLength = RuntimeBlockLength;369 /// The index type for blocks.370 type BlockNumber = BlockNumber;371 /// The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block.372 type BlockWeights = RuntimeBlockWeights;373 /// The aggregated dispatch type that is available for extrinsics.374 type Call = Call;375 /// The weight of database operations that the runtime can invoke.376 type DbWeight = RocksDbWeight;377 /// The ubiquitous event type.378 type Event = Event;379 /// The type for hashing blocks and tries.380 type Hash = Hash;381 /// The hashing algorithm used.382 type Hashing = BlakeTwo256;383 /// The header type.384 type Header = generic::Header<BlockNumber, BlakeTwo256>;385 /// The index type for storing how many extrinsics an account has signed.386 type Index = Index;387 /// The lookup mechanism to get account ID from whatever is passed in dispatchers.388 type Lookup = AccountIdLookup<AccountId, ()>;389 /// What to do if an account is fully reaped from the system.390 type OnKilledAccount = ();391 /// What to do if a new account is created.392 type OnNewAccount = ();393 type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode<Self>;394 /// The ubiquitous origin type.395 type Origin = Origin;396 /// This type is being generated by `construct_runtime!`.397 type PalletInfo = PalletInfo;398 /// This is used as an identifier of the chain. 42 is the generic substrate prefix.399 type SS58Prefix = SS58Prefix;400 /// Weight information for the extrinsics of this pallet.401 type SystemWeightInfo = frame_system::weights::SubstrateWeight<Self>;402 /// Version of the runtime.403 type Version = Version;404 type MaxConsumers = ConstU32<16>;405}406407parameter_types! {408 pub const MinimumPeriod: u64 = SLOT_DURATION / 2;409}410411impl pallet_timestamp::Config for Runtime {412 /// A timestamp: milliseconds since the unix epoch.413 type Moment = u64;414 type OnTimestampSet = ();415 type MinimumPeriod = MinimumPeriod;416 type WeightInfo = ();417}418419parameter_types! {420 // pub const ExistentialDeposit: u128 = 500;421 pub const ExistentialDeposit: u128 = 0;422 pub const MaxLocks: u32 = 50;423 pub const MaxReserves: u32 = 50;424}425426impl pallet_balances::Config for Runtime {427 type MaxLocks = MaxLocks;428 type MaxReserves = MaxReserves;429 type ReserveIdentifier = [u8; 16];430 /// The type for recording an account's balance.431 type Balance = Balance;432 /// The ubiquitous event type.433 type Event = Event;434 type DustRemoval = Treasury;435 type ExistentialDeposit = ExistentialDeposit;436 type AccountStore = System;437 type WeightInfo = pallet_balances::weights::SubstrateWeight<Self>;438}439440pub const fn deposit(items: u32, bytes: u32) -> Balance {441 items as Balance * 15 * CENTIUNIQUE + (bytes as Balance) * 6 * CENTIUNIQUE442}443444/*445parameter_types! {446 pub TombstoneDeposit: Balance = deposit(447 1,448 sp_std::mem::size_of::<pallet_contracts::Pallet<Runtime>> as u32,449 );450 pub DepositPerContract: Balance = TombstoneDeposit::get();451 pub const DepositPerStorageByte: Balance = deposit(0, 1);452 pub const DepositPerStorageItem: Balance = deposit(1, 0);453 pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * DAYS);454 pub const SurchargeReward: Balance = 150 * MILLIUNIQUE;455 pub const SignedClaimHandicap: u32 = 2;456 pub const MaxDepth: u32 = 32;457 pub const MaxValueSize: u32 = 16 * 1024;458 pub const MaxCodeSize: u32 = 1024 * 1024 * 25; // 25 Mb459 // The lazy deletion runs inside on_initialize.460 pub DeletionWeightLimit: Weight = AVERAGE_ON_INITIALIZE_RATIO *461 RuntimeBlockWeights::get().max_block;462 // The weight needed for decoding the queue should be less or equal than a fifth463 // of the overall weight dedicated to the lazy deletion.464 pub DeletionQueueDepth: u32 = ((DeletionWeightLimit::get() / (465 <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(1) -466 <Runtime as pallet_contracts::Config>::WeightInfo::on_initialize_per_queue_item(0)467 )) / 5) as u32;468 pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();469}470471impl pallet_contracts::Config for Runtime {472 type Time = Timestamp;473 type Randomness = RandomnessCollectiveFlip;474 type Currency = Balances;475 type Event = Event;476 type RentPayment = ();477 type SignedClaimHandicap = SignedClaimHandicap;478 type TombstoneDeposit = TombstoneDeposit;479 type DepositPerContract = DepositPerContract;480 type DepositPerStorageByte = DepositPerStorageByte;481 type DepositPerStorageItem = DepositPerStorageItem;482 type RentFraction = RentFraction;483 type SurchargeReward = SurchargeReward;484 type WeightPrice = pallet_transaction_payment::Pallet<Self>;485 type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;486 type ChainExtension = NFTExtension;487 type DeletionQueueDepth = DeletionQueueDepth;488 type DeletionWeightLimit = DeletionWeightLimit;489 type Schedule = Schedule;490 type CallStack = [pallet_contracts::Frame<Self>; 31];491}492*/493494parameter_types! {495 /// This value increases the priority of `Operational` transactions by adding496 /// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.497 pub const OperationalFeeMultiplier: u8 = 5;498}499500/// Linear implementor of `WeightToFeePolynomial`501pub struct LinearFee<T>(sp_std::marker::PhantomData<T>);502503impl<T> WeightToFeePolynomial for LinearFee<T>504where505 T: BaseArithmetic + From<u32> + Copy + Unsigned,506{507 type Balance = T;508509 fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {510 smallvec!(WeightToFeeCoefficient {511 // Targeting 0.1 Unique per NFT transfer512 coeff_integer: WEIGHT_TO_FEE_COEFF.into(),513 coeff_frac: Perbill::zero(),514 negative: false,515 degree: 1,516 })517 }518}519520impl pallet_transaction_payment::Config for Runtime {521 type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, DealWithFees>;522 type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;523 type OperationalFeeMultiplier = OperationalFeeMultiplier;524 type WeightToFee = LinearFee<Balance>;525 type FeeMultiplierUpdate = ();526}527528parameter_types! {529 pub const ProposalBond: Permill = Permill::from_percent(5);530 pub const ProposalBondMinimum: Balance = 1 * UNIQUE;531 pub const ProposalBondMaximum: Balance = 1000 * UNIQUE;532 pub const SpendPeriod: BlockNumber = 5 * MINUTES;533 pub const Burn: Permill = Permill::from_percent(0);534 pub const TipCountdown: BlockNumber = 1 * DAYS;535 pub const TipFindersFee: Percent = Percent::from_percent(20);536 pub const TipReportDepositBase: Balance = 1 * UNIQUE;537 pub const DataDepositPerByte: Balance = 1 * CENTIUNIQUE;538 pub const BountyDepositBase: Balance = 1 * UNIQUE;539 pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;540 pub const TreasuryModuleId: PalletId = PalletId(*b"py/trsry");541 pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;542 pub const MaximumReasonLength: u32 = 16384;543 pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);544 pub const BountyValueMinimum: Balance = 5 * UNIQUE;545 pub const MaxApprovals: u32 = 100;546}547548impl pallet_treasury::Config for Runtime {549 type PalletId = TreasuryModuleId;550 type Currency = Balances;551 type ApproveOrigin = EnsureRoot<AccountId>;552 type RejectOrigin = EnsureRoot<AccountId>;553 type Event = Event;554 type OnSlash = ();555 type ProposalBond = ProposalBond;556 type ProposalBondMinimum = ProposalBondMinimum;557 type ProposalBondMaximum = ProposalBondMaximum;558 type SpendPeriod = SpendPeriod;559 type Burn = Burn;560 type BurnDestination = ();561 type SpendFunds = ();562 type WeightInfo = pallet_treasury::weights::SubstrateWeight<Self>;563 type MaxApprovals = MaxApprovals;564}565566impl pallet_sudo::Config for Runtime {567 type Event = Event;568 type Call = Call;569}570571pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);572573impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider574 for RelayChainBlockNumberProvider<T>575{576 type BlockNumber = BlockNumber;577578 fn current_block_number() -> Self::BlockNumber {579 cumulus_pallet_parachain_system::Pallet::<T>::validation_data()580 .map(|d| d.relay_parent_number)581 .unwrap_or_default()582 }583}584585parameter_types! {586 pub const MinVestedTransfer: Balance = 10 * UNIQUE;587 pub const MaxVestingSchedules: u32 = 28;588}589590impl orml_vesting::Config for Runtime {591 type Event = Event;592 type Currency = pallet_balances::Pallet<Runtime>;593 type MinVestedTransfer = MinVestedTransfer;594 type VestedTransferOrigin = EnsureSigned<AccountId>;595 type WeightInfo = ();596 type MaxVestingSchedules = MaxVestingSchedules;597 type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;598}599600parameter_types! {601 pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;602 pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 4;603}604605impl cumulus_pallet_parachain_system::Config for Runtime {606 type Event = Event;607 type SelfParaId = parachain_info::Pallet<Self>;608 type OnSystemEvent = ();609 // type DownwardMessageHandlers = cumulus_primitives_utility::UnqueuedDmpAsParent<610 // MaxDownwardMessageWeight,611 // XcmExecutor<XcmConfig>,612 // Call,613 // >;614 type OutboundXcmpMessageSource = XcmpQueue;615 type DmpMessageHandler = DmpQueue;616 type ReservedDmpWeight = ReservedDmpWeight;617 type ReservedXcmpWeight = ReservedXcmpWeight;618 type XcmpMessageHandler = XcmpQueue;619}620621impl parachain_info::Config for Runtime {}622623impl cumulus_pallet_aura_ext::Config for Runtime {}624625parameter_types! {626 pub const RelayLocation: MultiLocation = MultiLocation::parent();627 pub const RelayNetwork: NetworkId = NetworkId::Polkadot;628 pub RelayOrigin: Origin = cumulus_pallet_xcm::Origin::Relay.into();629 pub Ancestry: MultiLocation = Parachain(ParachainInfo::parachain_id().into()).into();630}631632/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used633/// when determining ownership of accounts for asset transacting and when attempting to use XCM634/// `Transact` in order to determine the dispatch Origin.635pub type LocationToAccountId = (636 // The parent (Relay-chain) origin converts to the default `AccountId`.637 ParentIsPreset<AccountId>,638 // Sibling parachain origins convert to AccountId via the `ParaId::into`.639 SiblingParachainConvertsVia<Sibling, AccountId>,640 // Straight up local `AccountId32` origins just alias directly to `AccountId`.641 AccountId32Aliases<RelayNetwork, AccountId>,642);643644pub struct OnlySelfCurrency;645impl<B: TryFrom<u128>> MatchesFungible<B> for OnlySelfCurrency {646 fn matches_fungible(a: &MultiAsset) -> Option<B> {647 match (&a.id, &a.fun) {648 (Concrete(_), XcmFungible(ref amount)) => CheckedConversion::checked_from(*amount),649 _ => None,650 }651 }652}653654/// Means for transacting assets on this chain.655pub type LocalAssetTransactor = CurrencyAdapter<656 // Use this currency:657 Balances,658 // Use this currency when it is a fungible asset matching the given location or name:659 OnlySelfCurrency,660 // Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID:661 LocationToAccountId,662 // Our chain's account ID type (we can't get away without mentioning it explicitly):663 AccountId,664 // We don't track any teleports.665 (),666>;667668/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,669/// ready for dispatching a transaction with Xcm's `Transact`. There is an `OriginKind` which can670/// biases the kind of local `Origin` it will become.671pub type XcmOriginToTransactDispatchOrigin = (672 // Sovereign account converter; this attempts to derive an `AccountId` from the origin location673 // using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for674 // foreign chains who want to have a local sovereign account on this chain which they control.675 SovereignSignedViaLocation<LocationToAccountId, Origin>,676 // Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when677 // recognised.678 RelayChainAsNative<RelayOrigin, Origin>,679 // Native converter for sibling Parachains; will convert to a `SiblingPara` origin when680 // recognised.681 SiblingParachainAsNative<cumulus_pallet_xcm::Origin, Origin>,682 // Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a683 // transaction from the Root origin.684 ParentAsSuperuser<Origin>,685 // Native signed account converter; this just converts an `AccountId32` origin into a normal686 // `Origin::Signed` origin of the same 32-byte value.687 SignedAccountId32AsNative<RelayNetwork, Origin>,688 // Xcm origins can be represented natively under the Xcm pallet's Xcm origin.689 XcmPassthrough<Origin>,690);691692parameter_types! {693 // One XCM operation is 1_000_000 weight - almost certainly a conservative estimate.694 pub UnitWeightCost: Weight = 1_000_000;695 // 1200 UNIQUEs buy 1 second of weight.696 pub const WeightPrice: (MultiLocation, u128) = (MultiLocation::parent(), 1_200 * UNIQUE);697 pub const MaxInstructions: u32 = 100;698 pub const MaxAuthorities: u32 = 100_000;699}700701match_types! {702 pub type ParentOrParentsUnitPlurality: impl Contains<MultiLocation> = {703 MultiLocation { parents: 1, interior: Here } |704 MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Unit, .. }) }705 };706}707708pub type Barrier = (709 TakeWeightCredit,710 AllowTopLevelPaidExecutionFrom<Everything>,711 AllowUnpaidExecutionFrom<ParentOrParentsUnitPlurality>,712 // ^^^ Parent & its unit plurality gets free execution713);714715pub struct UsingOnlySelfCurrencyComponents<716 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,717 AssetId: Get<MultiLocation>,718 AccountId,719 Currency: CurrencyT<AccountId>,720 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,721>(722 Weight,723 Currency::Balance,724 PhantomData<(WeightToFee, AssetId, AccountId, Currency, OnUnbalanced)>,725);726impl<727 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,728 AssetId: Get<MultiLocation>,729 AccountId,730 Currency: CurrencyT<AccountId>,731 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,732 > WeightTrader733 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>734{735 fn new() -> Self {736 Self(0, Zero::zero(), PhantomData)737 }738739 fn buy_weight(&mut self, weight: Weight, payment: Assets) -> Result<Assets, XcmError> {740 let amount = WeightToFee::calc(&weight);741 let u128_amount: u128 = amount.try_into().map_err(|_| XcmError::Overflow)?;742743 // location to this parachain through relay chain744 let option1: xcm::v1::AssetId = Concrete(MultiLocation {745 parents: 1,746 interior: X1(Parachain(ParachainInfo::parachain_id().into())),747 });748 // direct location749 let option2: xcm::v1::AssetId = Concrete(MultiLocation {750 parents: 0,751 interior: Here,752 });753754 let required = if payment.fungible.contains_key(&option1) {755 (option1, u128_amount).into()756 } else if payment.fungible.contains_key(&option2) {757 (option2, u128_amount).into()758 } else {759 (Concrete(MultiLocation::default()), u128_amount).into()760 };761762 let unused = payment763 .checked_sub(required)764 .map_err(|_| XcmError::TooExpensive)?;765 self.0 = self.0.saturating_add(weight);766 self.1 = self.1.saturating_add(amount);767 Ok(unused)768 }769770 fn refund_weight(&mut self, weight: Weight) -> Option<MultiAsset> {771 let weight = weight.min(self.0);772 let amount = WeightToFee::calc(&weight);773 self.0 -= weight;774 self.1 = self.1.saturating_sub(amount);775 let amount: u128 = amount.saturated_into();776 if amount > 0 {777 Some((AssetId::get(), amount).into())778 } else {779 None780 }781 }782}783impl<784 WeightToFee: WeightToFeePolynomial<Balance = Currency::Balance>,785 AssetId: Get<MultiLocation>,786 AccountId,787 Currency: CurrencyT<AccountId>,788 OnUnbalanced: OnUnbalancedT<Currency::NegativeImbalance>,789 > Drop790 for UsingOnlySelfCurrencyComponents<WeightToFee, AssetId, AccountId, Currency, OnUnbalanced>791{792 fn drop(&mut self) {793 OnUnbalanced::on_unbalanced(Currency::issue(self.1));794 }795}796797pub struct XcmConfig;798impl Config for XcmConfig {799 type Call = Call;800 type XcmSender = XcmRouter;801 // How to withdraw and deposit an asset.802 type AssetTransactor = LocalAssetTransactor;803 type OriginConverter = XcmOriginToTransactDispatchOrigin;804 type IsReserve = NativeAsset;805 type IsTeleporter = (); // Teleportation is disabled806 type LocationInverter = LocationInverter<Ancestry>;807 type Barrier = Barrier;808 type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;809 type Trader = UsingOnlySelfCurrencyComponents<810 IdentityFee<Balance>,811 RelayLocation,812 AccountId,813 Balances,814 (),815 >;816 type ResponseHandler = (); // Don't handle responses for now.817 type SubscriptionService = PolkadotXcm;818819 type AssetTrap = PolkadotXcm;820 type AssetClaims = PolkadotXcm;821}822823// parameter_types! {824// pub const MaxDownwardMessageWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;825// }826827/// No local origins on this chain are allowed to dispatch XCM sends/executions.828pub type LocalOriginToLocation = (SignedToAccountId32<Origin, AccountId, RelayNetwork>,);829830/// The means for routing XCM messages which are not for local execution into the right message831/// queues.832pub type XcmRouter = (833 // Two routers - use UMP to communicate with the relay chain:834 cumulus_primitives_utility::ParentAsUmp<ParachainSystem, ()>,835 // ..and XCMP to communicate with the sibling chains.836 XcmpQueue,837);838839impl pallet_evm_coder_substrate::Config for Runtime {}840841impl pallet_xcm::Config for Runtime {842 type Event = Event;843 type SendXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;844 type XcmRouter = XcmRouter;845 type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, LocalOriginToLocation>;846 type XcmExecuteFilter = Everything;847 type XcmExecutor = XcmExecutor<XcmConfig>;848 type XcmTeleportFilter = Everything;849 type XcmReserveTransferFilter = Everything;850 type Weigher = FixedWeightBounds<UnitWeightCost, Call, MaxInstructions>;851 type LocationInverter = LocationInverter<Ancestry>;852 type Origin = Origin;853 type Call = Call;854 const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;855 type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion;856}857858impl cumulus_pallet_xcm::Config for Runtime {859 type Event = Event;860 type XcmExecutor = XcmExecutor<XcmConfig>;861}862863impl cumulus_pallet_xcmp_queue::Config for Runtime {864 type WeightInfo = ();865 type Event = Event;866 type XcmExecutor = XcmExecutor<XcmConfig>;867 type ChannelInfo = ParachainSystem;868 type VersionWrapper = ();869 type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;870 type ControllerOrigin = EnsureRoot<AccountId>;871 type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin;872}873874impl cumulus_pallet_dmp_queue::Config for Runtime {875 type Event = Event;876 type XcmExecutor = XcmExecutor<XcmConfig>;877 type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;878}879880impl pallet_aura::Config for Runtime {881 type AuthorityId = AuraId;882 type DisabledValidators = ();883 type MaxAuthorities = MaxAuthorities;884}885886parameter_types! {887 pub TreasuryAccountId: AccountId = TreasuryModuleId::get().into_account();888 pub const CollectionCreationPrice: Balance = 2 * UNIQUE;889}890891impl pallet_common::Config for Runtime {892 type WeightInfo = pallet_common::weights::SubstrateWeight<Self>;893 type Event = Event;894 type Currency = Balances;895 type CollectionCreationPrice = CollectionCreationPrice;896 type TreasuryAccountId = TreasuryAccountId;897 type CollectionDispatch = CollectionDispatchT<Self>;898899 type EvmTokenAddressMapping = EvmTokenAddressMapping;900 type CrossTokenAddressMapping = CrossTokenAddressMapping<Self::AccountId>;901 type ContractAddress = EvmCollectionHelpersAddress;902}903904impl pallet_structure::Config for Runtime {905 type Event = Event;906 type Call = Call;907 type WeightInfo = pallet_structure::weights::SubstrateWeight<Self>;908}909910impl pallet_fungible::Config for Runtime {911 type WeightInfo = pallet_fungible::weights::SubstrateWeight<Self>;912}913impl pallet_refungible::Config for Runtime {914 type WeightInfo = pallet_refungible::weights::SubstrateWeight<Self>;915}916impl pallet_nonfungible::Config for Runtime {917 type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;918}919920impl pallet_proxy_rmrk_core::Config for Runtime {921 type WeightInfo = pallet_proxy_rmrk_core::weights::SubstrateWeight<Self>;922 type Event = Event;923}924925impl pallet_proxy_rmrk_equip::Config for Runtime {926 type Event = Event;927}928929impl pallet_unique::Config for Runtime {930 type Event = Event;931 type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;932 type CommonWeightInfo = CommonWeights<Self>;933}934935parameter_types! {936 pub const InflationBlockInterval: BlockNumber = 100; // every time per how many blocks inflation is applied937}938939/// Used for the pallet inflation940impl pallet_inflation::Config for Runtime {941 type Currency = Balances;942 type TreasuryAccountId = TreasuryAccountId;943 type InflationBlockInterval = InflationBlockInterval;944 type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;945}946947parameter_types! {948 pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) *949 RuntimeBlockWeights::get().max_block;950 pub const MaxScheduledPerBlock: u32 = 50;951}952953type ChargeTransactionPayment = pallet_charge_transaction::ChargeTransactionPayment<Runtime>;954use frame_support::traits::NamedReservableCurrency;955956fn get_signed_extras(from: <Runtime as frame_system::Config>::AccountId) -> SignedExtraScheduler {957 (958 frame_system::CheckSpecVersion::<Runtime>::new(),959 frame_system::CheckGenesis::<Runtime>::new(),960 frame_system::CheckEra::<Runtime>::from(Era::Immortal),961 frame_system::CheckNonce::<Runtime>::from(frame_system::Pallet::<Runtime>::account_nonce(962 from,963 )),964 frame_system::CheckWeight::<Runtime>::new(),965 // sponsoring transaction logic966 // pallet_charge_transaction::ChargeTransactionPayment::<Runtime>::new(0),967 )968}969970pub struct SchedulerPaymentExecutor;971impl<T: frame_system::Config + pallet_unique_scheduler::Config, SelfContainedSignedInfo>972 DispatchCall<T, SelfContainedSignedInfo> for SchedulerPaymentExecutor973where974 <T as frame_system::Config>::Call: Member975 + Dispatchable<Origin = Origin, Info = DispatchInfo>976 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>977 + GetDispatchInfo978 + From<frame_system::Call<Runtime>>,979 SelfContainedSignedInfo: Send + Sync + 'static,980 Call: From<<T as frame_system::Config>::Call>981 + From<<T as pallet_unique_scheduler::Config>::Call>982 + SelfContainedCall<SignedInfo = SelfContainedSignedInfo>,983 sp_runtime::AccountId32: From<<T as frame_system::Config>::AccountId>,984{985 fn dispatch_call(986 signer: <T as frame_system::Config>::AccountId,987 call: <T as pallet_unique_scheduler::Config>::Call,988 ) -> Result<989 Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>,990 TransactionValidityError,991 > {992 let dispatch_info = call.get_dispatch_info();993 let extrinsic = fp_self_contained::CheckedExtrinsic::<994 AccountId,995 Call,996 SignedExtraScheduler,997 SelfContainedSignedInfo,998 > {999 signed:1000 CheckedSignature::<AccountId, SignedExtraScheduler, SelfContainedSignedInfo>::Signed(1001 signer.clone().into(),1002 get_signed_extras(signer.into()),1003 ),1004 function: call.into(),1005 };10061007 extrinsic.apply::<Runtime>(&dispatch_info, 0)1008 }10091010 fn reserve_balance(1011 id: [u8; 16],1012 sponsor: <T as frame_system::Config>::AccountId,1013 call: <T as pallet_unique_scheduler::Config>::Call,1014 count: u32,1015 ) -> Result<(), DispatchError> {1016 let dispatch_info = call.get_dispatch_info();1017 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0)1018 .saturating_mul(count.into());10191020 <Balances as NamedReservableCurrency<AccountId>>::reserve_named(1021 &id,1022 &(sponsor.into()),1023 weight.into(),1024 )1025 }10261027 fn pay_for_call(1028 id: [u8; 16],1029 sponsor: <T as frame_system::Config>::AccountId,1030 call: <T as pallet_unique_scheduler::Config>::Call,1031 ) -> Result<u128, DispatchError> {1032 let dispatch_info = call.get_dispatch_info();1033 let weight: Balance = ChargeTransactionPayment::traditional_fee(0, &dispatch_info, 0);1034 Ok(1035 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1036 &id,1037 &(sponsor.into()),1038 weight.into(),1039 ),1040 )1041 }10421043 fn cancel_reserve(1044 id: [u8; 16],1045 sponsor: <T as frame_system::Config>::AccountId,1046 ) -> Result<u128, DispatchError> {1047 Ok(1048 <Balances as NamedReservableCurrency<AccountId>>::unreserve_named(1049 &id,1050 &(sponsor.into()),1051 u128::MAX,1052 ),1053 )1054 }1055}10561057parameter_types! {1058 pub const NoPreimagePostponement: Option<u32> = Some(10);1059 pub const Preimage: Option<u32> = Some(10);1060}10611062/// Used the compare the privilege of an origin inside the scheduler.1063pub struct OriginPrivilegeCmp;10641065impl PrivilegeCmp<OriginCaller> for OriginPrivilegeCmp {1066 fn cmp_privilege(_left: &OriginCaller, _right: &OriginCaller) -> Option<Ordering> {1067 Some(Ordering::Equal)1068 }1069}10701071impl pallet_unique_scheduler::Config for Runtime {1072 type Event = Event;1073 type Origin = Origin;1074 type Currency = Balances;1075 type PalletsOrigin = OriginCaller;1076 type Call = Call;1077 type MaximumWeight = MaximumSchedulerWeight;1078 type ScheduleOrigin = EnsureSigned<AccountId>;1079 type MaxScheduledPerBlock = MaxScheduledPerBlock;1080 type WeightInfo = ();1081 type CallExecutor = SchedulerPaymentExecutor;1082 type OriginPrivilegeCmp = OriginPrivilegeCmp;1083 type PreimageProvider = ();1084 type NoPreimagePostponement = NoPreimagePostponement;1085}10861087type EvmSponsorshipHandler = (1088 UniqueEthSponsorshipHandler<Runtime>,1089 pallet_evm_contract_helpers::HelpersContractSponsoring<Runtime>,1090);1091type SponsorshipHandler = (1092 UniqueSponsorshipHandler<Runtime>,1093 //pallet_contract_helpers::ContractSponsorshipHandler<Runtime>,1094 pallet_evm_transaction_payment::BridgeSponsorshipHandler<Runtime>,1095);10961097impl pallet_evm_transaction_payment::Config for Runtime {1098 type EvmSponsorshipHandler = EvmSponsorshipHandler;1099 type Currency = Balances;1100}11011102impl pallet_charge_transaction::Config for Runtime {1103 type SponsorshipHandler = SponsorshipHandler;1104}11051106// impl pallet_contract_helpers::Config for Runtime {1107// type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1108// }11091110parameter_types! {1111 // 0x842899ECF380553E8a4de75bF534cdf6fBF640491112 pub const HelpersContractAddress: H160 = H160([1113 0x84, 0x28, 0x99, 0xec, 0xf3, 0x80, 0x55, 0x3e, 0x8a, 0x4d, 0xe7, 0x5b, 0xf5, 0x34, 0xcd, 0xf6, 0xfb, 0xf6, 0x40, 0x49,1114 ]);11151116 // 0x6c4e9fe1ae37a41e93cee429e8e1881abdcbb54f1117 pub const EvmCollectionHelpersAddress: H160 = H160([1118 0x6c, 0x4e, 0x9f, 0xe1, 0xae, 0x37, 0xa4, 0x1e, 0x93, 0xce, 0xe4, 0x29, 0xe8, 0xe1, 0x88, 0x1a, 0xbd, 0xcb, 0xb5, 0x4f,1119 ]);1120}11211122impl pallet_evm_contract_helpers::Config for Runtime {1123 type ContractAddress = HelpersContractAddress;1124 type DefaultSponsoringRateLimit = DefaultSponsoringRateLimit;1125}11261127construct_runtime!(1128 pub enum Runtime where1129 Block = Block,1130 NodeBlock = opaque::Block,1131 UncheckedExtrinsic = UncheckedExtrinsic1132 {1133 ParachainSystem: cumulus_pallet_parachain_system::{Pallet, Call, Config, Storage, Inherent, Event<T>, ValidateUnsigned} = 20,1134 ParachainInfo: parachain_info::{Pallet, Storage, Config} = 21,11351136 Aura: pallet_aura::{Pallet, Config<T>} = 22,1137 AuraExt: cumulus_pallet_aura_ext::{Pallet, Config} = 23,11381139 Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>} = 30,1140 RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Pallet, Storage} = 31,1141 Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent} = 32,1142 TransactionPayment: pallet_transaction_payment::{Pallet, Storage} = 33,1143 Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,1144 Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,1145 System: frame_system::{Pallet, Call, Storage, Config, Event<T>} = 36,1146 Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,1147 // Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,1148 // Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,11491150 // XCM helpers.1151 XcmpQueue: cumulus_pallet_xcmp_queue::{Pallet, Call, Storage, Event<T>} = 50,1152 PolkadotXcm: pallet_xcm::{Pallet, Call, Event<T>, Origin} = 51,1153 CumulusXcm: cumulus_pallet_xcm::{Pallet, Call, Event<T>, Origin} = 52,1154 DmpQueue: cumulus_pallet_dmp_queue::{Pallet, Call, Storage, Event<T>} = 53,11551156 // Unique Pallets1157 Inflation: pallet_inflation::{Pallet, Call, Storage} = 60,1158 Unique: pallet_unique::{Pallet, Call, Storage, Event<T>} = 61,1159 Scheduler: pallet_unique_scheduler::{Pallet, Call, Storage, Event<T>} = 62,1160 // free = 631161 Charging: pallet_charge_transaction::{Pallet, Call, Storage } = 64,1162 // ContractHelpers: pallet_contract_helpers::{Pallet, Call, Storage} = 65,1163 Common: pallet_common::{Pallet, Storage, Event<T>} = 66,1164 Fungible: pallet_fungible::{Pallet, Storage} = 67,1165 Refungible: pallet_refungible::{Pallet, Storage} = 68,1166 Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,1167 Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,1168 RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,1169 RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,11701171 // Frontier1172 EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,1173 Ethereum: pallet_ethereum::{Pallet, Config, Call, Storage, Event, Origin} = 101,11741175 EvmCoderSubstrate: pallet_evm_coder_substrate::{Pallet, Storage} = 150,1176 EvmContractHelpers: pallet_evm_contract_helpers::{Pallet, Storage} = 151,1177 EvmTransactionPayment: pallet_evm_transaction_payment::{Pallet} = 152,1178 EvmMigration: pallet_evm_migration::{Pallet, Call, Storage} = 153,1179 }1180);11811182pub struct TransactionConverter;11831184impl fp_rpc::ConvertTransaction<UncheckedExtrinsic> for TransactionConverter {1185 fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic {1186 UncheckedExtrinsic::new_unsigned(1187 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1188 )1189 }1190}11911192impl fp_rpc::ConvertTransaction<opaque::UncheckedExtrinsic> for TransactionConverter {1193 fn convert_transaction(1194 &self,1195 transaction: pallet_ethereum::Transaction,1196 ) -> opaque::UncheckedExtrinsic {1197 let extrinsic = UncheckedExtrinsic::new_unsigned(1198 pallet_ethereum::Call::<Runtime>::transact { transaction }.into(),1199 );1200 let encoded = extrinsic.encode();1201 opaque::UncheckedExtrinsic::decode(&mut &encoded[..])1202 .expect("Encoded extrinsic is always valid")1203 }1204}12051206/// The address format for describing accounts.1207pub type Address = sp_runtime::MultiAddress<AccountId, ()>;1208/// Block header type as expected by this runtime.1209pub type Header = generic::Header<BlockNumber, BlakeTwo256>;1210/// Block type as expected by this runtime.1211pub type Block = generic::Block<Header, UncheckedExtrinsic>;1212/// A Block signed with a Justification1213pub type SignedBlock = generic::SignedBlock<Block>;1214/// BlockId type as expected by this runtime.1215pub type BlockId = generic::BlockId<Block>;1216/// The SignedExtension to the basic transaction logic.1217pub type SignedExtra = (1218 frame_system::CheckSpecVersion<Runtime>,1219 // system::CheckTxVersion<Runtime>,1220 frame_system::CheckGenesis<Runtime>,1221 frame_system::CheckEra<Runtime>,1222 frame_system::CheckNonce<Runtime>,1223 frame_system::CheckWeight<Runtime>,1224 ChargeTransactionPayment,1225 //pallet_contract_helpers::ContractHelpersExtension<Runtime>,1226 pallet_ethereum::FakeTransactionFinalizer<Runtime>,1227);12281229pub type SignedExtraScheduler = (1230 frame_system::CheckSpecVersion<Runtime>,1231 frame_system::CheckGenesis<Runtime>,1232 frame_system::CheckEra<Runtime>,1233 frame_system::CheckNonce<Runtime>,1234 frame_system::CheckWeight<Runtime>,1235 // pallet_charge_transaction::ChargeTransactionPayment<Runtime>,1236);1237/// Unchecked extrinsic type as expected by this runtime.1238pub type UncheckedExtrinsic =1239 fp_self_contained::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;1240/// Extrinsic type that has already been checked.1241pub type CheckedExtrinsic = fp_self_contained::CheckedExtrinsic<AccountId, Call, SignedExtra, H160>;1242/// Executive: handles dispatch to the various modules.1243pub type Executive = frame_executive::Executive<1244 Runtime,1245 Block,1246 frame_system::ChainContext<Runtime>,1247 Runtime,1248 AllPalletsReversedWithSystemFirst,1249>;12501251impl_opaque_keys! {1252 pub struct SessionKeys {1253 pub aura: Aura,1254 }1255}12561257impl fp_self_contained::SelfContainedCall for Call {1258 type SignedInfo = H160;12591260 fn is_self_contained(&self) -> bool {1261 match self {1262 Call::Ethereum(call) => call.is_self_contained(),1263 _ => false,1264 }1265 }12661267 fn check_self_contained(&self) -> Option<Result<Self::SignedInfo, TransactionValidityError>> {1268 match self {1269 Call::Ethereum(call) => call.check_self_contained(),1270 _ => None,1271 }1272 }12731274 fn validate_self_contained(1275 &self,1276 info: &Self::SignedInfo,1277 dispatch_info: &DispatchInfoOf<Call>,1278 len: usize,1279 ) -> Option<TransactionValidity> {1280 match self {1281 Call::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),1282 _ => None,1283 }1284 }12851286 fn pre_dispatch_self_contained(1287 &self,1288 info: &Self::SignedInfo,1289 ) -> Option<Result<(), TransactionValidityError>> {1290 match self {1291 Call::Ethereum(call) => call.pre_dispatch_self_contained(info),1292 _ => None,1293 }1294 }12951296 fn apply_self_contained(1297 self,1298 info: Self::SignedInfo,1299 ) -> Option<sp_runtime::DispatchResultWithInfo<PostDispatchInfoOf<Self>>> {1300 match self {1301 call @ Call::Ethereum(pallet_ethereum::Call::transact { .. }) => Some(call.dispatch(1302 Origin::from(pallet_ethereum::RawOrigin::EthereumTransaction(info)),1303 )),1304 _ => None,1305 }1306 }1307}13081309macro_rules! dispatch_unique_runtime {1310 ($collection:ident.$method:ident($($name:ident),*)) => {{1311 let collection = <Runtime as pallet_common::Config>::CollectionDispatch::dispatch(<pallet_common::CollectionHandle<Runtime>>::try_get($collection)?);1312 let dispatch = collection.as_dyn();13131314 Ok::<_, DispatchError>(dispatch.$method($($name),*))1315 }};1316}13171318impl_common_runtime_apis!();13191320struct CheckInherents;13211322impl cumulus_pallet_parachain_system::CheckInherents<Block> for CheckInherents {1323 fn check_inherents(1324 block: &Block,1325 relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof,1326 ) -> sp_inherents::CheckInherentsResult {1327 let relay_chain_slot = relay_state_proof1328 .read_slot()1329 .expect("Could not read the relay chain slot from the proof");13301331 let inherent_data =1332 cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration(1333 relay_chain_slot,1334 sp_std::time::Duration::from_secs(6),1335 )1336 .create_inherent_data()1337 .expect("Could not create the timestamp inherent data");13381339 inherent_data.check_extrinsics(block)1340 }1341}13421343cumulus_pallet_parachain_system::register_validate_block!(1344 Runtime = Runtime,1345 BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::<Runtime, Executive>,1346 CheckInherents = CheckInherents,1347);runtime/unique/src/lib.rsdiffbeforeafterboth--- a/runtime/unique/src/lib.rs
+++ b/runtime/unique/src/lib.rs
@@ -74,10 +74,9 @@
CollectionStats, RpcCollection,
mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping},
TokenChild, RmrkCollectionInfo, RmrkInstanceInfo, RmrkResourceInfo, RmrkPropertyInfo,
- RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkThemeProperty, RmrkCollectionId,
- RmrkNftId, RmrkAccountIdOrCollectionNftTuple, RmrkNftChild, RmrkPropertyKey, RmrkResourceTypes,
- RmrkBasicResource, RmrkComposableResource, RmrkSlotResource, RmrkResourceId, RmrkBaseId,
- RmrkFixedPart, RmrkSlotPart, RmrkString,
+ RmrkBaseInfo, RmrkPartType, RmrkTheme, RmrkThemeName, RmrkCollectionId,
+ RmrkNftId, RmrkNftChild, RmrkPropertyKey,
+ RmrkResourceId, RmrkBaseId,
};
// use pallet_contracts::weights::WeightInfo;
@@ -914,15 +913,6 @@
}
impl pallet_nonfungible::Config for Runtime {
type WeightInfo = pallet_nonfungible::weights::SubstrateWeight<Self>;
-}
-
-impl pallet_proxy_rmrk_core::Config for Runtime {
- type WeightInfo = pallet_proxy_rmrk_core::weights::SubstrateWeight<Self>;
- type Event = Event;
-}
-
-impl pallet_proxy_rmrk_equip::Config for Runtime {
- type Event = Event;
}
impl pallet_unique::Config for Runtime {
@@ -1164,8 +1154,6 @@
Refungible: pallet_refungible::{Pallet, Storage} = 68,
Nonfungible: pallet_nonfungible::{Pallet, Storage} = 69,
Structure: pallet_structure::{Pallet, Call, Storage, Event<T>} = 70,
- RmrkCore: pallet_proxy_rmrk_core::{Pallet, Call, Storage, Event<T>} = 71,
- RmrkEquip: pallet_proxy_rmrk_equip::{Pallet, Call, Storage, Event<T>} = 72,
// Frontier
EVM: pallet_evm::{Pallet, Config, Call, Storage, Event<T>} = 100,
@@ -1313,7 +1301,73 @@
}};
}
-impl_common_runtime_apis!();
+impl_common_runtime_apis! {
+ #![custom_apis]
+
+ impl rmrk_rpc::RmrkApi<
+ Block,
+ AccountId,
+ RmrkCollectionInfo<AccountId>,
+ RmrkInstanceInfo<AccountId>,
+ RmrkResourceInfo,
+ RmrkPropertyInfo,
+ RmrkBaseInfo<AccountId>,
+ RmrkPartType,
+ RmrkTheme
+ > for Runtime {
+ fn last_collection_idx() -> Result<RmrkCollectionId, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn collection_by_id(_collection_id: RmrkCollectionId) -> Result<Option<RmrkCollectionInfo<AccountId>>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn nft_by_id(_collection_id: RmrkCollectionId, _nft_by_id: RmrkNftId) -> Result<Option<RmrkInstanceInfo<AccountId>>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn account_tokens(_account_id: AccountId, _collection_id: RmrkCollectionId) -> Result<Vec<RmrkNftId>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn nft_children(_collection_id: RmrkCollectionId, _nft_id: RmrkNftId) -> Result<Vec<RmrkNftChild>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn collection_properties(_collection_id: RmrkCollectionId, _filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn nft_properties(_collection_id: RmrkCollectionId, _nft_id: RmrkNftId, _filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Vec<RmrkPropertyInfo>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn nft_resources(_collection_id: RmrkCollectionId, _nft_id: RmrkNftId) -> Result<Vec<RmrkResourceInfo>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn nft_resource_priority(_collection_id: RmrkCollectionId, _nft_id: RmrkNftId, _resource_id: RmrkResourceId) -> Result<Option<u32>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn base(_base_id: RmrkBaseId) -> Result<Option<RmrkBaseInfo<AccountId>>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn base_parts(_base_id: RmrkBaseId) -> Result<Vec<RmrkPartType>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn theme_names(_base_id: RmrkBaseId) -> Result<Vec<RmrkThemeName>, DispatchError> {
+ Ok(Default::default())
+ }
+
+ fn theme(_base_id: RmrkBaseId, _theme_name: RmrkThemeName, _filter_keys: Option<Vec<RmrkPropertyKey>>) -> Result<Option<RmrkTheme>, DispatchError> {
+ Ok(Default::default())
+ }
+ }
+}
struct CheckInherents;
tests/src/eth/nesting/nest.test.tsdiffbeforeafterboth--- a/tests/src/eth/nesting/nest.test.ts
+++ b/tests/src/eth/nesting/nest.test.ts
@@ -29,34 +29,37 @@
const {collectionId, contract} = await createNestingCollection(api, web3, owner);
// Create a token to be nested
- const nftTokenId = await contract.methods.nextTokenId().call();
+ const targetNFTTokenId = await contract.methods.nextTokenId().call();
await contract.methods.mint(
owner,
- nftTokenId,
+ targetNFTTokenId,
).send({from: owner});
- // Nest into a token
- const firstTargetNftTokenId = await contract.methods.nextTokenId().call();
+ const targetNftTokenAddress = tokenIdToAddress(collectionId, targetNFTTokenId);
+
+ // Create a nested token
+ const firstTokenId = await contract.methods.nextTokenId().call();
await contract.methods.mint(
- owner,
- firstTargetNftTokenId,
+ targetNftTokenAddress,
+ firstTokenId,
).send({from: owner});
-
- const targetNftTokenAddress = tokenIdToAddress(collectionId, firstTargetNftTokenId);
- await contract.methods.transfer(targetNftTokenAddress, nftTokenId).send({from: owner});
- expect(await contract.methods.ownerOf(nftTokenId).call()).to.be.equal(targetNftTokenAddress);
+ expect(await contract.methods.ownerOf(firstTokenId).call()).to.be.equal(targetNftTokenAddress);
- // Re-nest into another
- const secondTargetNftTokenId = await contract.methods.nextTokenId().call();
+ // Create a token to be nested and nest
+ const secondTokenId = await contract.methods.nextTokenId().call();
await contract.methods.mint(
owner,
- secondTargetNftTokenId,
+ secondTokenId,
).send({from: owner});
- const nextNftTokenAddress = tokenIdToAddress(collectionId, secondTargetNftTokenId);
- await contract.methods.transfer(nextNftTokenAddress, nftTokenId).send({from: owner});
- expect(await contract.methods.ownerOf(nftTokenId).call()).to.be.equal(nextNftTokenAddress);
+ await contract.methods.transfer(targetNftTokenAddress, secondTokenId).send({from: owner});
+
+ expect(await contract.methods.ownerOf(secondTokenId).call()).to.be.equal(targetNftTokenAddress);
+
+ // Unnest token back
+ await contract.methods.transferFrom(targetNftTokenAddress, owner, secondTokenId).send({from: owner});
+ expect(await contract.methods.ownerOf(secondTokenId).call()).to.be.equal(owner);
});
itWeb3('NFT: allows an Owner to nest/unnest their token (Restricted nesting)', async ({api, web3, privateKeyWrapper}) => {
@@ -125,7 +128,7 @@
.transfer(targetNftTokenAddress, nftTokenId)
.call({from: owner})).to.be.rejectedWith('UserIsNotAllowedToNest');
});
-
+
itWeb3('NFT: disallows a non-Owner to nest someone else\'s token', async ({api, web3, privateKeyWrapper}) => {
const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
const malignant = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
@@ -139,20 +142,20 @@
targetTokenId,
).send({from: owner});
const targetTokenAddress = tokenIdToAddress(collectionId, targetTokenId);
-
+
// Mint a token belonging to a different account
const tokenId = await contract.methods.nextTokenId().call();
await contract.methods.mint(
malignant,
tokenId,
).send({from: owner});
-
+
// Try to nest one token in another as a non-owner account
await expect(contract.methods
.transfer(targetTokenAddress, tokenId)
.call({from: malignant})).to.be.rejectedWith('UserIsNotAllowedToNest');
});
-
+
itWeb3('NFT: disallows a non-Owner to nest someone else\'s token (Restricted nesting)', async ({api, web3, privateKeyWrapper}) => {
const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
const malignant = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
@@ -182,7 +185,7 @@
.transfer(nftTokenAddressA, nftTokenIdB)
.call({from: malignant})).to.be.rejectedWith('UserIsNotAllowedToNest');
});
-
+
itWeb3('NFT: disallows to nest token in an unlisted collection', async ({api, web3, privateKeyWrapper}) => {
const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
tests/src/nesting/nest.test.tsdiffbeforeafterboth--- a/tests/src/nesting/nest.test.ts
+++ b/tests/src/nesting/nest.test.ts
@@ -454,6 +454,7 @@
it('Admin (NFT): disallows an Admin to nest and unnest someone else\'s token', async () => {
await usingApi(async api => {
const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
+ await setCollectionLimitsExpectSuccess(alice, collection, {ownerCanTransfer: true});
await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {collectionAdmin: true}});
await addToAllowListExpectSuccess(alice, collection, bob.address);
tests/src/pallet-presence.test.tsdiffbeforeafterboth--- a/tests/src/pallet-presence.test.ts
+++ b/tests/src/pallet-presence.test.ts
@@ -50,8 +50,6 @@
'unique',
'nonfungible',
'refungible',
- 'rmrkcore',
- 'rmrkequip',
'scheduler',
'charging',
];
@@ -64,6 +62,16 @@
];
describe('Pallet presence', () => {
+ before(async () => {
+ await usingApi(async api => {
+ const chain = await api.rpc.system.chain();
+
+ if (!chain.eq('UNIQUE')) {
+ requiredPallets.push(...['rmrkcore', 'rmrkequip']);
+ }
+ });
+ });
+
it('Required pallets are present', async () => {
await usingApi(async api => {
for (let i=0; i<requiredPallets.length; i++) {
tests/src/rmrk/rmrk.test.tsdiffbeforeafterboth--- a/tests/src/rmrk/rmrk.test.ts
+++ b/tests/src/rmrk/rmrk.test.ts
@@ -11,6 +11,7 @@
} from '../util/helpers';
import {IKeyringPair} from '@polkadot/types/types';
import {ApiPromise} from '@polkadot/api';
+import {it} from 'mocha';
let alice: IKeyringPair;
let bob: IKeyringPair;
@@ -48,14 +49,26 @@
return result.data!;
}
-describe('RMRK External Integration Test', () => {
+async function isUnique(): Promise<boolean> {
+ return usingApi(async api => {
+ const chain = await api.rpc.system.chain();
+
+ return chain.eq('UNIQUE');
+ });
+}
+
+describe('RMRK External Integration Test', async () => {
+ const it_rmrk = (await isUnique() ? it : it.skip);
+
before(async () => {
await usingApi(async (api, privateKeyWrapper) => {
alice = privateKeyWrapper('//Alice');
+
+
});
});
- it('Creates a new RMRK collection that is mapped to a different ID and is tagged as external', async () => {
+ it_rmrk('Creates a new RMRK collection that is mapped to a different ID and is tagged as external', async () => {
await usingApi(async api => {
// throwaway collection to bump last Unique collection ID to test ID mapping
await createCollectionExpectSuccess();
@@ -70,11 +83,13 @@
});
});
-describe('Negative Integration Test: External Collections, Internal Ops', () => {
+describe('Negative Integration Test: External Collections, Internal Ops', async () => {
let uniqueCollectionId: number;
let rmrkCollectionId: number;
let rmrkNftId: number;
+ const it_rmrk = (await isUnique() ? it : it.skip);
+
before(async () => {
await usingApi(async (api, privateKeyWrapper) => {
alice = privateKeyWrapper('//Alice');
@@ -88,7 +103,7 @@
});
});
- it('[Negative] Forbids Unique operations with an external collection, handled by dispatch_call', async () => {
+ it_rmrk('[Negative] Forbids Unique operations with an external collection, handled by dispatch_call', async () => {
await usingApi(async api => {
// Collection item creation
@@ -147,7 +162,7 @@
});
});
- it('[Negative] Forbids Unique collection operations with an external collection', async () => {
+ it_rmrk('[Negative] Forbids Unique collection operations with an external collection', async () => {
await usingApi(async api => {
const txDestroyCollection = api.tx.unique.destroyCollection(uniqueCollectionId);
await expect(executeTransaction(api, alice, txDestroyCollection), 'destroying collection')
@@ -206,10 +221,12 @@
});
});
-describe('Negative Integration Test: Internal Collections, External Ops', () => {
+describe('Negative Integration Test: Internal Collections, External Ops', async () => {
let collectionId: number;
let nftId: number;
+ const it_rmrk = (await isUnique() ? it : it.skip);
+
before(async () => {
await usingApi(async (api, privateKeyWrapper) => {
alice = privateKeyWrapper('//Alice');
@@ -220,7 +237,7 @@
});
});
- it('[Negative] Forbids RMRK operations with the internal collection and NFT (due to the lack of mapping)', async () => {
+ it_rmrk('[Negative] Forbids RMRK operations with the internal collection and NFT (due to the lack of mapping)', async () => {
await usingApi(async api => {
const txChangeOwner = api.tx.rmrkCore.changeCollectionIssuer(collectionId, bob.address);
await expect(executeTransaction(api, alice, txChangeOwner), 'changing collection issuer')