--- a/.rustfmt.toml +++ b/.rustfmt.toml @@ -1,2 +1,3 @@ +group_imports = "stdexternalcrate" hard_tabs = true -reorder_imports = false +imports_granularity = "crate" --- a/client/rpc/src/lib.rs +++ b/client/rpc/src/lib.rs @@ -17,23 +17,19 @@ // Original License use std::sync::Arc; -use codec::Decode; -use jsonrpsee::{ - core::{RpcResult as Result}, - proc_macros::rpc, -}; use anyhow::anyhow; +use app_promotion_rpc::AppPromotionApi as AppPromotionRuntimeApi; +pub use app_promotion_unique_rpc::AppPromotionApiServer; +use jsonrpsee::{core::RpcResult as Result, proc_macros::rpc}; +use parity_scale_codec::Decode; +use sp_api::{ApiExt, BlockT, ProvideRuntimeApi}; +use sp_blockchain::HeaderBackend; use sp_runtime::traits::{AtLeast32BitUnsigned, Member}; use up_data_structs::{ - RpcCollection, CollectionId, CollectionStats, CollectionLimits, TokenId, Property, - PropertyKeyPermission, TokenData, TokenChild, + CollectionId, CollectionLimits, CollectionStats, Property, PropertyKeyPermission, + RpcCollection, TokenChild, TokenData, TokenId, }; -use sp_api::{BlockT, ProvideRuntimeApi, ApiExt}; -use sp_blockchain::HeaderBackend; use up_rpc::UniqueApi as UniqueRuntimeApi; -use app_promotion_rpc::AppPromotionApi as AppPromotionRuntimeApi; - -pub use app_promotion_unique_rpc::AppPromotionApiServer; #[cfg(feature = "pov-estimate")] pub mod pov_estimate; @@ -549,16 +545,16 @@ keys.map(|keys| keys.into_iter().map(|key| key.into_bytes()).collect()) } -fn decode_collection_from_bytes( +fn decode_collection_from_bytes( bytes: &[u8], -) -> core::result::Result { - let mut reader = codec::IoReader(bytes); +) -> core::result::Result { + let mut reader = parity_scale_codec::IoReader(bytes); T::decode(&mut reader) } fn detect_type_and_decode_collection( bytes: &[u8], -) -> core::result::Result, codec::Error> { +) -> core::result::Result, parity_scale_codec::Error> { use up_data_structs::{CollectionVersion1, RpcCollectionVersion1}; decode_collection_from_bytes::>(bytes) @@ -574,11 +570,12 @@ #[cfg(test)] mod tests { - use super::*; - use codec::IoReader; use hex_literal::hex; + use parity_scale_codec::IoReader; use up_data_structs::{CollectionVersion1, RawEncoded}; + use super::*; + const ENCODED_COLLECTION_V1: [u8; 180] = hex!("aab94a1ee784bc17f68d76d4d48d736916ca6ff6315b8c1fa1175726c8345a390000285000720069006d00610020004c00690076006500d04500730065006d00700069006f00200064006900200063007200650061007a0069006f006e006500200064006900200075006e00610020006e0075006f0076006100200063006f006c006c0065007a0069006f006e00650020006400690020004e004600540021000c464e5400000000000000000000000000000000"); const ENCODED_RPC_COLLECTION_V2: [u8; 618] = hex!("d00dcc24bf66750d3809aa26884b930ec8a3094d6f6f19fdc62020b2fbec013400604d0069006e007400460065007300740020002d002000460075006e006e007900200061006e0069006d0061006c0073008c430072006f00730073006f0076006500720020006200650074007700650065006e00200061006e0069006d0061006c00730020002d00200066006f0072002000660075006e00104d46464100000000000000000000010001000100000004385f6f6c645f636f6e7374446174610001000c5c5f6f6c645f636f6e73744f6e436861696e536368656d6139047b226e6573746564223a7b226f6e436861696e4d65746144617461223a7b226e6573746564223a7b224e46544d657461223a7b226669656c6473223a7b22697066734a736f6e223a7b226964223a312c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c2248656164223a7b226964223a322c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c22426f6479223a7b226964223a332c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c225461696c223a7b226964223a342c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d7d7d7d7d7d7d485f6f6c645f736368656d6156657273696f6e18556e69717565685f6f6c645f7661726961626c654f6e436861696e536368656d6111017b22636f6c6c656374696f6e436f766572223a22516d53557a7139354c357a556777795a584d3731576a3762786b36557048515468633162536965347766706e5435227d000000"); --- a/client/rpc/src/pov_estimate.rs +++ b/client/rpc/src/pov_estimate.rs @@ -16,39 +16,31 @@ use std::sync::Arc; -use codec::{Encode, Decode}; -use sp_externalities::Extensions; - -use up_pov_estimate_rpc::{PovEstimateApi as PovEstimateRuntimeApi}; -use up_common::types::opaque::RuntimeId; - -use sc_service::{NativeExecutionDispatch, config::ExecutionStrategy}; -use sp_state_machine::{StateMachine, TrieBackendBuilder}; -use trie_db::{Trie, TrieDBBuilder}; - +use anyhow::anyhow; use jsonrpsee::{core::RpcResult as Result, proc_macros::rpc}; -use anyhow::anyhow; - +use parity_scale_codec::{Decode, Encode}; use sc_client_api::backend::Backend; +use sc_executor::NativeElseWasmExecutor; +use sc_rpc_api::DenyUnsafe; +use sc_service::{config::ExecutionStrategy, NativeExecutionDispatch}; +use sp_api::{AsTrieBackend, BlockId, BlockT, ProvideRuntimeApi}; use sp_blockchain::HeaderBackend; use sp_core::{ - Bytes, offchain::{ testing::{TestOffchainExt, TestTransactionPoolExt}, OffchainDbExt, OffchainWorkerExt, TransactionPoolExt, }, testing::TaskExecutor, traits::TaskExecutorExt, + Bytes, }; +use sp_externalities::Extensions; use sp_keystore::{testing::KeyStore, KeystoreExt}; -use sp_api::{AsTrieBackend, BlockId, BlockT, ProvideRuntimeApi}; - -use sc_executor::NativeElseWasmExecutor; -use sc_rpc_api::DenyUnsafe; - use sp_runtime::traits::Header; - -use up_pov_estimate_rpc::{PovInfo, TrieKeyValue}; +use sp_state_machine::{StateMachine, TrieBackendBuilder}; +use trie_db::{Trie, TrieDBBuilder}; +use up_common::types::opaque::RuntimeId; +use up_pov_estimate_rpc::{PovEstimateApi as PovEstimateRuntimeApi, PovInfo, TrieKeyValue}; use crate::define_struct_for_server_api; --- a/crates/struct-versioning/src/lib.rs +++ b/crates/struct-versioning/src/lib.rs @@ -17,13 +17,12 @@ #![doc = include_str!("../README.md")] use proc_macro::TokenStream; -use quote::format_ident; +use quote::{format_ident, quote}; use syn::{ - parse::{Parse, ParseStream}, - Token, LitInt, parse_macro_input, ItemStruct, Error, Fields, Result, Field, Expr, parenthesized, + parse::{Parse, ParseStream}, + parse_macro_input, Error, Expr, Field, Fields, ItemStruct, LitInt, Result, Token, }; -use quote::quote; mod kw { syn::custom_keyword!(version); --- a/node/cli/src/chain_spec.rs +++ b/node/cli/src/chain_spec.rs @@ -14,36 +14,35 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . +use std::collections::BTreeMap; + +#[cfg(all(not(feature = "unique-runtime"), not(feature = "quartz-runtime")))] +pub use opal_runtime as default_runtime; +#[cfg(all(not(feature = "unique-runtime"), feature = "quartz-runtime"))] +pub use quartz_runtime as default_runtime; use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup}; use sc_service::ChainType; +use serde::{Deserialize, Serialize}; +use serde_json::map::Map; use sp_core::{sr25519, Pair, Public}; use sp_runtime::traits::{IdentifyAccount, Verify}; -use std::collections::BTreeMap; - -use serde::{Deserialize, Serialize}; -use serde_json::map::Map; - -use up_common::types::opaque::*; - #[cfg(feature = "unique-runtime")] pub use unique_runtime as default_runtime; - -#[cfg(all(not(feature = "unique-runtime"), feature = "quartz-runtime"))] -pub use quartz_runtime as default_runtime; - -#[cfg(all(not(feature = "unique-runtime"), not(feature = "quartz-runtime")))] -pub use opal_runtime as default_runtime; +use up_common::types::opaque::*; /// The `ChainSpec` parameterized for the unique runtime. #[cfg(feature = "unique-runtime")] -pub type UniqueChainSpec = sc_service::GenericChainSpec; +pub type UniqueChainSpec = + sc_service::GenericChainSpec; /// The `ChainSpec` parameterized for the quartz runtime. #[cfg(feature = "quartz-runtime")] -pub type QuartzChainSpec = sc_service::GenericChainSpec; +pub type QuartzChainSpec = + sc_service::GenericChainSpec; /// The `ChainSpec` parameterized for the opal runtime. -pub type OpalChainSpec = sc_service::GenericChainSpec; +pub type OpalChainSpec = + sc_service::GenericChainSpec; #[cfg(feature = "unique-runtime")] pub type DefaultChainSpec = UniqueChainSpec; --- a/node/cli/src/cli.rs +++ b/node/cli/src/cli.rs @@ -14,10 +14,12 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use crate::chain_spec; use std::path::PathBuf; + use clap::Parser; +use crate::chain_spec; + /// Sub-commands supported by the collator. #[derive(Debug, Parser)] pub enum Subcommand { --- a/node/cli/src/command.rs +++ b/node/cli/src/command.rs @@ -32,28 +32,11 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crate::{ - chain_spec::{self, RuntimeIdentification, ServiceId, ServiceIdentification}, - cli::{Cli, RelayChainCli, Subcommand}, - service::{new_partial, start_node, start_dev_node}, -}; -#[cfg(feature = "runtime-benchmarks")] -use crate::chain_spec::default_runtime; - -#[cfg(feature = "unique-runtime")] -use crate::service::UniqueRuntimeExecutor; - -#[cfg(feature = "quartz-runtime")] -use crate::service::QuartzRuntimeExecutor; - -use crate::service::OpalRuntimeExecutor; - -#[cfg(feature = "runtime-benchmarks")] -use crate::service::DefaultRuntimeExecutor; +use std::time::Duration; use codec::Encode; -use cumulus_primitives_core::ParaId; use cumulus_client_cli::generate_genesis_block; +use cumulus_primitives_core::ParaId; use log::{debug, info}; use sc_cli::{ ChainSpec, CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams, @@ -62,8 +45,21 @@ use sc_service::config::{BasePath, PrometheusConfig}; use sp_core::hexdisplay::HexDisplay; use sp_runtime::traits::{AccountIdConversion, Block as BlockT}; +use up_common::types::opaque::{Block, RuntimeId}; -use up_common::types::opaque::{Block, RuntimeId}; +#[cfg(feature = "runtime-benchmarks")] +use crate::chain_spec::default_runtime; +#[cfg(feature = "runtime-benchmarks")] +use crate::service::DefaultRuntimeExecutor; +#[cfg(feature = "quartz-runtime")] +use crate::service::QuartzRuntimeExecutor; +#[cfg(feature = "unique-runtime")] +use crate::service::UniqueRuntimeExecutor; +use crate::{ + chain_spec::{self, RuntimeIdentification, ServiceId, ServiceIdentification}, + cli::{Cli, RelayChainCli, Subcommand}, + service::{new_partial, start_dev_node, start_node, OpalRuntimeExecutor}, +}; macro_rules! no_runtime_err { ($runtime_id:expr) => { --- a/node/cli/src/lib.rs +++ /dev/null @@ -1,18 +0,0 @@ -// Copyright 2019-2022 Unique Network (Gibraltar) Ltd. -// This file is part of Unique Network. - -// Unique Network is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Unique Network is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Unique Network. If not, see . - -pub mod chain_spec; -pub mod service; --- a/node/cli/src/main.rs +++ b/node/cli/src/main.rs @@ -19,6 +19,7 @@ mod service; mod cli; mod command; +mod rpc; fn main() -> sc_cli::Result<()> { command::run() --- a/node/cli/src/service.rs +++ b/node/cli/src/service.rs @@ -15,73 +15,72 @@ // along with Unique Network. If not, see . // std -use std::sync::Arc; -use std::sync::Mutex; -use std::collections::BTreeMap; -use std::time::Duration; -use std::pin::Pin; -use fc_mapping_sync::EthereumBlockNotificationSinks; -use fc_rpc::EthBlockDataCacheTask; -use fc_rpc::EthTask; -use fc_rpc_core::types::FeeHistoryCache; -use futures::{ - Stream, StreamExt, - stream::select, - task::{Context, Poll}, +use std::{ + collections::BTreeMap, + marker::PhantomData, + pin::Pin, + sync::{Arc, Mutex}, + time::Duration, }; -use sc_rpc::SubscriptionTaskExecutor; -use sp_keystore::KeystorePtr; -use tokio::time::Interval; -use jsonrpsee::RpcModule; - -use serde::{Serialize, Deserialize}; -// Cumulus Imports -use cumulus_client_consensus_aura::{AuraConsensus, BuildAuraConsensusParams, SlotProportion}; -use cumulus_client_consensus_common::{ - ParachainConsensus, ParachainBlockImport as TParachainBlockImport, +use cumulus_client_cli::CollatorOptions; +use cumulus_client_collator::service::CollatorService; +#[cfg(not(feature = "lookahead"))] +use cumulus_client_consensus_aura::collators::basic::{ + run as run_aura, Params as BuildAuraConsensusParams, }; +#[cfg(feature = "lookahead")] +use cumulus_client_consensus_aura::collators::lookahead::{ + run as run_aura, Params as BuildAuraConsensusParams, +}; +use cumulus_client_consensus_common::ParachainBlockImport as TParachainBlockImport; +use cumulus_client_consensus_proposer::Proposer; +use cumulus_client_network::RequireSecondedInBlockAnnounce; use cumulus_client_service::{ - prepare_node_config, start_collator, start_full_node, StartCollatorParams, StartFullNodeParams, + build_relay_chain_interface, prepare_node_config, start_relay_chain_tasks, DARecoveryProfile, + StartRelayChainTasksParams, }; -use cumulus_client_cli::CollatorOptions; -use cumulus_client_network::BlockAnnounceValidator; use cumulus_primitives_core::ParaId; -use cumulus_relay_chain_inprocess_interface::build_inprocess_relay_chain; -use cumulus_relay_chain_interface::{RelayChainInterface, RelayChainResult}; -use cumulus_relay_chain_minimal_node::build_minimal_relay_chain_node; - -// Substrate Imports -use sp_api::{BlockT, HeaderT, ProvideRuntimeApi, StateBackend}; -use sc_executor::NativeElseWasmExecutor; -use sc_executor::NativeExecutionDispatch; +use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface}; +use fc_mapping_sync::{kv::MappingSyncWorker, EthereumBlockNotificationSinks, SyncStrategy}; +use fc_rpc::{ + frontier_backend_client::SystemAccountId32StorageOverride, EthBlockDataCacheTask, EthConfig, + EthTask, OverrideHandle, RuntimeApiStorageOverride, SchemaV1Override, SchemaV2Override, + SchemaV3Override, StorageOverride, +}; +use fc_rpc_core::types::{FeeHistoryCache, FilterPool}; +use fp_rpc::EthereumRuntimeRPCApi; +use fp_storage::EthereumStorageSchema; +use futures::{ + stream::select, + task::{Context, Poll}, + Stream, StreamExt, +}; +use jsonrpsee::RpcModule; +use polkadot_service::CollatorPair; +use sc_client_api::{AuxStore, Backend, BlockOf, BlockchainEvents, StorageProvider}; +use sc_consensus::ImportQueue; +use sc_executor::{NativeElseWasmExecutor, NativeExecutionDispatch}; use sc_network::NetworkBlock; use sc_network_sync::SyncingService; +use sc_rpc::SubscriptionTaskExecutor; use sc_service::{Configuration, PartialComponents, TaskManager}; use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle}; +use serde::{Deserialize, Serialize}; +use sp_api::{ProvideRuntimeApi, StateBackend}; +use sp_block_builder::BlockBuilder; +use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata}; +use sp_consensus_aura::sr25519::AuthorityPair as AuraAuthorityPair; +use sp_keystore::KeystorePtr; use sp_runtime::traits::BlakeTwo256; use substrate_prometheus_endpoint::Registry; -use sc_client_api::{BlockchainEvents, BlockOf, Backend, AuxStore, StorageProvider}; -use sp_blockchain::{HeaderBackend, HeaderMetadata, Error as BlockChainError}; -use sc_consensus::ImportQueue; -use sp_core::H256; -use sp_block_builder::BlockBuilder; +use tokio::time::Interval; +use up_common::types::{opaque::*, Nonce}; -use polkadot_service::CollatorPair; - -// Frontier Imports -use fc_rpc_core::types::FilterPool; -use fc_mapping_sync::{kv::MappingSyncWorker, SyncStrategy}; -use fc_rpc::{ - StorageOverride, OverrideHandle, SchemaV1Override, SchemaV2Override, SchemaV3Override, - RuntimeApiStorageOverride, +use crate::{ + chain_spec::RuntimeIdentification, + rpc::{create_eth, create_full, EthDeps, FullDeps}, }; -use fp_rpc::EthereumRuntimeRPCApi; -use fp_storage::EthereumStorageSchema; - -use up_common::types::opaque::*; - -use crate::chain_spec::RuntimeIdentification; /// Unique native executor instance. #[cfg(feature = "unique-runtime")] --- a/pallets/app-promotion/src/benchmarking.rs +++ b/pallets/app-promotion/src/benchmarking.rs @@ -16,16 +16,15 @@ #![cfg(feature = "runtime-benchmarks")] -use super::*; -use crate::Pallet as PromototionPallet; -use frame_support::traits::fungible::Unbalanced; -use sp_runtime::traits::Bounded; - -use frame_benchmarking::{benchmarks, account}; -use frame_support::traits::OnInitialize; +use frame_benchmarking::{account, benchmarks}; +use frame_support::traits::{fungible::Unbalanced, OnInitialize}; use frame_system::RawOrigin; +use pallet_evm_migration::Pallet as EvmMigrationPallet; use pallet_unique::benchmarking::create_nft_collection; -use pallet_evm_migration::Pallet as EvmMigrationPallet; +use sp_runtime::traits::Bounded; + +use super::*; +use crate::Pallet as PromototionPallet; const SEED: u32 = 0; --- a/pallets/app-promotion/src/lib.rs +++ b/pallets/app-promotion/src/lib.rs @@ -53,32 +53,32 @@ pub mod types; pub mod weights; -use sp_std::{vec::Vec, vec, iter::Sum, borrow::ToOwned, cell::RefCell}; -use sp_core::H160; -use codec::EncodeLike; -pub use types::*; - -use up_data_structs::CollectionId; - use frame_support::{ - dispatch::{DispatchResult}, + dispatch::DispatchResult, + ensure, + pallet_prelude::*, + storage::Key, traits::{ - Get, + fungible::{Inspect, InspectFreeze, Mutate, MutateFreeze}, tokens::Balance, - fungible::{Inspect, InspectFreeze, Mutate, MutateFreeze}, + Get, }, - ensure, BoundedVec, + weights::Weight, + Blake2_128Concat, BoundedVec, PalletId, Twox64Concat, }; - -use weights::WeightInfo; - +use frame_system::pallet_prelude::*; pub use pallet::*; use pallet_evm::account::CrossAccountId; +use parity_scale_codec::EncodeLike; +use sp_core::H160; use sp_runtime::{ - Perbill, - traits::{BlockNumberProvider, CheckedAdd, CheckedSub, AccountIdConversion, Zero}, - ArithmeticError, DispatchError, + traits::{AccountIdConversion, BlockNumberProvider, CheckedAdd, CheckedSub, Zero}, + ArithmeticError, DispatchError, Perbill, }; +use sp_std::{borrow::ToOwned, cell::RefCell, iter::Sum, vec, vec::Vec}; +pub use types::*; +use up_data_structs::CollectionId; +use weights::WeightInfo; const PENDING_LIMIT_PER_BLOCK: u32 = 3; @@ -87,12 +87,8 @@ #[frame_support::pallet] pub mod pallet { + use super::*; - use frame_support::{ - Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, PalletId, weights::Weight, - }; - use frame_system::pallet_prelude::*; - use sp_runtime::DispatchError; #[pallet::config] pub trait Config: --- a/pallets/app-promotion/src/types.rs +++ b/pallets/app-promotion/src/types.rs @@ -1,13 +1,12 @@ -use frame_support::{dispatch::DispatchResult}; - +use frame_support::dispatch::DispatchResult; +use frame_system::pallet_prelude::*; use pallet_common::CollectionHandle; - +use pallet_configuration::AppPromomotionConfigurationOverride; +use pallet_evm_contract_helpers::{Config as EvmHelpersConfig, Pallet as EvmHelpersPallet}; +use sp_core::Get; use sp_runtime::{DispatchError, Perbill}; -use up_data_structs::{CollectionId}; use sp_std::borrow::ToOwned; -use pallet_evm_contract_helpers::{Pallet as EvmHelpersPallet, Config as EvmHelpersConfig}; -use pallet_configuration::{AppPromomotionConfigurationOverride}; -use sp_core::Get; +use up_data_structs::CollectionId; const MAX_NUMBER_PAYOUTS: u8 = 100; pub(crate) const DEFAULT_NUMBER_PAYOUTS: u8 = 20; --- a/pallets/balances-adapter/src/common.rs +++ b/pallets/balances-adapter/src/common.rs @@ -1,11 +1,13 @@ use alloc::{vec, vec::Vec}; use core::marker::PhantomData; -use crate::{Config, NativeFungibleHandle, Pallet}; + use frame_support::{fail, weights::Weight}; use pallet_balances::{weights::SubstrateWeight as BalancesWeight, WeightInfo}; use pallet_common::{CommonCollectionOperations, CommonWeightInfo}; use up_data_structs::TokenId; +use crate::{Config, NativeFungibleHandle, Pallet}; + pub struct CommonWeights(PhantomData); // All implementations with `Weight::default` used in methods that return error `UnsupportedOperation`. --- a/pallets/balances-adapter/src/erc.rs +++ b/pallets/balances-adapter/src/erc.rs @@ -1,4 +1,3 @@ -use crate::{Config, NativeFungibleHandle, Pallet, SelfWeightOf}; use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*}; use pallet_balances::WeightInfo; use pallet_common::{ @@ -10,8 +9,10 @@ execution::{PreDispatch, Result}, frontier_contract, WithRecorder, }; -use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _}; -use sp_core::{U256, Get}; +use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight}; +use sp_core::{Get, U256}; + +use crate::{Config, NativeFungibleHandle, Pallet, SelfWeightOf}; frontier_contract! { macro_rules! NativeFungibleHandle_result {...} --- a/pallets/balances-adapter/src/lib.rs +++ b/pallets/balances-adapter/src/lib.rs @@ -4,8 +4,8 @@ use core::ops::Deref; use frame_support::sp_runtime::DispatchResult; -use pallet_evm_coder_substrate::{WithRecorder, SubstrateRecorder}; pub use pallet::*; +use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder}; pub mod common; pub mod erc; @@ -55,16 +55,16 @@ } #[frame_support::pallet] pub mod pallet { - use super::*; use alloc::string::String; + use frame_support::{ dispatch::PostDispatchInfo, ensure, - pallet_prelude::{DispatchResultWithPostInfo, Pays}, + pallet_prelude::*, traits::{ - Get, fungible::{Inspect, Mutate}, tokens::Preservation, + Get, }, }; use pallet_balances::WeightInfo; @@ -74,6 +74,8 @@ use sp_runtime::DispatchError; use up_data_structs::{budget::Budget, mapping::TokenAddressMapping}; + use super::*; + #[pallet::config] pub trait Config: frame_system::Config --- a/pallets/collator-selection/src/benchmarking.rs +++ b/pallets/collator-selection/src/benchmarking.rs @@ -32,18 +32,13 @@ //! Benchmarking setup for pallet-collator-selection -use super::*; - -#[allow(unused)] -use crate::{Pallet as CollatorSelection, BalanceOf}; use frame_benchmarking::{account, benchmarks, impl_benchmark_test_suite, whitelisted_caller}; use frame_support::{ assert_ok, - codec::Decode, + parity_scale_codec::Decode, traits::{ - EnsureOrigin, fungible::{Inspect, Mutate}, - Get, + EnsureOrigin, Get, }, }; use frame_system::{EventRecord, RawOrigin}; --- a/pallets/collator-selection/src/lib.rs +++ b/pallets/collator-selection/src/lib.rs @@ -96,26 +96,27 @@ <::Currency as Inspect<::AccountId>>::Balance; #[frame_support::pallet] pub mod pallet { - use super::*; - pub use crate::weights::WeightInfo; use core::ops::Div; + use frame_support::{ dispatch::{DispatchClass, DispatchResultWithPostInfo}, - inherent::Vec, pallet_prelude::*, sp_runtime::traits::{AccountIdConversion, CheckedSub, Saturating, Zero}, traits::{ - EnsureOrigin, - fungible::{Balanced, BalancedHold, Inspect, InspectHold, Mutate, MutateHold}, - ValidatorRegistration, + fungible::{Balanced, BalancedHold, Inspect, Mutate, MutateHold}, tokens::{Precision, Preservation}, + EnsureOrigin, ValidatorRegistration, }, BoundedVec, PalletId, }; use frame_system::pallet_prelude::*; use pallet_session::SessionManager; - use sp_runtime::{Perbill, traits::Convert}; + use sp_runtime::{traits::Convert, Perbill}; use sp_staking::SessionIndex; + use sp_std::vec::Vec; + + use super::*; + pub use crate::weights::WeightInfo; /// A convertor from collators id. Since this pallet does not have stash/controller, this is /// just identity. --- a/pallets/collator-selection/src/mock.rs +++ b/pallets/collator-selection/src/mock.rs @@ -30,8 +30,6 @@ // See the License for the specific language governing permissions and // limitations under the License. -use super::*; -use crate as collator_selection; use frame_support::{ ord_parameter_types, parameter_types, traits::{FindAuthor, GenesisBuild, ValidatorRegistration}, @@ -46,6 +44,9 @@ Perbill, RuntimeAppPublic, }; +use super::*; +use crate as collator_selection; + type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; type Block = frame_system::mocking::MockBlock; --- a/pallets/collator-selection/src/tests.rs +++ b/pallets/collator-selection/src/tests.rs @@ -30,15 +30,15 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crate::{self as collator_selection, Config}; -use crate::{mock::*, Error}; use frame_support::{ assert_noop, assert_ok, traits::{fungible, GenesisBuild, OnInitialize}, }; +use scale_info::prelude::*; use sp_runtime::{traits::BadOrigin, TokenError}; -use scale_info::prelude::*; +use crate::{self as collator_selection, mock::*, Config, Error}; + fn get_license_and_onboard(account_id: ::AccountId) { assert_ok!(CollatorSelection::get_license(RuntimeOrigin::signed( account_id --- a/pallets/common/src/benchmarking.rs +++ b/pallets/common/src/benchmarking.rs @@ -16,23 +16,25 @@ #![allow(missing_docs)] -use sp_std::vec::Vec; -use crate::{Config, CollectionHandle, Pallet}; -use pallet_evm::account::CrossAccountId; -use frame_benchmarking::{benchmarks, account}; -use up_data_structs::{ - CollectionMode, CreateCollectionData, CollectionId, Property, PropertyKey, PropertyValue, - CollectionPermissions, NestingPermissions, AccessMode, PropertiesPermissionMap, - MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, - MAX_PROPERTIES_PER_ITEM, -}; +use core::convert::TryInto; + +use frame_benchmarking::{account, benchmarks}; use frame_support::{ - traits::{Get, fungible::Balanced, Imbalance, tokens::Precision}, pallet_prelude::ConstU32, + traits::{fungible::Balanced, tokens::Precision, Get, Imbalance}, BoundedVec, }; -use core::convert::TryInto; -use sp_runtime::{DispatchError, traits::Zero}; +use pallet_evm::account::CrossAccountId; +use sp_runtime::{traits::Zero, DispatchError}; +use sp_std::vec::Vec; +use up_data_structs::{ + AccessMode, CollectionId, CollectionMode, CollectionPermissions, CreateCollectionData, + NestingPermissions, PropertiesPermissionMap, Property, PropertyKey, PropertyValue, + MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_PROPERTIES_PER_ITEM, + MAX_TOKEN_PREFIX_LENGTH, +}; + +use crate::{CollectionHandle, Config, Pallet}; const SEED: u32 = 1; --- a/pallets/common/src/dispatch.rs +++ b/pallets/common/src/dispatch.rs @@ -2,13 +2,13 @@ use frame_support::{ dispatch::{ - DispatchResultWithPostInfo, PostDispatchInfo, Weight, DispatchErrorWithPostInfo, - DispatchResult, + DispatchErrorWithPostInfo, DispatchResult, DispatchResultWithPostInfo, Pays, + PostDispatchInfo, }, - dispatch::Pays, traits::Get, }; use sp_runtime::DispatchError; +use sp_weights::Weight; use up_data_structs::{CollectionId, CreateCollectionData}; use crate::{pallet::Config, CommonCollectionOperations}; --- a/pallets/common/src/erc.rs +++ b/pallets/common/src/erc.rs @@ -16,15 +16,17 @@ //! This module contains the implementation of pallet methods for evm. -pub use pallet_evm::{PrecompileOutput, PrecompileResult, PrecompileHandle, account::CrossAccountId}; +pub use pallet_evm::{ + account::CrossAccountId, PrecompileHandle, PrecompileOutput, PrecompileResult, +}; use pallet_evm_coder_substrate::{ abi::AbiType, - solidity_interface, ToLog, + dispatch_to_evm, + execution::{Error, PreDispatch, Result}, + frontier_contract, solidity_interface, types::*, - execution::{Result, Error, PreDispatch}, - frontier_contract, + ToLog, }; -use pallet_evm_coder_substrate::dispatch_to_evm; use sp_std::{vec, vec::Vec}; use up_data_structs::{ CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property, SponsoringRateLimit, @@ -32,7 +34,7 @@ }; use crate::{ - Pallet, CollectionHandle, Config, CollectionProperties, eth, SelfWeightOf, weights::WeightInfo, + eth, weights::WeightInfo, CollectionHandle, CollectionProperties, Config, Pallet, SelfWeightOf, }; frontier_contract! { @@ -727,11 +729,10 @@ /// Contains static property keys and values. pub mod static_property { - use pallet_evm_coder_substrate::{ - execution::{Result, Error}, - }; use alloc::format; + use pallet_evm_coder_substrate::execution::{Error, Result}; + const EXPECT_CONVERT_ERROR: &str = "length < limit"; /// Keys. --- a/pallets/common/src/eth.rs +++ b/pallets/common/src/eth.rs @@ -17,15 +17,16 @@ //! The module contains a number of functions for converting and checking ethereum identifiers. use alloc::format; -use sp_std::{vec, vec::Vec}; + use evm_coder::{ + types::{Address, String}, AbiCoder, - types::{Address, String}, }; -pub use pallet_evm::{Config, account::CrossAccountId}; -use sp_core::{H160, U256}; -use up_data_structs::{CollectionId, CollectionFlags}; +pub use pallet_evm::{account::CrossAccountId, Config}; use pallet_evm_coder_substrate::execution::Error; +use sp_core::{H160, U256}; +use sp_std::{vec, vec::Vec}; +use up_data_structs::{CollectionFlags, CollectionId}; // 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 1 // TODO: Unhardcode prefix --- a/pallets/common/src/helpers.rs +++ b/pallets/common/src/helpers.rs @@ -3,9 +3,9 @@ //! The module contains helpers. //! use frame_support::{ + dispatch::{DispatchErrorWithPostInfo, PostDispatchInfo}, pallet_prelude::DispatchResultWithPostInfo, weights::Weight, - dispatch::{DispatchErrorWithPostInfo, PostDispatchInfo}, }; /// Add weight for a `DispatchResultWithPostInfo` --- a/pallets/common/src/lib.rs +++ b/pallets/common/src/lib.rs @@ -58,37 +58,37 @@ slice::from_ref, marker::PhantomData, }; -use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder}; -use sp_std::vec::Vec; -use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; + use evm_coder::ToLog; use frame_support::{ - dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Weight, PostDispatchInfo}, - ensure, + dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo, Pays, PostDispatchInfo}, + ensure, fail, traits::{ - Get, fungible::{Balanced, Debt, Inspect}, tokens::{Imbalance, Precision, Preservation}, + Get, }, - dispatch::Pays, - transactional, fail, + transactional, }; +pub use pallet::*; +use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; +use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder}; +use sp_core::H160; +use sp_runtime::{traits::Zero, ArithmeticError, DispatchError, DispatchResult}; +use sp_std::vec::Vec; +use sp_weights::Weight; use up_data_structs::{ - AccessMode, COLLECTION_NUMBER_LIMIT, Collection, RpcCollection, RpcCollectionFlags, - CollectionId, CreateItemData, MAX_TOKEN_PREFIX_LENGTH, COLLECTION_ADMINS_LIMIT, TokenId, - TokenChild, CollectionStats, MAX_TOKEN_OWNERSHIP, CollectionMode, NFT_SPONSOR_TRANSFER_TIMEOUT, - FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT, - CUSTOM_DATA_LIMIT, CollectionLimits, CreateCollectionData, SponsorshipState, CreateItemExData, - SponsoringRateLimit, budget::Budget, PhantomType, Property, - CollectionProperties as CollectionPropertiesT, TokenProperties, PropertiesPermissionMap, - PropertyKey, PropertyValue, PropertyPermission, PropertiesError, TokenOwnerError, - PropertyKeyPermission, TokenData, TrySetProperty, PropertyScope, CollectionPermissions, + budget::Budget, AccessMode, Collection, CollectionId, CollectionLimits, CollectionMode, + CollectionPermissions, CollectionProperties as CollectionPropertiesT, CollectionStats, + CreateCollectionData, CreateItemData, CreateItemExData, PhantomType, PropertiesError, + PropertiesPermissionMap, Property, PropertyKey, PropertyKeyPermission, PropertyPermission, + PropertyScope, PropertyValue, RpcCollection, RpcCollectionFlags, SponsoringRateLimit, + SponsorshipState, TokenChild, TokenData, TokenId, TokenOwnerError, TokenProperties, + TrySetProperty, COLLECTION_ADMINS_LIMIT, COLLECTION_NUMBER_LIMIT, CUSTOM_DATA_LIMIT, + FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, + MAX_TOKEN_PREFIX_LENGTH, NFT_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, }; use up_pov_estimate_rpc::PovInfo; - -pub use pallet::*; -use sp_core::H160; -use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, traits::Zero}; #[cfg(feature = "runtime-benchmarks")] pub mod benchmarking; @@ -401,13 +401,16 @@ #[frame_support::pallet] pub mod pallet { - use super::*; use dispatch::CollectionDispatch; - use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key, traits::StorageVersion}; - use up_data_structs::{TokenId, mapping::TokenAddressMapping}; + use frame_support::{ + pallet_prelude::*, storage::Key, traits::StorageVersion, Blake2_128Concat, + }; use scale_info::TypeInfo; + use up_data_structs::{mapping::TokenAddressMapping, TokenId}; use weights::WeightInfo; + use super::*; + #[pallet::config] pub trait Config: frame_system::Config + pallet_evm_coder_substrate::Config + pallet_evm::Config + TypeInfo @@ -2720,7 +2723,7 @@ #[cfg(any(feature = "tests", test))] #[allow(missing_docs)] pub mod tests { - use crate::{DispatchResult, DispatchError, LazyValue, Config}; + use crate::{Config, DispatchError, DispatchResult, LazyValue}; const fn to_bool(u: u8) -> bool { u != 0 --- a/pallets/configuration/src/benchmarking.rs +++ b/pallets/configuration/src/benchmarking.rs @@ -16,10 +16,11 @@ //! Benchmarking setup for pallet-configuration -use super::*; use frame_benchmarking::benchmarks; -use frame_system::{EventRecord, RawOrigin}; use frame_support::assert_ok; +use frame_system::{EventRecord, RawOrigin}; + +use super::*; fn assert_last_event(generic_event: ::RuntimeEvent) { let events = frame_system::Pallet::::events(); --- a/pallets/configuration/src/lib.rs +++ b/pallets/configuration/src/lib.rs @@ -20,19 +20,17 @@ use frame_support::{ pallet, - weights::{WeightToFeePolynomial, WeightToFeeCoefficients, WeightToFeeCoefficient, Weight}, traits::Get, - Parameter, + weights::{Weight, WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial}, }; -use codec::{Decode, Encode, MaxEncodedLen}; +pub use pallet::*; +use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; +use smallvec::smallvec; use sp_arithmetic::{ - per_things::{Perbill, PerThing}, + per_things::{PerThing, Perbill}, traits::{BaseArithmetic, Unsigned}, }; -use smallvec::smallvec; - -pub use pallet::*; use sp_core::U256; #[cfg(feature = "runtime-benchmarks")] @@ -41,15 +39,14 @@ #[pallet] mod pallet { + use core::fmt::Debug; + + use frame_support::{pallet_prelude::*, traits::Get}; + use frame_system::{ensure_root, pallet_prelude::*}; + use parity_scale_codec::Codec; + use sp_arithmetic::{traits::AtLeast32BitUnsigned, FixedPointOperand, Permill}; + use super::*; - use frame_support::{ - traits::Get, - pallet_prelude::*, - log, - dispatch::{Codec, fmt::Debug}, - }; - use frame_system::{pallet_prelude::OriginFor, ensure_root, pallet_prelude::*}; - use sp_arithmetic::{FixedPointOperand, traits::AtLeast32BitUnsigned, Permill}; pub use crate::weights::WeightInfo; #[pallet::config] --- a/pallets/evm-coder-substrate/procedural/src/lib.rs +++ b/pallets/evm-coder-substrate/procedural/src/lib.rs @@ -1,12 +1,12 @@ use std::result; -use proc_macro2::{TokenStream, Ident}; +use proc_macro2::{Ident, TokenStream}; use quote::quote; use syn::{ - Error, DeriveInput, Data, Attribute, + parenthesized, parse::{Parse, ParseBuffer}, spanned::Spanned, - Expr, parenthesized, + Attribute, Data, DeriveInput, Error, Expr, }; type Result = result::Result; --- a/pallets/evm-coder-substrate/src/execution.rs +++ b/pallets/evm-coder-substrate/src/execution.rs @@ -22,10 +22,9 @@ use std::string::{String, ToString}; use evm_coder::ERC165Call; +pub use evm_coder_substrate_procedural::PreDispatch; use evm_core::{ExitError, ExitFatal}; - pub use frame_support::weights::Weight; -pub use evm_coder_substrate_procedural::PreDispatch; /// Execution error, should be convertible between EVM and Substrate. #[derive(Debug, Clone)] --- a/pallets/evm-coder-substrate/src/lib.rs +++ b/pallets/evm-coder-substrate/src/lib.rs @@ -22,42 +22,39 @@ extern crate alloc; #[cfg(not(feature = "std"))] use alloc::format; -use execution::PreDispatch; -use frame_support::dispatch::Weight; - use core::marker::PhantomData; -use sp_std::{cell::RefCell, vec::Vec}; -use codec::Decode; -use frame_support::pallet_prelude::DispatchError; -use frame_support::traits::PalletInfo; -use frame_support::{ensure, sp_runtime::ModuleError}; -use up_data_structs::budget; +use execution::PreDispatch; +use frame_support::{ + ensure, pallet_prelude::DispatchError, sp_runtime::ModuleError, traits::PalletInfo, +}; use pallet_evm::{ - ExitError, ExitRevert, ExitSucceed, GasWeightMapping, PrecompileFailure, PrecompileOutput, - PrecompileResult, PrecompileHandle, + ExitError, ExitRevert, ExitSucceed, GasWeightMapping, PrecompileFailure, PrecompileHandle, + PrecompileOutput, PrecompileResult, }; +use parity_scale_codec::Decode; use sp_core::{Get, H160}; +use sp_std::{cell::RefCell, vec::Vec}; +use sp_weights::Weight; +use up_data_structs::budget; // #[cfg(feature = "runtime-benchmarks")] // pub mod benchmarking; pub mod execution; -#[doc(hidden)] -pub use spez::spez; - +pub use evm_coder::{abi, solidity_interface, types, Contract, ResultWithPostInfoOf, ToLog}; use evm_coder::{ types::{Msg, Value}, AbiEncode, }; - pub use pallet::*; -pub use evm_coder::{ResultWithPostInfoOf, Contract, abi, solidity_interface, ToLog, types}; +#[doc(hidden)] +pub use spez::spez; #[frame_support::pallet] pub mod pallet { + pub use frame_support::dispatch::DispatchResult; + use super::*; - - pub use frame_support::dispatch::DispatchResult; /// DispatchError is opaque, but we need to somehow extract correct error in case of OutOfGas failure /// So we have this pallet, which defines OutOfGas error, and knews its own id to check if DispatchError --- a/pallets/evm-contract-helpers/src/eth.rs +++ b/pallets/evm-contract-helpers/src/eth.rs @@ -18,32 +18,35 @@ extern crate alloc; use core::marker::PhantomData; + use evm_coder::{ - abi::{AbiType, AbiEncode}, + abi::{AbiEncode, AbiType}, generate_stubgen, solidity_interface, types::*, ToLog, }; +use frame_support::traits::Get; +use frame_system::pallet_prelude::*; use pallet_common::eth; use pallet_evm::{ - ExitRevert, OnCreate, OnMethodCall, PrecompileResult, PrecompileFailure, PrecompileHandle, - account::CrossAccountId, + account::CrossAccountId, ExitRevert, OnCreate, OnMethodCall, PrecompileFailure, + PrecompileHandle, PrecompileResult, }; use pallet_evm_coder_substrate::{ - SubstrateRecorder, WithRecorder, dispatch_to_evm, - execution::{Result, PreDispatch}, - frontier_contract, + dispatch_to_evm, + execution::{PreDispatch, Result}, + frontier_contract, SubstrateRecorder, WithRecorder, }; use pallet_evm_transaction_payment::CallContext; use sp_core::{H160, U256}; +use sp_std::vec::Vec; use up_data_structs::SponsorshipState; +use up_sponsorship::SponsorshipHandler; + use crate::{ - AllowlistEnabled, Config, Owner, Pallet, SponsorBasket, SponsoringFeeLimit, - SponsoringRateLimit, SponsoringModeT, Sponsoring, + AllowlistEnabled, Config, Owner, Pallet, SponsorBasket, Sponsoring, SponsoringFeeLimit, + SponsoringModeT, SponsoringRateLimit, }; -use frame_support::traits::Get; -use up_sponsorship::SponsorshipHandler; -use sp_std::vec::Vec; frontier_contract! { macro_rules! ContractHelpers_result {...} --- a/pallets/evm-contract-helpers/src/lib.rs +++ b/pallets/evm-contract-helpers/src/lib.rs @@ -18,12 +18,12 @@ #![cfg_attr(not(feature = "std"), no_std)] #![warn(missing_docs)] -use codec::{Decode, Encode, MaxEncodedLen}; +pub use eth::*; use evm_coder::AbiCoder; +use frame_support::storage::bounded_btree_map::BoundedBTreeMap; pub use pallet::*; -pub use eth::*; +use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; -use frame_support::storage::bounded_btree_map::BoundedBTreeMap; pub mod eth; /// Maximum number of methods per contract that could have fee limit @@ -31,15 +31,16 @@ #[frame_support::pallet] pub mod pallet { - pub use super::*; + use evm_coder::ToLog; use frame_support::{pallet_prelude::*, sp_runtime::DispatchResult}; - use frame_system::{pallet_prelude::OriginFor, ensure_root}; + use frame_system::{ensure_root, pallet_prelude::*}; + use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; use sp_core::{H160, U256}; use sp_std::vec::Vec; - use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; use up_data_structs::SponsorshipState; - use evm_coder::ToLog; + pub use super::*; + #[pallet::config] pub trait Config: frame_system::Config + pallet_evm_coder_substrate::Config + pallet_evm::Config --- a/pallets/evm-migration/src/benchmarking.rs +++ b/pallets/evm-migration/src/benchmarking.rs @@ -16,11 +16,12 @@ #![allow(missing_docs)] -use super::{Call, Config, Pallet}; use frame_benchmarking::benchmarks; use frame_system::RawOrigin; use sp_core::{H160, H256}; -use sp_std::{vec::Vec, vec}; +use sp_std::{vec, vec::Vec}; + +use super::{Call, Config, Pallet}; benchmarks! { where_clause { where ::RuntimeEvent: parity_scale_codec::Encode } --- a/pallets/evm-migration/src/lib.rs +++ b/pallets/evm-migration/src/lib.rs @@ -26,15 +26,13 @@ #[frame_support::pallet] pub mod pallet { - use frame_support::{ - pallet_prelude::{*, DispatchResult}, - traits::IsType, - }; - use frame_system::pallet_prelude::{*, OriginFor}; + use frame_support::{pallet_prelude::*, traits::IsType}; + use frame_system::pallet_prelude::*; + use pallet_evm::{Pallet as PalletEvm, PrecompileHandle}; use sp_core::{H160, H256}; use sp_std::vec::Vec; + use super::weights::WeightInfo; - use pallet_evm::{PrecompileHandle, Pallet as PalletEvm}; #[pallet::config] pub trait Config: frame_system::Config + pallet_evm::Config { --- a/pallets/evm-transaction-payment/src/lib.rs +++ b/pallets/evm-transaction-payment/src/lib.rs @@ -19,19 +19,26 @@ #![deny(missing_docs)] use core::marker::PhantomData; -use fp_evm::WithdrawReason; -use frame_support::traits::IsSubType; + +use fp_evm::{CheckEvmTransaction, FeeCalculator, TransactionValidationError, WithdrawReason}; +use frame_support::{ + storage::with_transaction, + traits::{Currency, Imbalance, IsSubType, OnUnbalanced}, +}; pub use pallet::*; -use pallet_evm::{account::CrossAccountId, EnsureAddressOrigin}; +use pallet_evm::{ + account::CrossAccountId, EnsureAddressOrigin, NegativeImbalanceOf, OnChargeEVMTransaction, + OnCheckEvmTransaction, +}; use sp_core::{H160, U256}; -use sp_runtime::{TransactionOutcome, DispatchError}; +use sp_runtime::{traits::UniqueSaturatedInto, DispatchError, TransactionOutcome}; use up_sponsorship::SponsorshipHandler; #[frame_support::pallet] pub mod pallet { + use sp_std::vec::Vec; + use super::*; - - use sp_std::vec::Vec; /// Contains call data pub struct CallContext { --- a/pallets/foreign-assets/src/benchmarking.rs +++ b/pallets/foreign-assets/src/benchmarking.rs @@ -16,15 +16,14 @@ #![allow(missing_docs)] -use super::{Config, Pallet, Call}; -use frame_benchmarking::{benchmarks, account}; +use frame_benchmarking::{account, benchmarks}; +use frame_support::traits::Currency; use frame_system::RawOrigin; +use sp_std::{boxed::Box, vec::Vec}; +use staging_xcm::{opaque::latest::Junction::Parachain, v3::Junctions::X1, VersionedMultiLocation}; + +use super::{Call, Config, Pallet}; use crate::AssetMetadata; -use xcm::opaque::latest::Junction::Parachain; -use xcm::VersionedMultiLocation; -use xcm::v3::Junctions::X1; -use frame_support::traits::Currency; -use sp_std::{vec::Vec, boxed::Box}; fn bounded>>(slice: &[u8]) -> T { T::try_from(slice.to_vec()) --- a/pallets/foreign-assets/src/impl_fungibles.rs +++ b/pallets/foreign-assets/src/impl_fungibles.rs @@ -16,18 +16,17 @@ //! Implementations for fungibles trait. -use super::*; -use frame_system::Config as SystemConfig; - use frame_support::traits::tokens::{ - DepositConsequence, WithdrawConsequence, Preservation, Fortitude, Provenance, Precision, + DepositConsequence, Fortitude, Precision, Preservation, Provenance, WithdrawConsequence, }; -use pallet_common::CollectionHandle; +use frame_system::Config as SystemConfig; +use pallet_common::{CollectionHandle, CommonCollectionOperations}; use pallet_fungible::FungibleHandle; -use pallet_common::CommonCollectionOperations; +use sp_runtime::traits::{CheckedAdd, CheckedSub}; use up_data_structs::budget::Value; -use sp_runtime::traits::{CheckedAdd, CheckedSub}; +use super::*; + impl fungibles::Inspect<::AccountId> for Pallet where T: orml_tokens::Config, --- a/pallets/foreign-assets/src/lib.rs +++ b/pallets/foreign-assets/src/lib.rs @@ -39,29 +39,26 @@ ensure, pallet_prelude::*, traits::{fungible, fungibles, Currency, EnsureOrigin}, - RuntimeDebug, }; use frame_system::pallet_prelude::*; -use up_data_structs::CollectionMode; +use pallet_common::erc::CrossAccountId; use pallet_fungible::Pallet as PalletFungible; use scale_info::TypeInfo; +use serde::{Deserialize, Serialize}; use sp_runtime::{ traits::{One, Zero}, ArithmeticError, }; use sp_std::{boxed::Box, vec::Vec}; -use up_data_structs::{CollectionId, TokenId, CreateCollectionData}; - +use staging_xcm::{latest::MultiLocation, VersionedMultiLocation}; // NOTE: MultiLocation is used in storages, we will need to do migration if upgrade the // MultiLocation to the XCM v3. -use xcm::opaque::latest::{prelude::XcmError, Weight}; -use xcm::{latest::MultiLocation, VersionedMultiLocation}; -use xcm_executor::{traits::WeightTrader, Assets}; - -use pallet_common::erc::CrossAccountId; - -#[cfg(feature = "std")] -use serde::{Deserialize, Serialize}; +use staging_xcm::{ + opaque::latest::{prelude::XcmError, Weight}, + v3::XcmContext, +}; +use staging_xcm_executor::{traits::WeightTrader, Assets}; +use up_data_structs::{CollectionId, CollectionMode, CreateCollectionData, TokenId}; // TODO: Move to primitives // Id of native currency. --- a/pallets/fungible/src/benchmarking.rs +++ b/pallets/fungible/src/benchmarking.rs @@ -14,14 +14,13 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use super::*; -use crate::{Pallet, Config, FungibleHandle}; - +use frame_benchmarking::{account, benchmarks}; +use pallet_common::{bench_init, benchmarking::create_collection_raw}; use sp_std::prelude::*; -use pallet_common::benchmarking::create_collection_raw; -use frame_benchmarking::{benchmarks, account}; -use up_data_structs::{CollectionMode, MAX_ITEMS_PER_BATCH, budget::Unlimited}; -use pallet_common::bench_init; +use up_data_structs::{budget::Unlimited, CollectionMode, MAX_ITEMS_PER_BATCH}; + +use super::*; +use crate::{Config, FungibleHandle, Pallet}; const SEED: u32 = 1; --- a/pallets/fungible/src/common.rs +++ b/pallets/fungible/src/common.rs @@ -16,22 +16,24 @@ use core::marker::PhantomData; -use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get}; -use up_data_structs::{ - TokenId, CollectionId, CreateItemExData, budget::Budget, CreateItemData, TokenOwnerError, +use frame_support::{ + dispatch::DispatchResultWithPostInfo, ensure, fail, traits::Get, weights::Weight, }; use pallet_common::{ - CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight, - weights::WeightInfo as _, SelfWeightOf as PalletCommonWeightOf, + weights::WeightInfo as _, with_weight, CommonCollectionOperations, CommonWeightInfo, + RefungibleExtensions, SelfWeightOf as PalletCommonWeightOf, }; use pallet_structure::Error as StructureError; use sp_runtime::{ArithmeticError, DispatchError}; -use sp_std::{vec::Vec, vec}; -use up_data_structs::{Property, PropertyKey, PropertyValue, PropertyKeyPermission}; +use sp_std::{vec, vec::Vec}; +use up_data_structs::{ + budget::Budget, CollectionId, CreateItemData, CreateItemExData, Property, PropertyKey, + PropertyKeyPermission, PropertyValue, TokenId, TokenOwnerError, +}; use crate::{ - Allowance, TotalSupply, Balance, Config, Error, FungibleHandle, Pallet, SelfWeightOf, - weights::WeightInfo, + weights::WeightInfo, Allowance, Balance, Config, Error, FungibleHandle, Pallet, SelfWeightOf, + TotalSupply, }; pub struct CommonWeights(PhantomData); --- a/pallets/fungible/src/erc.rs +++ b/pallets/fungible/src/erc.rs @@ -17,30 +17,31 @@ //! ERC-20 standart support implementation. extern crate alloc; -use core::char::{REPLACEMENT_CHARACTER, decode_utf16}; -use core::convert::TryInto; -use evm_coder::AbiCoder; -use evm_coder::{abi::AbiType, ToLog, generate_stubgen, solidity_interface, types::*}; -use up_data_structs::CollectionMode; +use core::{ + char::{decode_utf16, REPLACEMENT_CHARACTER}, + convert::TryInto, +}; + +use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*, AbiCoder, ToLog}; use pallet_common::{ - CollectionHandle, - erc::{CommonEvmHandler, PrecompileResult, CollectionCall}, + erc::{CollectionCall, CommonEvmHandler, PrecompileResult}, eth::CrossAddress, - CommonWeightInfo as _, + CollectionHandle, CommonWeightInfo as _, }; -use sp_std::vec::Vec; use pallet_evm::{account::CrossAccountId, PrecompileHandle}; use pallet_evm_coder_substrate::{ call, dispatch_to_evm, execution::{PreDispatch, Result}, frontier_contract, }; -use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _}; -use sp_core::{U256, Get}; +use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight}; +use sp_core::{Get, U256}; +use sp_std::vec::Vec; +use up_data_structs::CollectionMode; use crate::{ - Allowance, Balance, Config, FungibleHandle, Pallet, TotalSupply, SelfWeightOf, - weights::WeightInfo, common::CommonWeights, + common::CommonWeights, weights::WeightInfo, Allowance, Balance, Config, FungibleHandle, Pallet, + SelfWeightOf, TotalSupply, }; frontier_contract! { --- a/pallets/fungible/src/lib.rs +++ b/pallets/fungible/src/lib.rs @@ -79,30 +79,26 @@ #![cfg_attr(not(feature = "std"), no_std)] use core::ops::Deref; + use evm_coder::ToLog; -use frame_support::{ - ensure, - pallet_prelude::{DispatchResultWithPostInfo, Pays}, - dispatch::PostDispatchInfo, -}; -use pallet_evm::account::CrossAccountId; -use up_data_structs::{ - AccessMode, CollectionId, TokenId, CreateCollectionData, mapping::TokenAddressMapping, - budget::Budget, PropertyKey, Property, -}; +use frame_support::{dispatch::PostDispatchInfo, ensure, pallet_prelude::*}; +pub use pallet::*; use pallet_common::{ - Error as CommonError, Event as CommonEvent, Pallet as PalletCommon, - eth::collection_id_to_address, SelfWeightOf as PalletCommonWeightOf, - weights::WeightInfo as CommonWeightInfo, helpers::add_weight_to_post_info, + eth::collection_id_to_address, helpers::add_weight_to_post_info, + weights::WeightInfo as CommonWeightInfo, Error as CommonError, Event as CommonEvent, + Pallet as PalletCommon, SelfWeightOf as PalletCommonWeightOf, }; -use pallet_evm::Pallet as PalletEvm; +use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; +use pallet_evm_coder_substrate::WithRecorder; use pallet_structure::Pallet as PalletStructure; -use pallet_evm_coder_substrate::WithRecorder; use sp_core::H160; use sp_runtime::{ArithmeticError, DispatchError, DispatchResult}; use sp_std::{collections::btree_map::BTreeMap, vec::Vec}; +use up_data_structs::{ + budget::Budget, mapping::TokenAddressMapping, AccessMode, CollectionId, CreateCollectionData, + Property, PropertyKey, TokenId, +}; use weights::WeightInfo; -pub use pallet::*; use crate::erc::ERC20Events; #[cfg(feature = "runtime-benchmarks")] @@ -116,8 +112,11 @@ #[frame_support::pallet] pub mod pallet { - use frame_support::{Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key}; + use frame_support::{ + pallet_prelude::*, storage::Key, Blake2_128, Blake2_128Concat, Twox64Concat, + }; use up_data_structs::CollectionId; + use super::weights::WeightInfo; #[pallet::error] --- a/pallets/gov-origins/src/lib.rs +++ b/pallets/gov-origins/src/lib.rs @@ -17,7 +17,6 @@ #![cfg_attr(not(feature = "std"), no_std)] use frame_support::pallet_prelude::*; - pub use pallet::*; #[frame_support::pallet] --- a/pallets/identity/src/benchmarking.rs +++ b/pallets/identity/src/benchmarking.rs @@ -37,17 +37,17 @@ #![cfg(feature = "runtime-benchmarks")] #![allow(clippy::no_effect)] -use super::*; - -use crate::Pallet as Identity; use frame_benchmarking::{account, benchmarks, whitelisted_caller}; use frame_support::{ - ensure, assert_ok, + assert_ok, ensure, traits::{EnsureOrigin, Get}, }; use frame_system::RawOrigin; use sp_runtime::traits::Bounded; +use super::*; +use crate::Pallet as Identity; + const SEED: u32 = 0; fn assert_last_event(generic_event: ::RuntimeEvent) { --- a/pallets/identity/src/lib.rs +++ b/pallets/identity/src/lib.rs @@ -95,21 +95,18 @@ mod types; pub mod weights; -use frame_support::{ - traits::{BalanceStatus, Currency, OnUnbalanced, ReservableCurrency}, -}; +use frame_support::traits::{BalanceStatus, Currency, OnUnbalanced, ReservableCurrency}; +pub use pallet::*; use sp_runtime::{ - BoundedVec, traits::{AppendZerosInput, Hash, Saturating, StaticLookup, Zero}, + BoundedVec, }; use sp_std::prelude::*; -pub use weights::WeightInfo; - -pub use pallet::*; pub use types::{ Data, IdentityField, IdentityFields, IdentityInfo, Judgement, RegistrarIndex, RegistrarInfo, Registration, }; +pub use weights::WeightInfo; pub type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; @@ -132,10 +129,11 @@ #[frame_support::pallet] pub mod pallet { - use super::*; use frame_support::pallet_prelude::*; use frame_system::pallet_prelude::*; + use super::*; + #[pallet::config] pub trait Config: frame_system::Config { /// The overarching event type. --- a/pallets/identity/src/tests.rs +++ b/pallets/identity/src/tests.rs @@ -34,22 +34,23 @@ // Tests for Identity Pallet -use super::*; -use crate as pallet_identity; - -use codec::{Decode, Encode}; use frame_support::{ assert_noop, assert_ok, ord_parameter_types, parameter_types, traits::{ConstU32, ConstU64, EitherOfDiverse}, BoundedVec, }; use frame_system::{EnsureRoot, EnsureSignedBy}; +use parity_scale_codec::{Decode, Encode}; use sp_core::H256; use sp_runtime::{ testing::Header, traits::{BadOrigin, BlakeTwo256, IdentityLookup}, + BuildStorage, }; +use super::*; +use crate as pallet_identity; + type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; type Block = frame_system::mocking::MockBlock; --- a/pallets/identity/src/types.rs +++ b/pallets/identity/src/types.rs @@ -32,13 +32,12 @@ // See the License for the specific language governing permissions and // limitations under the License. -use super::*; -use codec::{Decode, Encode, MaxEncodedLen}; use enumflags2::{bitflags, BitFlags}; use frame_support::{ traits::{ConstU32, Get}, BoundedVec, CloneNoBound, PartialEqNoBound, RuntimeDebugNoBound, }; +use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::{ build::{Fields, Variants}, meta_type, Path, Type, TypeInfo, TypeParameter, @@ -46,6 +45,8 @@ use sp_runtime::{traits::Zero, RuntimeDebug}; use sp_std::{fmt::Debug, iter::once, ops::Add, prelude::*}; +use super::*; + /// Either underlying data blob if it is at most 32 bytes, or a hash of it. If the data is greater /// than 32-bytes then it will be truncated when encoding. /// --- a/pallets/inflation/src/benchmarking.rs +++ b/pallets/inflation/src/benchmarking.rs @@ -16,11 +16,11 @@ #![cfg(feature = "runtime-benchmarks")] +use frame_benchmarking::benchmarks; +use frame_support::traits::OnInitialize; + use super::*; use crate::Pallet as Inflation; - -use frame_benchmarking::{benchmarks}; -use frame_support::traits::OnInitialize; benchmarks! { --- a/pallets/inflation/src/lib.rs +++ b/pallets/inflation/src/lib.rs @@ -37,17 +37,14 @@ #[cfg(test)] mod tests; -use frame_support::{ - dispatch::{DispatchResult}, - traits::{ - fungible::{Balanced, Inspect, Mutate}, - Get, - tokens::Precision, - }, +use frame_support::traits::{ + fungible::{Balanced, Inspect, Mutate}, + tokens::Precision, + Get, }; +use frame_system::pallet_prelude::BlockNumberFor; pub use pallet::*; -use sp_runtime::{Perbill, traits::BlockNumberProvider}; - +use sp_runtime::{traits::BlockNumberProvider, Perbill}; use sp_std::convert::TryInto; type BalanceOf = @@ -61,10 +58,11 @@ #[frame_support::pallet] pub mod pallet { - use super::*; use frame_support::pallet_prelude::*; use frame_system::pallet_prelude::*; + use super::*; + #[pallet::config] pub trait Config: frame_system::Config { type Currency: Balanced --- a/pallets/inflation/src/tests.rs +++ b/pallets/inflation/src/tests.rs @@ -16,14 +16,12 @@ #![cfg(test)] #![allow(clippy::from_over_into)] -use crate as pallet_inflation; - use frame_support::{ assert_ok, parameter_types, traits::{ fungible::{Balanced, Inspect}, - OnInitialize, Everything, ConstU32, tokens::Precision, + ConstU32, Everything, OnInitialize, }, weights::Weight, }; @@ -31,9 +29,11 @@ use sp_core::H256; use sp_runtime::{ traits::{BlakeTwo256, BlockNumberProvider, IdentityLookup}, - testing::Header, + BuildStorage, }; +use crate as pallet_inflation; + type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; type Block = frame_system::mocking::MockBlock; --- a/pallets/maintenance/src/benchmarking.rs +++ b/pallets/maintenance/src/benchmarking.rs @@ -14,13 +14,13 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use super::*; -use crate::{Pallet as Maintenance, Config}; - -use codec::Encode; use frame_benchmarking::benchmarks; +use frame_support::{ensure, pallet_prelude::Weight, traits::StorePreimage}; use frame_system::RawOrigin; -use frame_support::{ensure, pallet_prelude::Weight, traits::StorePreimage}; +use parity_scale_codec::Encode; + +use super::*; +use crate::{Config, Pallet as Maintenance}; benchmarks! { enable { --- a/pallets/maintenance/src/lib.rs +++ b/pallets/maintenance/src/lib.rs @@ -26,10 +26,14 @@ #[frame_support::pallet] pub mod pallet { - use frame_support::{dispatch::*, pallet_prelude::*}; - use frame_support::traits::{QueryPreimage, StorePreimage, EnsureOrigin}; + use frame_support::{ + dispatch::*, + pallet_prelude::*, + traits::{EnsureOrigin, QueryPreimage, StorePreimage}, + }; use frame_system::pallet_prelude::*; use sp_core::H256; + use sp_runtime::traits::Dispatchable; use crate::weights::WeightInfo; @@ -111,7 +115,7 @@ hash: H256, weight_bound: Weight, ) -> DispatchResultWithPostInfo { - use codec::Decode; + use parity_scale_codec::Decode; T::PreimageOrigin::ensure_origin(origin.clone())?; --- a/pallets/nonfungible/src/benchmarking.rs +++ b/pallets/nonfungible/src/benchmarking.rs @@ -14,10 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use super::*; -use crate::{Pallet, Config, NonfungibleHandle}; - -use frame_benchmarking::{benchmarks, account}; +use frame_benchmarking::{account, benchmarks}; use pallet_common::{ bench_init, benchmarking::{ @@ -27,10 +24,13 @@ }; use sp_std::prelude::*; use up_data_structs::{ - CollectionMode, MAX_ITEMS_PER_BATCH, MAX_PROPERTIES_PER_ITEM, budget::Unlimited, - PropertyPermission, + budget::Unlimited, CollectionMode, PropertyPermission, MAX_ITEMS_PER_BATCH, + MAX_PROPERTIES_PER_ITEM, }; +use super::*; +use crate::{Config, NonfungibleHandle, Pallet}; + const SEED: u32 = 1; fn create_max_item_data(owner: T::CrossAccountId) -> CreateItemData { --- a/pallets/nonfungible/src/common.rs +++ b/pallets/nonfungible/src/common.rs @@ -17,21 +17,21 @@ use core::marker::PhantomData; use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight}; -use up_data_structs::{ - TokenId, CreateItemExData, CollectionId, budget::Budget, Property, PropertyKey, - PropertyKeyPermission, PropertyValue, TokenOwnerError, -}; use pallet_common::{ - CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight, - weights::WeightInfo as _, SelfWeightOf as PalletCommonWeightOf, init_token_properties_delta, + init_token_properties_delta, weights::WeightInfo as _, with_weight, CommonCollectionOperations, + CommonWeightInfo, RefungibleExtensions, SelfWeightOf as PalletCommonWeightOf, }; use pallet_structure::Pallet as PalletStructure; use sp_runtime::DispatchError; -use sp_std::{vec::Vec, vec}; +use sp_std::{vec, vec::Vec}; +use up_data_structs::{ + budget::Budget, CollectionId, CreateItemExData, Property, PropertyKey, PropertyKeyPermission, + PropertyValue, TokenId, TokenOwnerError, +}; use crate::{ - AccountBalance, Allowance, Config, CreateItemData, Error, NonfungibleHandle, Owned, Pallet, - SelfWeightOf, TokenData, weights::WeightInfo, TokensMinted, TokenProperties, + weights::WeightInfo, AccountBalance, Allowance, Config, CreateItemData, Error, + NonfungibleHandle, Owned, Pallet, SelfWeightOf, TokenData, TokenProperties, TokensMinted, }; pub struct CommonWeights(PhantomData); --- a/pallets/nonfungible/src/erc.rs +++ b/pallets/nonfungible/src/erc.rs @@ -23,34 +23,34 @@ use alloc::string::ToString; use core::{ - char::{REPLACEMENT_CHARACTER, decode_utf16}, + char::{decode_utf16, REPLACEMENT_CHARACTER}, convert::TryInto, }; -use evm_coder::{abi::AbiType, AbiCoder, ToLog, generate_stubgen, solidity_interface, types::*}; + +use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*, AbiCoder, ToLog}; use frame_support::BoundedVec; -use up_data_structs::{ - TokenId, PropertyPermission, PropertyKeyPermission, Property, CollectionId, PropertyKey, - CollectionPropertiesVec, +use pallet_common::{ + erc::{static_property::key, CollectionCall, CommonEvmHandler, PrecompileResult}, + eth::{self, TokenUri}, + CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations, CommonWeightInfo, }; +use pallet_evm::{account::CrossAccountId, PrecompileHandle}; use pallet_evm_coder_substrate::{ - dispatch_to_evm, frontier_contract, - execution::{Result, PreDispatch, Error}, + call, dispatch_to_evm, + execution::{Error, PreDispatch, Result}, + frontier_contract, }; -use sp_std::{vec::Vec, vec}; -use pallet_common::{ - CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations, - erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key}, - eth::{self, TokenUri}, - CommonWeightInfo, +use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight}; +use sp_core::{Get, U256}; +use sp_std::{vec, vec::Vec}; +use up_data_structs::{ + CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission, + PropertyPermission, TokenId, }; -use pallet_evm::{account::CrossAccountId, PrecompileHandle}; -use pallet_evm_coder_substrate::call; -use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _}; -use sp_core::{U256, Get}; use crate::{ - AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted, - TokenProperties, SelfWeightOf, weights::WeightInfo, common::CommonWeights, + common::CommonWeights, weights::WeightInfo, AccountBalance, Config, CreateItemData, + NonfungibleHandle, Pallet, SelfWeightOf, TokenData, TokenProperties, TokensMinted, }; /// Nft events. --- a/pallets/refungible/src/benchmarking.rs +++ b/pallets/refungible/src/benchmarking.rs @@ -14,12 +14,9 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use super::*; -use crate::{Pallet, Config, RefungibleHandle}; +use core::{convert::TryInto, iter::IntoIterator}; -use core::convert::TryInto; -use core::iter::IntoIterator; -use frame_benchmarking::{benchmarks, account}; +use frame_benchmarking::{account, benchmarks}; use pallet_common::{ bench_init, benchmarking::{ @@ -28,10 +25,13 @@ }; use sp_std::prelude::*; use up_data_structs::{ - CollectionMode, MAX_ITEMS_PER_BATCH, MAX_PROPERTIES_PER_ITEM, budget::Unlimited, - PropertyPermission, + budget::Unlimited, CollectionMode, PropertyPermission, MAX_ITEMS_PER_BATCH, + MAX_PROPERTIES_PER_ITEM, }; +use super::*; +use crate::{Config, Pallet, RefungibleHandle}; + const SEED: u32 = 1; fn create_max_item_data( --- a/pallets/refungible/src/common.rs +++ b/pallets/refungible/src/common.rs @@ -16,24 +16,25 @@ use core::marker::PhantomData; -use sp_std::collections::btree_map::BTreeMap; -use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight, traits::Get}; -use up_data_structs::{ - CollectionId, TokenId, CreateItemExData, budget::Budget, Property, PropertyKey, PropertyValue, - PropertyKeyPermission, CreateRefungibleExMultipleOwners, CreateRefungibleExSingleOwner, - TokenOwnerError, +use frame_support::{ + dispatch::DispatchResultWithPostInfo, ensure, fail, traits::Get, weights::Weight, }; use pallet_common::{ - CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions, with_weight, - weights::WeightInfo as _, init_token_properties_delta, + init_token_properties_delta, weights::WeightInfo as _, with_weight, CommonCollectionOperations, + CommonWeightInfo, RefungibleExtensions, }; -use pallet_structure::{Pallet as PalletStructure, Error as StructureError}; -use sp_runtime::{DispatchError}; -use sp_std::{vec::Vec, vec}; +use pallet_structure::{Error as StructureError, Pallet as PalletStructure}; +use sp_runtime::DispatchError; +use sp_std::{collections::btree_map::BTreeMap, vec, vec::Vec}; +use up_data_structs::{ + budget::Budget, CollectionId, CreateItemExData, CreateRefungibleExMultipleOwners, + CreateRefungibleExSingleOwner, Property, PropertyKey, PropertyKeyPermission, PropertyValue, + TokenId, TokenOwnerError, +}; use crate::{ - AccountBalance, Allowance, Balance, Config, Error, Owned, Pallet, RefungibleHandle, - SelfWeightOf, weights::WeightInfo, TokensMinted, TotalSupply, CreateItemData, TokenProperties, + weights::WeightInfo, AccountBalance, Allowance, Balance, Config, CreateItemData, Error, Owned, + Pallet, RefungibleHandle, SelfWeightOf, TokenProperties, TokensMinted, TotalSupply, }; macro_rules! max_weight_of { --- a/pallets/refungible/src/erc.rs +++ b/pallets/refungible/src/erc.rs @@ -23,34 +23,35 @@ use alloc::string::ToString; use core::{ - char::{REPLACEMENT_CHARACTER, decode_utf16}, + char::{decode_utf16, REPLACEMENT_CHARACTER}, convert::TryInto, }; -use evm_coder::{abi::AbiType, AbiCoder, ToLog, generate_stubgen, solidity_interface, types::*}; + +use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*, AbiCoder, ToLog}; use frame_support::{BoundedBTreeMap, BoundedVec}; use pallet_common::{ + erc::{static_property::key, CollectionCall, CommonEvmHandler}, + eth::{self, TokenUri}, CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations, Error as CommonError, - erc::{CommonEvmHandler, CollectionCall, static_property::key}, - eth::{self, TokenUri}, }; use pallet_evm::{account::CrossAccountId, PrecompileHandle}; use pallet_evm_coder_substrate::{ call, dispatch_to_evm, - execution::{PreDispatch, Result, Error}, + execution::{Error, PreDispatch, Result}, frontier_contract, }; -use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _}; -use sp_core::{H160, U256, Get}; -use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec}; +use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight}; +use sp_core::{Get, H160, U256}; +use sp_std::{collections::btree_map::BTreeMap, vec, vec::Vec}; use up_data_structs::{ - CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey, + mapping::TokenAddressMapping, CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission, PropertyPermission, TokenId, TokenOwnerError, }; use crate::{ - AccountBalance, Balance, Config, CreateItemData, Pallet, RefungibleHandle, TokenProperties, - TokensMinted, TotalSupply, SelfWeightOf, weights::WeightInfo, + weights::WeightInfo, AccountBalance, Balance, Config, CreateItemData, Pallet, RefungibleHandle, + SelfWeightOf, TokenProperties, TokensMinted, TotalSupply, }; frontier_contract! { --- a/pallets/refungible/src/erc_token.rs +++ b/pallets/refungible/src/erc_token.rs @@ -20,11 +20,12 @@ //! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods. use core::{ - char::{REPLACEMENT_CHARACTER, decode_utf16}, + char::{decode_utf16, REPLACEMENT_CHARACTER}, convert::TryInto, ops::Deref, }; -use evm_coder::{abi::AbiType, ToLog, generate_stubgen, solidity_interface, types::*}; + +use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*, ToLog}; use pallet_common::{ erc::{CommonEvmHandler, PrecompileResult}, eth::{collection_id_to_address, CrossAddress}, @@ -32,17 +33,18 @@ }; use pallet_evm::{account::CrossAccountId, PrecompileHandle}; use pallet_evm_coder_substrate::{ - call, dispatch_to_evm, WithRecorder, frontier_contract, - execution::{Result, PreDispatch}, + call, dispatch_to_evm, + execution::{PreDispatch, Result}, + frontier_contract, WithRecorder, }; -use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _}; -use sp_std::vec::Vec; +use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight}; use sp_core::U256; +use sp_std::vec::Vec; use up_data_structs::TokenId; use crate::{ - Allowance, Balance, Config, Pallet, RefungibleHandle, TotalSupply, common::CommonWeights, - SelfWeightOf, weights::WeightInfo, + common::CommonWeights, weights::WeightInfo, Allowance, Balance, Config, Pallet, + RefungibleHandle, SelfWeightOf, TotalSupply, }; /// Refungible token handle contains information about token's collection and id --- a/pallets/refungible/src/lib.rs +++ b/pallets/refungible/src/lib.rs @@ -87,30 +87,29 @@ #![cfg_attr(not(feature = "std"), no_std)] -use crate::erc_token::ERC20Events; -use crate::erc::ERC721Events; +use core::{cmp::Ordering, ops::Deref}; -use core::{ops::Deref, cmp::Ordering}; use evm_coder::ToLog; use frame_support::{ensure, storage::with_transaction, transactional}; -use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; -use pallet_evm_coder_substrate::WithRecorder; +pub use pallet::*; use pallet_common::{ - Error as CommonError, eth::collection_id_to_address, Event as CommonEvent, + eth::collection_id_to_address, Error as CommonError, Event as CommonEvent, Pallet as PalletCommon, }; +use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; +use pallet_evm_coder_substrate::WithRecorder; use pallet_structure::Pallet as PalletStructure; use sp_core::{Get, H160}; use sp_runtime::{ArithmeticError, DispatchError, DispatchResult, TransactionOutcome}; -use sp_std::{vec::Vec, vec, collections::btree_map::BTreeMap}; +use sp_std::{collections::btree_map::BTreeMap, vec, vec::Vec}; use up_data_structs::{ - AccessMode, budget::Budget, CollectionId, CreateCollectionData, mapping::TokenAddressMapping, - MAX_REFUNGIBLE_PIECES, Property, PropertyKey, PropertyKeyPermission, PropertyScope, - PropertyValue, TokenId, PropertiesPermissionMap, CreateRefungibleExMultipleOwners, - TokenOwnerError, TokenProperties as TokenPropertiesT, + budget::Budget, mapping::TokenAddressMapping, AccessMode, CollectionId, CreateCollectionData, + CreateRefungibleExMultipleOwners, PropertiesPermissionMap, Property, PropertyKey, + PropertyKeyPermission, PropertyScope, PropertyValue, TokenId, TokenOwnerError, + TokenProperties as TokenPropertiesT, TrySetProperty, MAX_REFUNGIBLE_PIECES, }; -pub use pallet::*; +use crate::{erc::ERC721Events, erc_token::ERC20Events}; #[cfg(feature = "runtime-benchmarks")] pub mod benchmarking; pub mod common; @@ -124,14 +123,14 @@ #[frame_support::pallet] pub mod pallet { - use super::*; use frame_support::{ - Blake2_128, Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, - traits::StorageVersion, + pallet_prelude::*, storage::Key, traits::StorageVersion, Blake2_128, Blake2_128Concat, + Twox64Concat, }; use up_data_structs::{CollectionId, TokenId}; - use super::weights::WeightInfo; + use super::{weights::WeightInfo, *}; + #[pallet::error] pub enum Error { /// Not Refungible item data used to mint in Refungible collection. --- a/pallets/structure/src/benchmarking.rs +++ b/pallets/structure/src/benchmarking.rs @@ -14,16 +14,16 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use super::*; - -use frame_benchmarking::{benchmarks, account}; -use frame_support::traits::{fungible::Balanced, Get, tokens::Precision}; +use frame_benchmarking::{account, benchmarks}; +use frame_support::traits::{fungible::Balanced, tokens::Precision, Get}; +use pallet_common::Config as CommonConfig; +use pallet_evm::account::CrossAccountId; use up_data_structs::{ - CreateCollectionData, CollectionMode, CreateItemData, CreateNftData, budget::Unlimited, + budget::Unlimited, CollectionMode, CreateCollectionData, CreateItemData, CreateNftData, }; -use pallet_common::Config as CommonConfig; -use pallet_evm::account::CrossAccountId; +use super::*; + const SEED: u32 = 1; benchmarks! { --- a/pallets/structure/src/lib.rs +++ b/pallets/structure/src/lib.rs @@ -53,29 +53,31 @@ #![cfg_attr(not(feature = "std"), no_std)] -use pallet_common::CommonCollectionOperations; -use pallet_common::{erc::CrossAccountId, eth::is_collection}; +use frame_support::{ + dispatch::{DispatchResult, DispatchResultWithPostInfo}, + fail, + pallet_prelude::*, +}; +use pallet_common::{ + dispatch::CollectionDispatch, erc::CrossAccountId, eth::is_collection, + CommonCollectionOperations, +}; use sp_std::collections::btree_set::BTreeSet; - -use frame_support::dispatch::{DispatchError, DispatchResult, DispatchResultWithPostInfo}; -use frame_support::fail; -pub use pallet::*; -use pallet_common::{dispatch::CollectionDispatch}; use up_data_structs::{ - CollectionId, TokenId, mapping::TokenAddressMapping, budget::Budget, TokenOwnerError, + budget::Budget, mapping::TokenAddressMapping, CollectionId, TokenId, TokenOwnerError, }; #[cfg(feature = "runtime-benchmarks")] pub mod benchmarking; pub mod weights; +pub use pallet::*; + pub type SelfWeightOf = ::WeightInfo; #[frame_support::pallet] pub mod pallet { - use frame_support::Parameter; - use frame_support::dispatch::{GetDispatchInfo, UnfilteredDispatchable}; - use frame_support::pallet_prelude::*; + use frame_support::{dispatch::GetDispatchInfo, traits::UnfilteredDispatchable, Parameter}; use super::*; --- a/pallets/unique/src/benchmarking.rs +++ b/pallets/unique/src/benchmarking.rs @@ -16,22 +16,23 @@ #![cfg(feature = "runtime-benchmarks")] -use super::*; -use crate::Pallet; +use frame_benchmarking::{account, benchmarks}; +use frame_support::traits::{fungible::Balanced, tokens::Precision, Get}; use frame_system::RawOrigin; -use frame_support::traits::{fungible::Balanced, Get, tokens::Precision}; -use frame_benchmarking::{benchmarks, account}; -use sp_runtime::DispatchError; use pallet_common::{ - Config as CommonConfig, benchmarking::{create_data, create_u16_data}, + erc::CrossAccountId, + Config as CommonConfig, }; +use sp_runtime::DispatchError; use up_data_structs::{ - CollectionId, CollectionMode, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH, - MAX_COLLECTION_DESCRIPTION_LENGTH, CollectionLimits, + CollectionId, CollectionLimits, CollectionMode, MAX_COLLECTION_DESCRIPTION_LENGTH, + MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH, }; -use pallet_common::erc::CrossAccountId; +use super::*; +use crate::Pallet; + const SEED: u32 = 1; fn create_collection_helper( --- a/pallets/unique/src/eth/mod.rs +++ b/pallets/unique/src/eth/mod.rs @@ -16,32 +16,31 @@ //! Implementation of CollectionHelpers contract. //! +use alloc::{collections::BTreeSet, format}; use core::marker::PhantomData; + use ethereum as _; use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*}; -use frame_support::{BoundedVec, traits::Get}; +use frame_support::{traits::Get, BoundedVec}; use pallet_common::{ - CollectionById, dispatch::CollectionDispatch, - erc::{CollectionHelpersEvents, static_property::key}, - eth::{self, map_eth_to_id, collection_id_to_address}, - Pallet as PalletCommon, CollectionHandle, + erc::{static_property::key, CollectionHelpersEvents}, + eth::{self, collection_id_to_address, map_eth_to_id}, + CollectionById, CollectionHandle, Pallet as PalletCommon, }; use pallet_evm::{account::CrossAccountId, OnMethodCall, PrecompileHandle, PrecompileResult}; use pallet_evm_coder_substrate::{ - dispatch_to_evm, SubstrateRecorder, WithRecorder, - execution::{PreDispatch, Result, Error}, - frontier_contract, + dispatch_to_evm, + execution::{Error, PreDispatch, Result}, + frontier_contract, SubstrateRecorder, WithRecorder, }; +use sp_std::vec::Vec; use up_data_structs::{ CollectionDescription, CollectionMode, CollectionName, CollectionPermissions, CollectionTokenPrefix, CreateCollectionData, NestingPermissions, }; use crate::{weights::WeightInfo, Config, Pallet, SelfWeightOf}; - -use alloc::{format, collections::BTreeSet}; -use sp_std::vec::Vec; frontier_contract! { macro_rules! EvmCollectionHelpers_result {...} --- a/pallets/unique/src/lib.rs +++ b/pallets/unique/src/lib.rs @@ -73,9 +73,9 @@ extern crate alloc; -pub use pallet::*; use frame_support::pallet_prelude::*; use frame_system::pallet_prelude::*; +pub use pallet::*; pub mod eth; #[cfg(feature = "runtime-benchmarks")] @@ -84,27 +84,27 @@ #[frame_support::pallet] pub mod pallet { - use super::*; - - use frame_support::{dispatch::DispatchResult, ensure, fail, BoundedVec, storage::Key}; + use frame_support::{dispatch::DispatchResult, ensure, fail, storage::Key, BoundedVec}; + use frame_system::{ensure_root, ensure_signed}; + use pallet_common::{ + dispatch::{dispatch_tx, CollectionDispatch}, + CollectionHandle, CommonWeightInfo, Pallet as PalletCommon, RefungibleExtensionsWeightInfo, + }; + use pallet_evm::account::CrossAccountId; use scale_info::TypeInfo; - use frame_system::{ensure_signed, ensure_root}; use sp_std::{vec, vec::Vec}; use up_data_structs::{ - MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH, - MAX_PROPERTIES_PER_ITEM, MAX_PROPERTY_KEY_LENGTH, MAX_PROPERTY_VALUE_LENGTH, - MAX_COLLECTION_PROPERTIES_SIZE, COLLECTION_ADMINS_LIMIT, MAX_TOKEN_PROPERTIES_SIZE, - CreateItemData, CollectionLimits, CollectionPermissions, CollectionId, CollectionMode, - TokenId, CreateCollectionData, CreateItemExData, budget, Property, PropertyKey, - PropertyKeyPermission, - }; - use pallet_evm::account::CrossAccountId; - use pallet_common::{ - CollectionHandle, Pallet as PalletCommon, CommonWeightInfo, dispatch::dispatch_tx, - dispatch::CollectionDispatch, RefungibleExtensionsWeightInfo, + budget, CollectionId, CollectionLimits, CollectionMode, CollectionPermissions, + CreateCollectionData, CreateItemData, CreateItemExData, Property, PropertyKey, + PropertyKeyPermission, TokenId, COLLECTION_ADMINS_LIMIT, MAX_COLLECTION_DESCRIPTION_LENGTH, + MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_PROPERTIES_SIZE, MAX_PROPERTIES_PER_ITEM, + MAX_PROPERTY_KEY_LENGTH, MAX_PROPERTY_VALUE_LENGTH, MAX_TOKEN_PREFIX_LENGTH, + MAX_TOKEN_PROPERTIES_SIZE, }; use weights::WeightInfo; + use super::*; + /// A maximum number of levels of depth in the token nesting tree. pub const NESTING_BUDGET: u32 = 5; --- a/primitives/app_promotion_rpc/src/lib.rs +++ b/primitives/app_promotion_rpc/src/lib.rs @@ -16,12 +16,12 @@ #![cfg_attr(not(feature = "std"), no_std)] -use sp_std::vec::Vec; -use codec::Decode; +use parity_scale_codec::Decode; use sp_runtime::{ + traits::{AtLeast32BitUnsigned, Member}, DispatchError, - traits::{AtLeast32BitUnsigned, Member}, }; +use sp_std::vec::Vec; type Result = core::result::Result; --- a/primitives/common/src/constants.rs +++ b/primitives/common/src/constants.rs @@ -14,13 +14,14 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use sp_runtime::Perbill; +use cumulus_primitives_core::relay_chain::MAX_POV_SIZE; use frame_support::{ parameter_types, - weights::{Weight, constants::WEIGHT_REF_TIME_PER_SECOND}, + weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight}, }; -use cumulus_primitives_core::relay_chain::MAX_POV_SIZE; -use crate::types::{BlockNumber, Balance}; +use sp_runtime::Perbill; + +use crate::types::{Balance, BlockNumber}; pub const MILLISECS_PER_BLOCK: u64 = 12000; pub const MILLISECS_PER_RELAY_BLOCK: u64 = 6000; --- a/primitives/common/src/types.rs +++ b/primitives/common/src/types.rs @@ -16,7 +16,7 @@ use sp_runtime::{ generic, - traits::{Verify, IdentifyAccount}, + traits::{IdentifyAccount, Verify}, MultiSignature, }; @@ -27,7 +27,7 @@ pub mod opaque { pub use sp_runtime::{generic, traits::BlakeTwo256, OpaqueExtrinsic as UncheckedExtrinsic}; - pub use super::{BlockNumber, Signature, AccountId, Balance, Index, Hash, AuraId}; + pub use super::{AccountId, AuraId, Balance, BlockNumber, Hash, Signature}; #[derive(Debug, Clone)] pub enum RuntimeId { --- a/primitives/data-structs/src/bounded.rs +++ b/primitives/data-structs/src/bounded.rs @@ -17,13 +17,15 @@ //! This module contins implementations for support bounded structures ([`BoundedVec`], [`BoundedBTreeMap`], [`BoundedBTreeSet`]) in [`serde`]. use core::fmt; -use sp_std::collections::{btree_map::BTreeMap, btree_set::BTreeSet}; -use sp_std::vec::Vec; use frame_support::{ + storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet}, BoundedVec, - storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet}, }; +use sp_std::{ + collections::{btree_map::BTreeMap, btree_set::BTreeSet}, + vec::Vec, +}; /// [`serde`] implementations for [`BoundedVec`]. pub mod vec_serde { --- a/primitives/data-structs/src/lib.rs +++ b/primitives/data-structs/src/lib.rs @@ -25,20 +25,21 @@ fmt, ops::Deref, }; -use frame_support::storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet}; -#[cfg(feature = "serde")] -use serde::{Serialize, Deserialize}; - -use sp_core::U256; -use sp_runtime::{ArithmeticError, sp_std::prelude::Vec}; -use sp_std::collections::btree_set::BTreeSet; -use codec::{Decode, Encode, EncodeLike, MaxEncodedLen}; -use frame_support::{BoundedVec, traits::ConstU32}; +use bondrewd::Bitfields; use derivative::Derivative; -use scale_info::TypeInfo; use evm_coder::AbiCoderFlags; -use bondrewd::Bitfields; +use frame_support::{ + storage::{bounded_btree_map::BoundedBTreeMap, bounded_btree_set::BoundedBTreeSet}, + traits::ConstU32, + BoundedVec, +}; +use parity_scale_codec::{Decode, Encode, EncodeLike, MaxEncodedLen}; +use scale_info::TypeInfo; +use serde::{Deserialize, Serialize}; +use sp_core::U256; +use sp_runtime::{sp_std::prelude::Vec, ArithmeticError}; +use sp_std::collections::btree_set::BTreeSet; mod bondrewd_codec; mod bounded; --- a/primitives/data-structs/src/mapping.rs +++ b/primitives/data-structs/src/mapping.rs @@ -18,10 +18,10 @@ use core::marker::PhantomData; +use pallet_evm::account::CrossAccountId; use sp_core::H160; use crate::{CollectionId, TokenId}; -use pallet_evm::account::CrossAccountId; /// Trait for mapping between token id and some `Address`. pub trait TokenAddressMapping
{ --- a/primitives/data-structs/src/migration.rs +++ b/primitives/data-structs/src/migration.rs @@ -17,8 +17,9 @@ /// Storage migration is not required for this change, as SponsoringRateLimit has same encoding as Option #[test] fn sponsoring_rate_limit_has_same_encoding_as_option_u32() { + use parity_scale_codec::Encode; + use crate::SponsoringRateLimit; - use codec::Encode; fn limit_to_option(limit: SponsoringRateLimit) -> Option { match limit { @@ -41,8 +42,9 @@ #[test] fn collection_flags_have_same_encoding_as_bool() { + use parity_scale_codec::Encode; + use crate::CollectionFlags; - use codec::Encode; assert_eq!( true.encode(), --- a/primitives/pov-estimate-rpc/src/lib.rs +++ b/primitives/pov-estimate-rpc/src/lib.rs @@ -17,12 +17,10 @@ #![cfg_attr(not(feature = "std"), no_std)] use scale_info::TypeInfo; -use sp_std::vec::Vec; - #[cfg(feature = "std")] use serde::Serialize; - use sp_runtime::ApplyExtrinsicResult; +use sp_std::vec::Vec; #[cfg_attr(feature = "std", derive(Serialize))] #[derive(Debug, TypeInfo)] --- a/primitives/rpc/src/lib.rs +++ b/primitives/rpc/src/lib.rs @@ -18,14 +18,13 @@ extern crate alloc; +use parity_scale_codec::Decode; +use sp_runtime::DispatchError; +use sp_std::vec::Vec; use up_data_structs::{ - CollectionId, TokenId, RawEncoded, RpcCollection, CollectionStats, CollectionLimits, Property, - PropertyKeyPermission, TokenData, TokenChild, TokenDataVersion1, + CollectionId, CollectionLimits, CollectionStats, Property, PropertyKeyPermission, + RpcCollection, TokenChild, TokenData, TokenId, }; - -use sp_std::vec::Vec; -use codec::Decode; -use sp_runtime::DispatchError; type Result = core::result::Result; --- a/runtime/common/config/ethereum.rs +++ b/runtime/common/config/ethereum.rs @@ -1,22 +1,24 @@ -use sp_core::{U256, H160}; use frame_support::{ - weights::{Weight, constants::WEIGHT_REF_TIME_PER_SECOND}, - traits::{FindAuthor}, - parameter_types, ConsensusEngineId, + parameter_types, + traits::FindAuthor, + weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight}, + ConsensusEngineId, }; -use sp_runtime::{RuntimeAppPublic, Perbill, traits::ConstU32}; +use pallet_ethereum::PostLogContent; +use pallet_evm::{EnsureAddressTruncated, HashedAddressMapping}; +use sp_core::{H160, U256}; +use sp_runtime::{traits::ConstU32, Perbill, RuntimeAppPublic}; +use up_common::constants::*; + use crate::{ runtime_common::{ config::sponsoring::DefaultSponsoringRateLimit, - DealWithFees, dispatch::CollectionDispatchT, ethereum::{precompiles::UniquePrecompiles, sponsoring::EvmSponsorshipHandler}, + DealWithFees, }, - Runtime, Aura, Balances, RuntimeEvent, ChainId, + Aura, Balances, ChainId, Runtime, RuntimeEvent, }; -use pallet_evm::{EnsureAddressTruncated, HashedAddressMapping}; -use pallet_ethereum::PostLogContent; -use up_common::constants::*; pub type CrossAccountId = pallet_evm::account::BasicCrossAccountId; --- a/runtime/common/config/governance/fellowship.rs +++ b/runtime/common/config/governance/fellowship.rs @@ -1,8 +1,11 @@ -use crate::{Preimage, Treasury, RuntimeCall, RuntimeEvent, Scheduler, FellowshipReferenda, Runtime}; -use super::*; use pallet_gov_origins::Origin as GovOrigins; use pallet_ranked_collective::{Config as RankedConfig, Rank, TallyOf}; +use super::*; +use crate::{ + FellowshipReferenda, Preimage, Runtime, RuntimeCall, RuntimeEvent, Scheduler, Treasury, +}; + pub const FELLOWSHIP_MODULE_ID: PalletId = PalletId(*b"flowship"); pub const DEMOCRACY_TRACK_ID: u16 = 10; --- a/runtime/common/config/governance/mod.rs +++ b/runtime/common/config/governance/mod.rs @@ -15,29 +15,31 @@ // along with Unique Network. If not, see . use frame_support::{ - PalletId, parameter_types, + pallet_prelude::*, + parameter_types, traits::{ - EnsureOrigin, EqualPrivilegeOnly, EitherOfDiverse, EitherOf, MapSuccess, ConstU16, Polling, + ConstU16, EitherOf, EitherOfDiverse, EnsureOrigin, EqualPrivilegeOnly, MapSuccess, Polling, }, weights::Weight, - pallet_prelude::*, + PalletId, }; -use frame_system::{EnsureRoot, EnsureNever}; +use frame_system::{EnsureNever, EnsureRoot}; +use pallet_collective::EnsureProportionAtLeast; use sp_runtime::{ + morph_types, + traits::{AccountIdConversion, CheckedSub, ConstU32, Convert, Replace}, Perbill, - traits::{AccountIdConversion, ConstU32, Replace, CheckedSub, Convert}, - morph_types, }; -use crate::{ - Runtime, RuntimeOrigin, RuntimeEvent, RuntimeCall, OriginCaller, Preimage, Balances, Treasury, - Scheduler, Council, TechnicalCommittee, -}; pub use up_common::{ - constants::{UNIQUE, DAYS, HOURS, MINUTES, CENTIUNIQUE}, + constants::{CENTIUNIQUE, DAYS, HOURS, MINUTES, UNIQUE}, types::{AccountId, Balance, BlockNumber}, }; -use pallet_collective::EnsureProportionAtLeast; +use crate::{ + Balances, Council, OriginCaller, Preimage, Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin, + Scheduler, TechnicalCommittee, Treasury, +}; + pub mod council; pub use council::*; --- a/runtime/common/config/orml.rs +++ b/runtime/common/config/orml.rs @@ -20,26 +20,26 @@ }; use frame_system::EnsureSigned; use orml_traits::{location::AbsoluteReserveProvider, parameter_type_with_key}; +use pallet_foreign_assets::{CurrencyId, NativeCurrency}; use sp_runtime::traits::Convert; -use xcm::latest::{Weight, Junction::*, Junctions::*, MultiLocation}; -use xcm_executor::XcmExecutor; use sp_std::{vec, vec::Vec}; -use pallet_foreign_assets::{CurrencyId, NativeCurrency}; +use staging_xcm::latest::{Junction::*, Junctions::*, MultiLocation, Weight}; +use staging_xcm_executor::XcmExecutor; +use up_common::{ + constants::*, + types::{AccountId, Balance}, +}; + use crate::{ - Runtime, RuntimeEvent, RelayChainBlockNumberProvider, runtime_common::config::{ + pallets::TreasuryAccountId, + substrate::{MaxLocks, MaxReserves}, xcm::{ - SelfLocation, Weigher, XcmExecutorConfig, UniversalLocation, - xcm_assets::{CurrencyIdConvert}, + xcm_assets::CurrencyIdConvert, SelfLocation, UniversalLocation, Weigher, + XcmExecutorConfig, }, - pallets::TreasuryAccountId, - substrate::{MaxLocks, MaxReserves}, }, -}; - -use up_common::{ - types::{AccountId, Balance}, - constants::*, + RelayChainBlockNumberProvider, Runtime, RuntimeEvent, }; // Signed version of balance --- a/runtime/common/config/pallets/app_promotion.rs +++ b/runtime/common/config/pallets/app_promotion.rs @@ -14,18 +14,18 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use crate::{ - runtime_common::config::pallets::{TreasuryAccountId, RelayChainBlockNumberProvider}, - Runtime, Balances, BlockNumber, Unique, RuntimeEvent, EvmContractHelpers, Maintenance, -}; - use frame_support::{parameter_types, PalletId}; use sp_arithmetic::Perbill; use up_common::{ - constants::{UNIQUE, DAYS, RELAY_DAYS}, + constants::{DAYS, RELAY_DAYS, UNIQUE}, types::Balance, }; +use crate::{ + runtime_common::config::pallets::{RelayChainBlockNumberProvider, TreasuryAccountId}, + Balances, BlockNumber, EvmContractHelpers, Maintenance, Runtime, RuntimeEvent, Unique, +}; + parameter_types! { pub const AppPromotionId: PalletId = PalletId(*b"appstake"); pub const RecalculationInterval: BlockNumber = RELAY_DAYS; --- a/runtime/common/config/pallets/collator_selection.rs +++ b/runtime/common/config/pallets/collator_selection.rs @@ -15,23 +15,21 @@ // along with Unique Network. If not, see . use frame_support::{parameter_types, PalletId}; -use crate::{ - Balance, Balances, BlockNumber, Runtime, RuntimeEvent, Aura, Session, SessionKeys, - CollatorSelection, Treasury, - config::pallets::{MaxCollators, SessionPeriod, TreasuryAccountId}, +#[cfg(not(feature = "governance"))] +use frame_system::EnsureRoot; +use pallet_configuration::{ + CollatorSelectionDesiredCollatorsOverride, CollatorSelectionKickThresholdOverride, + CollatorSelectionLicenseBondOverride, }; +use sp_runtime::Perbill; +use up_common::constants::{MILLIUNIQUE, UNIQUE}; #[cfg(feature = "governance")] use crate::config::governance; - -#[cfg(not(feature = "governance"))] -use frame_system::EnsureRoot; - -use sp_runtime::Perbill; -use up_common::constants::{UNIQUE, MILLIUNIQUE}; -use pallet_configuration::{ - CollatorSelectionKickThresholdOverride, CollatorSelectionLicenseBondOverride, - CollatorSelectionDesiredCollatorsOverride, +use crate::{ + config::pallets::{MaxCollators, SessionPeriod, TreasuryAccountId}, + Aura, Balance, Balances, BlockNumber, CollatorSelection, Runtime, RuntimeEvent, + RuntimeHoldReason, Session, SessionKeys, Treasury, }; parameter_types! { pub const SessionOffset: BlockNumber = 0; --- a/runtime/common/config/pallets/foreign_asset.rs +++ b/runtime/common/config/pallets/foreign_asset.rs @@ -1,6 +1,7 @@ -use crate::{Runtime, RuntimeEvent, Balances}; use up_common::types::AccountId; +use crate::{Balances, Runtime, RuntimeEvent}; + impl pallet_foreign_assets::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Currency = Balances; --- a/runtime/common/config/pallets/mod.rs +++ b/runtime/common/config/pallets/mod.rs @@ -15,29 +15,30 @@ // along with Unique Network. If not, see . use alloc::string::{String, ToString}; -use frame_support::parameter_types; + +use frame_support::{ + parameter_types, + traits::{ConstU32, ConstU64, Currency}, +}; +use sp_arithmetic::Perbill; use sp_runtime::traits::AccountIdConversion; +use up_common::{ + constants::*, + types::{AccountId, Balance, BlockNumber}, +}; +use up_data_structs::mapping::{CrossTokenAddressMapping, EvmTokenAddressMapping}; + +#[cfg(feature = "governance")] +use crate::runtime_common::config::governance; use crate::{ runtime_common::{ + config::{ethereum::EvmCollectionHelpersAddress, substrate::TreasuryModuleId}, dispatch::CollectionDispatchT, - config::{substrate::TreasuryModuleId, ethereum::EvmCollectionHelpersAddress}, weights::CommonWeights, RelayChainBlockNumberProvider, }, - Runtime, RuntimeEvent, RuntimeCall, VERSION, TOKEN_SYMBOL, DECIMALS, Balances, -}; -use frame_support::traits::{ConstU32, ConstU64, Currency}; -use up_common::{ - types::{AccountId, Balance, BlockNumber}, - constants::*, -}; -use up_data_structs::{ - mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping}, + Balances, Runtime, RuntimeCall, RuntimeEvent, DECIMALS, TOKEN_SYMBOL, VERSION, }; -use sp_arithmetic::Perbill; - -#[cfg(feature = "governance")] -use crate::runtime_common::config::governance; #[cfg(feature = "unique-scheduler")] pub mod scheduler; --- a/runtime/common/config/pallets/preimage.rs +++ b/runtime/common/config/pallets/preimage.rs @@ -16,9 +16,10 @@ use frame_support::parameter_types; use frame_system::EnsureRoot; -use crate::{AccountId, Balance, Balances, Runtime, RuntimeEvent}; use up_common::constants::*; +use crate::{AccountId, Balance, Balances, Runtime, RuntimeEvent}; + parameter_types! { pub PreimageBaseDeposit: Balance = 1000 * UNIQUE; } --- a/runtime/common/config/pallets/scheduler.rs +++ b/runtime/common/config/pallets/scheduler.rs @@ -14,21 +14,23 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . +use core::cmp::Ordering; + use frame_support::{ - traits::{PrivilegeCmp, EnsureOrigin}, - weights::Weight, parameter_types, + traits::{EnsureOrigin, PrivilegeCmp}, + weights::Weight, }; use frame_system::{EnsureRoot, RawOrigin}; +use pallet_unique_scheduler_v2::ScheduledEnsureOriginSuccess; +use parity_scale_codec::Decode; use sp_runtime::Perbill; -use core::cmp::Ordering; -use codec::Decode; +use up_common::types::AccountId; + use crate::{ - runtime_common::{scheduler::SchedulerPaymentExecutor, config::substrate::RuntimeBlockWeights}, - Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin, OriginCaller, + runtime_common::{config::substrate::RuntimeBlockWeights, scheduler::SchedulerPaymentExecutor}, + OriginCaller, Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin, }; -use pallet_unique_scheduler_v2::ScheduledEnsureOriginSuccess; -use up_common::types::AccountId; parameter_types! { pub MaximumSchedulerWeight: Weight = Perbill::from_percent(50) * --- a/runtime/common/config/parachain.rs +++ b/runtime/common/config/parachain.rs @@ -14,10 +14,11 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use frame_support::{weights::Weight, parameter_types}; -use crate::{Runtime, RuntimeEvent, XcmpQueue, DmpQueue}; +use frame_support::{parameter_types, weights::Weight}; use up_common::constants::*; +use crate::{DmpQueue, Runtime, RuntimeEvent, XcmpQueue}; + parameter_types! { pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT.saturating_div(4); pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT.saturating_div(4); --- a/runtime/common/config/sponsoring.rs +++ b/runtime/common/config/sponsoring.rs @@ -14,14 +14,12 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use crate::{ - runtime_common::{sponsoring::UniqueSponsorshipHandler}, - Runtime, -}; use frame_support::parameter_types; use sp_core::U256; use up_common::{constants::*, types::BlockNumber}; +use crate::{runtime_common::sponsoring::UniqueSponsorshipHandler, Runtime}; + parameter_types! { pub const DefaultSponsoringRateLimit: BlockNumber = 1 * DAYS; pub const DefaultSponsoringFeeLimit: U256 = U256::MAX; --- a/runtime/common/config/substrate.rs +++ b/runtime/common/config/substrate.rs @@ -15,31 +15,32 @@ // along with Unique Network. If not, see . use frame_support::{ - traits::{Everything, ConstU32, NeverEnsureOrigin}, + dispatch::DispatchClass, + ord_parameter_types, parameter_types, + traits::{ConstBool, ConstU32, Everything, NeverEnsureOrigin}, weights::{ constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}, ConstantMultiplier, }, - dispatch::DispatchClass, - parameter_types, ord_parameter_types, PalletId, -}; -use sp_runtime::{ - generic, - traits::{BlakeTwo256, AccountIdLookup}, - Perbill, Permill, Percent, + PalletId, }; -use sp_arithmetic::traits::One; use frame_system::{ limits::{BlockLength, BlockWeights}, EnsureRoot, EnsureSignedBy, }; -use pallet_transaction_payment::{Multiplier, ConstFeeMultiplier}; -use crate::{ - runtime_common::DealWithFees, Runtime, RuntimeEvent, RuntimeCall, RuntimeOrigin, OriginCaller, - PalletInfo, System, Balances, SS58Prefix, Version, +use pallet_transaction_payment::{ConstFeeMultiplier, Multiplier}; +use sp_arithmetic::traits::One; +use sp_runtime::{ + traits::{AccountIdLookup, BlakeTwo256}, + Perbill, Percent, Permill, }; -use up_common::{types::*, constants::*}; use sp_std::vec; +use up_common::{constants::*, types::*}; + +use crate::{ + runtime_common::DealWithFees, Balances, Block, OriginCaller, PalletInfo, Runtime, RuntimeCall, + RuntimeEvent, RuntimeHoldReason, RuntimeOrigin, SS58Prefix, System, Version, +}; parameter_types! { pub const BlockHashCount: BlockNumber = 2400; --- a/runtime/common/config/test_pallets.rs +++ b/runtime/common/config/test_pallets.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use crate::{Runtime, RuntimeEvent, RuntimeCall}; +use crate::{Runtime, RuntimeCall, RuntimeEvent}; impl pallet_test_utils::Config for Runtime { type RuntimeEvent = RuntimeEvent; --- a/runtime/common/config/xcm/foreignassets.rs +++ b/runtime/common/config/xcm/foreignassets.rs @@ -14,23 +14,22 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use frame_support::{traits::Get, parameter_types}; -use sp_runtime::traits::Convert; -use xcm::latest::{prelude::*, MultiAsset, MultiLocation}; -use xcm_builder::{FungiblesAdapter, NoChecking, ConvertedConcreteId}; -use xcm_executor::traits::{TransactAsset, Convert as ConvertXcm, JustTry}; -use pallet_foreign_assets::{ - AssetIds, AssetIdMapping, XcmForeignAssetIdMapping, NativeCurrency, FreeForAll, TryAsForeign, - ForeignAssetId, CurrencyId, -}; -use sp_std::{borrow::Borrow, marker::PhantomData}; +use frame_support::{parameter_types, traits::Get}; use orml_traits::location::AbsoluteReserveProvider; use orml_xcm_support::MultiNativeAsset; -use crate::{Runtime, Balances, ParachainInfo, PolkadotXcm, ForeignAssets}; +use pallet_foreign_assets::{ + AssetId, AssetIdMapping, CurrencyId, ForeignAssetId, FreeForAll, NativeCurrency, TryAsForeign, + XcmForeignAssetIdMapping, +}; +use sp_runtime::traits::{Convert, MaybeEquivalence}; +use sp_std::marker::PhantomData; +use staging_xcm::latest::{prelude::*, MultiAsset, MultiLocation}; +use staging_xcm_builder::{ConvertedConcreteId, FungiblesAdapter, NoChecking}; +use staging_xcm_executor::traits::{JustTry, TransactAsset}; +use up_common::types::{AccountId, Balance}; use super::{LocationToAccountId, RelayLocation}; - -use up_common::types::{AccountId, Balance}; +use crate::{Balances, ForeignAssets, ParachainInfo, PolkadotXcm, Runtime}; parameter_types! { pub CheckingAccount: AccountId = PolkadotXcm::check_account(); --- a/runtime/common/config/xcm/mod.rs +++ b/runtime/common/config/xcm/mod.rs @@ -15,28 +15,33 @@ // along with Unique Network. If not, see . use frame_support::{ - traits::{Everything, Nothing, Get, ConstU32, ProcessMessageError, Contains}, parameter_types, + traits::{ConstU32, Contains, Everything, Get, Nothing, ProcessMessageError}, }; use frame_system::EnsureRoot; use pallet_xcm::XcmPassthrough; -use polkadot_parachain::primitives::Sibling; -use xcm::latest::{prelude::*, Weight, MultiLocation}; -use xcm::v3::Instruction; -use xcm_builder::{ - AccountId32Aliases, EnsureXcmOrigin, FixedWeightBounds, ParentAsSuperuser, RelayChainAsNative, - SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative, - SignedToAccountId32, SovereignSignedViaLocation, ParentIsPreset, -}; -use xcm_executor::{XcmExecutor, traits::ShouldExecute}; +use polkadot_parachain_primitives::primitives::Sibling; use sp_std::marker::PhantomData; -use crate::{ - Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin, ParachainInfo, ParachainSystem, PolkadotXcm, - XcmpQueue, xcm_barrier::Barrier, RelayNetwork, AllPalletsWithSystem, Balances, +use staging_xcm::{ + latest::{prelude::*, MultiLocation, Weight}, + v3::Instruction, +}; +use staging_xcm_builder::{ + AccountId32Aliases, EnsureXcmOrigin, FixedWeightBounds, ParentAsSuperuser, ParentIsPreset, + RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, + SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, +}; +use staging_xcm_executor::{ + traits::{Properties, ShouldExecute}, + XcmExecutor, }; - use up_common::types::AccountId; +use crate::{ + xcm_barrier::Barrier, AllPalletsWithSystem, Balances, ParachainInfo, ParachainSystem, + PolkadotXcm, RelayNetwork, Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin, XcmpQueue, +}; + #[cfg(feature = "foreign-assets")] pub mod foreignassets; @@ -45,14 +50,12 @@ #[cfg(feature = "foreign-assets")] pub use foreignassets as xcm_assets; - #[cfg(not(feature = "foreign-assets"))] pub use nativeassets as xcm_assets; +use xcm_assets::{AssetTransactor, IsReserve, Trader}; #[cfg(feature = "governance")] use crate::runtime_common::config::governance; - -use xcm_assets::{AssetTransactor, IsReserve, Trader}; parameter_types! { pub const RelayLocation: MultiLocation = MultiLocation::parent(); --- a/runtime/common/config/xcm/nativeassets.rs +++ b/runtime/common/config/xcm/nativeassets.rs @@ -14,31 +14,28 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . +use cumulus_primitives_core::XcmContext; use frame_support::{ - traits::{tokens::currency::Currency as CurrencyT, OnUnbalanced as OnUnbalancedT, Get}, + traits::{tokens::currency::Currency as CurrencyT, Get, OnUnbalanced as OnUnbalancedT}, weights::WeightToFeePolynomial, }; -use sp_runtime::traits::{CheckedConversion, Zero, Convert}; -use xcm::latest::{ - AssetId::{Concrete}, - Fungibility::Fungible as XcmFungible, - MultiAsset, Error as XcmError, Weight, - Junction::*, - MultiLocation, - Junctions::*, +use pallet_foreign_assets::{AssetIds, NativeCurrency}; +use sp_runtime::traits::{CheckedConversion, Convert, Zero}; +use sp_std::marker::PhantomData; +use staging_xcm::latest::{ + AssetId::Concrete, Error as XcmError, Fungibility::Fungible as XcmFungible, Junction::*, + Junctions::*, MultiAsset, MultiLocation, Weight, }; -use xcm_builder::{CurrencyAdapter, NativeAsset}; -use xcm_executor::{ +use staging_xcm_builder::{CurrencyAdapter, NativeAsset}; +use staging_xcm_executor::{ + traits::{MatchesFungible, WeightTrader}, Assets, - traits::{MatchesFungible, WeightTrader}, }; -use pallet_foreign_assets::{AssetIds, NativeCurrency}; -use sp_std::marker::PhantomData; -use crate::{Balances, ParachainInfo}; -use super::{LocationToAccountId, RelayLocation}; - use up_common::types::{AccountId, Balance}; +use super::{LocationToAccountId, RelayLocation}; +use crate::{Balances, ParachainInfo}; + pub struct OnlySelfCurrency; impl> MatchesFungible for OnlySelfCurrency { fn matches_fungible(a: &MultiAsset) -> Option { --- a/runtime/common/dispatch.rs +++ b/runtime/common/dispatch.rs @@ -15,28 +15,27 @@ // along with Unique Network. If not, see . use frame_support::{dispatch::DispatchResult, ensure, fail}; -use pallet_evm::{PrecompileHandle, PrecompileResult}; -use sp_core::H160; -use sp_runtime::DispatchError; -use sp_std::{borrow::ToOwned, vec::Vec}; +use pallet_balances_adapter::NativeFungibleHandle; +pub use pallet_common::dispatch::CollectionDispatch; +#[cfg(not(feature = "refungible"))] +use pallet_common::unsupported; use pallet_common::{ - CollectionById, CollectionHandle, CommonCollectionOperations, erc::CommonEvmHandler, - eth::map_eth_to_id, + erc::CommonEvmHandler, eth::map_eth_to_id, CollectionById, CollectionHandle, + CommonCollectionOperations, }; -pub use pallet_common::dispatch::CollectionDispatch; -use pallet_fungible::{Pallet as PalletFungible, FungibleHandle}; -use pallet_balances_adapter::NativeFungibleHandle; -use pallet_nonfungible::{Pallet as PalletNonfungible, NonfungibleHandle}; +use pallet_evm::{PrecompileHandle, PrecompileResult}; +use pallet_fungible::{FungibleHandle, Pallet as PalletFungible}; +use pallet_nonfungible::{NonfungibleHandle, Pallet as PalletNonfungible}; use pallet_refungible::{ - Pallet as PalletRefungible, RefungibleHandle, erc_token::RefungibleTokenHandle, + erc_token::RefungibleTokenHandle, Pallet as PalletRefungible, RefungibleHandle, }; +use sp_core::H160; +use sp_runtime::DispatchError; +use sp_std::{borrow::ToOwned, vec::Vec}; use up_data_structs::{ - CollectionMode, CreateCollectionData, MAX_DECIMAL_POINTS, mapping::TokenAddressMapping, - CollectionId, + mapping::TokenAddressMapping, CollectionId, CollectionMode, CreateCollectionData, + MAX_DECIMAL_POINTS, }; - -#[cfg(not(feature = "refungible"))] -use pallet_common::unsupported; pub enum CollectionDispatchT where --- a/runtime/common/ethereum/precompiles/mod.rs +++ b/runtime/common/ethereum/precompiles/mod.rs @@ -14,11 +14,12 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use pallet_evm::{Precompile, PrecompileHandle, PrecompileResult, PrecompileSet, IsPrecompileResult}; +use pallet_evm::{ + IsPrecompileResult, Precompile, PrecompileHandle, PrecompileResult, PrecompileSet, +}; +use pallet_evm_precompile_simple::ECRecover; use sp_core::H160; use sp_std::marker::PhantomData; - -use pallet_evm_precompile_simple::{ECRecover}; use sr25519::Sr25519Precompile; mod sr25519; --- a/runtime/common/ethereum/precompiles/sr25519.rs +++ b/runtime/common/ethereum/precompiles/sr25519.rs @@ -17,8 +17,7 @@ use fp_evm::{Context, ExitSucceed, PrecompileHandle, PrecompileOutput}; use pallet_evm::Precompile; use sp_core::{crypto::UncheckedFrom, sr25519, H256}; -use sp_std::marker::PhantomData; -use sp_std::prelude::*; +use sp_std::{marker::PhantomData, prelude::*}; use super::utils::{Bytes, EvmDataReader, EvmDataWriter, EvmResult, FunctionModifier, Gasometer}; --- a/runtime/common/ethereum/precompiles/utils/data.rs +++ b/runtime/common/ethereum/precompiles/utils/data.rs @@ -16,12 +16,12 @@ // You should have received a copy of the GNU General Public License // along with Utils. If not, see . -use super::{EvmResult, Gasometer}; +use core::{any::type_name, ops::Range}; -use sp_std::borrow::ToOwned; -use core::{any::type_name, ops::Range}; use sp_core::{H160, H256, U256}; -use sp_std::{convert::TryInto, vec, vec::Vec}; +use sp_std::{borrow::ToOwned, convert::TryInto, vec, vec::Vec}; + +use super::{EvmResult, Gasometer}; /// The `address` type of Solidity. /// H160 could represent 2 types of data (bytes20 and address) that are not encoded the same way. --- a/runtime/common/ethereum/precompiles/utils/macro/src/lib.rs +++ b/runtime/common/ethereum/precompiles/utils/macro/src/lib.rs @@ -19,11 +19,12 @@ #![crate_type = "proc-macro"] extern crate proc_macro; +use std::convert::TryInto; + use proc_macro::TokenStream; use proc_macro2::Literal; use quote::{quote, quote_spanned}; use sha3::{Digest, Keccak256}; -use std::convert::TryInto; use syn::{parse_macro_input, spanned::Spanned, Expr, ExprLit, Ident, ItemEnum, Lit}; /// This macro allows to associate to each variant of an enumeration a discriminant (of type u32 --- a/runtime/common/ethereum/precompiles/utils/mod.rs +++ b/runtime/common/ethereum/precompiles/utils/mod.rs @@ -16,10 +16,9 @@ // You should have received a copy of the GNU General Public License // along with Utils. If not, see . -use sp_std::borrow::ToOwned; use fp_evm::{Context, ExitRevert, PrecompileFailure}; use sp_core::U256; -use sp_std::marker::PhantomData; +use sp_std::{borrow::ToOwned, marker::PhantomData}; mod data; --- a/runtime/common/ethereum/self_contained_call.rs +++ b/runtime/common/ethereum/self_contained_call.rs @@ -16,11 +16,12 @@ use sp_core::H160; use sp_runtime::{ - traits::{Dispatchable, DispatchInfoOf, PostDispatchInfoOf}, - transaction_validity::{TransactionValidityError, TransactionValidity, InvalidTransaction}, + traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf}, + transaction_validity::{InvalidTransaction, TransactionValidity, TransactionValidityError}, }; -use crate::{RuntimeOrigin, RuntimeCall, Maintenance}; +use crate::{Maintenance, RuntimeCall, RuntimeOrigin}; + impl fp_self_contained::SelfContainedCall for RuntimeCall { type SignedInfo = H160; --- a/runtime/common/ethereum/sponsoring.rs +++ b/runtime/common/ethereum/sponsoring.rs @@ -17,35 +17,36 @@ //! Implements EVM sponsoring logic via TransactionValidityHack use core::{convert::TryInto, marker::PhantomData}; -use evm_coder::{Call}; -use pallet_common::{CollectionHandle, eth::map_eth_to_id}; + +use evm_coder::Call; +use pallet_common::{eth::map_eth_to_id, CollectionHandle}; use pallet_evm::account::CrossAccountId; use pallet_evm_transaction_payment::CallContext; +use pallet_fungible::{ + erc::{ERC20Call, UniqueFungibleCall}, + Config as FungibleConfig, +}; use pallet_nonfungible::{ - Config as NonfungibleConfig, Pallet as NonfungiblePallet, NonfungibleHandle, erc::{ - UniqueNFTCall, ERC721UniqueExtensionsCall, ERC721UniqueMintableCall, ERC721Call, - TokenPropertiesCall, + ERC721Call, ERC721UniqueExtensionsCall, ERC721UniqueMintableCall, TokenPropertiesCall, + UniqueNFTCall, }, -}; -use pallet_fungible::{ - Config as FungibleConfig, - erc::{UniqueFungibleCall, ERC20Call}, + Config as NonfungibleConfig, NonfungibleHandle, Pallet as NonfungiblePallet, }; use pallet_refungible::{ - Config as RefungibleConfig, erc::UniqueRefungibleCall, erc_token::{RefungibleTokenHandle, UniqueRefungibleTokenCall}, - RefungibleHandle, + Config as RefungibleConfig, RefungibleHandle, }; use pallet_unique::Config as UniqueConfig; use sp_std::prelude::*; use up_data_structs::{ - CollectionMode, CreateItemData, CreateNftData, mapping::TokenAddressMapping, TokenId, + mapping::TokenAddressMapping, CollectionMode, CreateItemData, CreateNftData, TokenId, }; use up_sponsorship::SponsorshipHandler; -use crate::{Runtime, runtime_common::sponsoring::*}; +use crate::{runtime_common::sponsoring::*, Runtime}; + mod refungible; pub type EvmSponsorshipHandler = ( @@ -206,9 +207,9 @@ } mod common { - use super::*; + use pallet_common::erc::CollectionCall; - use pallet_common::erc::{CollectionCall}; + use super::*; pub fn collection_call_sponsor( call: CollectionCall, --- a/runtime/common/ethereum/sponsoring/refungible.rs +++ b/runtime/common/ethereum/sponsoring/refungible.rs @@ -19,14 +19,7 @@ use pallet_common::CollectionHandle; use pallet_evm::account::CrossAccountId; use pallet_fungible::Config as FungibleConfig; -use pallet_refungible::Config as RefungibleConfig; use pallet_nonfungible::Config as NonfungibleConfig; -use pallet_unique::Config as UniqueConfig; -use up_data_structs::{CreateItemData, CreateNftData, TokenId}; - -use super::common; -use crate::runtime_common::sponsoring::*; - use pallet_refungible::{ erc::{ ERC721BurnableCall, ERC721Call, ERC721EnumerableCall, ERC721MetadataCall, @@ -37,7 +30,13 @@ ERC1633Call, ERC20Call, ERC20UniqueExtensionsCall, RefungibleTokenHandle, UniqueRefungibleTokenCall, }, + Config as RefungibleConfig, }; +use pallet_unique::Config as UniqueConfig; +use up_data_structs::{CreateItemData, CreateNftData, TokenId}; + +use super::common; +use crate::runtime_common::sponsoring::*; pub fn call_sponsor( call: UniqueRefungibleCall, --- a/runtime/common/identity.rs +++ b/runtime/common/identity.rs @@ -14,18 +14,17 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . +use parity_scale_codec::{Decode, Encode}; use scale_info::TypeInfo; -use codec::{Encode, Decode}; -use up_common::types::AccountId; -use crate::RuntimeCall; - +#[cfg(feature = "collator-selection")] +use sp_runtime::transaction_validity::InvalidTransaction; use sp_runtime::{ traits::{DispatchInfoOf, SignedExtension}, - transaction_validity::{TransactionValidity, ValidTransaction, TransactionValidityError}, + transaction_validity::{TransactionValidity, TransactionValidityError, ValidTransaction}, }; +use up_common::types::AccountId; -#[cfg(feature = "collator-selection")] -use sp_runtime::transaction_validity::InvalidTransaction; +use crate::RuntimeCall; #[derive(Debug, Encode, Decode, PartialEq, Eq, Clone, TypeInfo)] pub struct DisableIdentityCalls; --- a/runtime/common/instance.rs +++ b/runtime/common/instance.rs @@ -1,9 +1,7 @@ -use crate::{ - runtime_common::{config::ethereum::CrossAccountId}, - Runtime, -}; use up_common::types::opaque::RuntimeInstance; +use crate::{runtime_common::config::ethereum::CrossAccountId, Runtime}; + impl RuntimeInstance for Runtime { type CrossAccountId = CrossAccountId; } --- a/runtime/common/maintenance.rs +++ b/runtime/common/maintenance.rs @@ -14,17 +14,17 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . +use parity_scale_codec::{Decode, Encode}; use scale_info::TypeInfo; -use codec::{Encode, Decode}; -use up_common::types::AccountId; -use crate::{RuntimeCall, Maintenance}; - use sp_runtime::{ traits::{DispatchInfoOf, SignedExtension}, transaction_validity::{ - TransactionValidity, ValidTransaction, InvalidTransaction, TransactionValidityError, + InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction, }, }; +use up_common::types::AccountId; + +use crate::{Maintenance, RuntimeCall}; #[derive(Debug, Encode, Decode, PartialEq, Eq, Clone, TypeInfo)] pub struct CheckMaintenance; --- a/runtime/common/mod.rs +++ b/runtime/common/mod.rs @@ -33,26 +33,23 @@ #[cfg(test)] pub mod tests; -use sp_core::H160; use frame_support::{ - traits::{Currency, OnUnbalanced, Imbalance}, + traits::{Currency, Imbalance, OnUnbalanced}, weights::Weight, }; use sp_runtime::{ - generic, + generic, impl_opaque_keys, traits::{BlakeTwo256, BlockNumberProvider}, - impl_opaque_keys, }; use sp_std::vec::Vec; - #[cfg(feature = "std")] use sp_version::NativeVersion; +use up_common::types::{AccountId, BlockNumber}; use crate::{ - Runtime, RuntimeCall, Balances, Treasury, Aura, Signature, AllPalletsWithSystem, - InherentDataExt, + AllPalletsWithSystem, Aura, Balances, InherentDataExt, Runtime, RuntimeCall, Signature, + Treasury, }; -use up_common::types::{AccountId, BlockNumber}; #[macro_export] macro_rules! unsupported { @@ -175,7 +172,7 @@ } } -#[derive(codec::Encode, codec::Decode)] +#[derive(parity_scale_codec::Encode, parity_scale_codec::Decode)] pub enum XCMPMessage { /// Transfer tokens to the given account from the Parachain account. TransferToken(XAccountId, XBalance), @@ -186,9 +183,10 @@ fn on_runtime_upgrade() -> Weight { #[cfg(feature = "collator-selection")] { - use frame_support::{BoundedVec, storage::migration}; - use sp_runtime::{traits::OpaqueKeys, RuntimeAppPublic}; + use frame_support::{storage::migration, BoundedVec}; use pallet_session::SessionManager; + use sp_runtime::{traits::OpaqueKeys, RuntimeAppPublic}; + use crate::config::pallets::MaxCollators; let mut weight = ::DbWeight::get().reads(1); --- a/runtime/common/scheduler.rs +++ b/runtime/common/scheduler.rs @@ -14,21 +14,20 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use frame_support::{ - dispatch::{GetDispatchInfo, PostDispatchInfo, DispatchInfo}, -}; +use fp_self_contained::SelfContainedCall; +use frame_support::dispatch::{DispatchInfo, GetDispatchInfo, PostDispatchInfo}; +use pallet_transaction_payment::ChargeTransactionPayment; +use pallet_unique_scheduler_v2::DispatchCall; +use parity_scale_codec::Encode; use sp_runtime::{ - traits::{Dispatchable, Applyable, Member}, + traits::{Applyable, Dispatchable, Member}, transaction_validity::TransactionValidityError, DispatchErrorWithPostInfo, }; -use codec::Encode; -use crate::{Runtime, RuntimeCall, RuntimeOrigin, maintenance}; use up_common::types::AccountId; -use fp_self_contained::SelfContainedCall; -use pallet_unique_scheduler_v2::DispatchCall; -use pallet_transaction_payment::ChargeTransactionPayment; +use crate::{maintenance, Runtime, RuntimeCall, RuntimeOrigin}; + /// The SignedExtension to the basic transaction logic. pub type SignedExtraScheduler = ( frame_system::CheckWeight, --- a/runtime/common/sponsoring.rs +++ b/runtime/common/sponsoring.rs @@ -15,25 +15,25 @@ // along with Unique Network. If not, see . use core::marker::PhantomData; -use up_sponsorship::SponsorshipHandler; -use frame_support::{ - traits::{IsSubType}, -}; -use up_data_structs::{ - CollectionId, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, NFT_SPONSOR_TRANSFER_TIMEOUT, - REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, TokenId, CollectionMode, CreateItemData, -}; -use sp_runtime::traits::Saturating; -use pallet_common::{CollectionHandle}; + +use frame_support::traits::IsSubType; +use frame_system::pallet_prelude::*; +use pallet_common::CollectionHandle; use pallet_evm::account::CrossAccountId; -use pallet_unique::{ - Call as UniqueCall, Config as UniqueConfig, FungibleApproveBasket, RefungibleApproveBasket, - NftApproveBasket, CreateItemBasket, ReFungibleTransferBasket, FungibleTransferBasket, - NftTransferBasket, TokenPropertyBasket, -}; use pallet_fungible::Config as FungibleConfig; use pallet_nonfungible::Config as NonfungibleConfig; use pallet_refungible::Config as RefungibleConfig; +use pallet_unique::{ + Call as UniqueCall, Config as UniqueConfig, CreateItemBasket, FungibleApproveBasket, + FungibleTransferBasket, NftApproveBasket, NftTransferBasket, ReFungibleTransferBasket, + RefungibleApproveBasket, TokenPropertyBasket, +}; +use sp_runtime::traits::Saturating; +use up_data_structs::{ + CollectionId, CollectionMode, CreateItemData, TokenId, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, + NFT_SPONSOR_TRANSFER_TIMEOUT, REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, +}; +use up_sponsorship::SponsorshipHandler; pub trait Config: UniqueConfig + FungibleConfig + NonfungibleConfig + RefungibleConfig {} impl Config for T where T: UniqueConfig + FungibleConfig + NonfungibleConfig + RefungibleConfig {} --- a/runtime/common/tests/mod.rs +++ b/runtime/common/tests/mod.rs @@ -14,12 +14,12 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . +use sp_core::{Pair, Public}; +pub use sp_runtime::AccountId32 as AccountId; use sp_runtime::{BuildStorage, Storage}; -use sp_core::{Public, Pair}; use up_common::types::AuraId; -use crate::{Runtime, GenesisConfig, ParachainInfoConfig, RuntimeEvent, System}; -pub use sp_runtime::AccountId32 as AccountId; +use crate::{BuildGenesisConfig, ParachainInfoConfig, Runtime, RuntimeEvent, System}; pub type Balance = u128; pub mod xcm; @@ -62,10 +62,11 @@ #[cfg(feature = "collator-selection")] fn make_basic_storage() -> Storage { - use sp_core::{sr25519}; + use sp_core::sr25519; use sp_runtime::traits::{IdentifyAccount, Verify}; - use crate::{AccountId, Signature, SessionKeys, CollatorSelectionConfig, SessionConfig}; + use crate::{AccountId, CollatorSelectionConfig, SessionConfig, SessionKeys, Signature}; + type AccountPublic = ::Signer; fn get_account_id_from_seed(seed: &str) -> AccountId --- a/runtime/common/tests/xcm.rs +++ b/runtime/common/tests/xcm.rs @@ -14,15 +14,16 @@ // You should have received a copy of the GNU General Public License // along with Unique Network. If not, see . -use xcm::{ - VersionedXcm, +use frame_support::pallet_prelude::Weight; +use parity_scale_codec::Encode; +use staging_xcm::{ latest::{prelude::*, Error}, + VersionedXcm, }; -use codec::Encode; -use crate::{Runtime, RuntimeCall, RuntimeOrigin, RuntimeEvent, PolkadotXcm}; -use super::{new_test_ext, last_events, AccountId}; -use frame_support::{pallet_prelude::Weight}; +use super::{last_events, new_test_ext, AccountId}; +use crate::{PolkadotXcm, Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin}; + const ALICE: AccountId = AccountId::new([0u8; 32]); const BOB: AccountId = AccountId::new([1u8; 32]); --- a/runtime/common/weights/mod.rs +++ b/runtime/common/weights/mod.rs @@ -15,20 +15,21 @@ // along with Unique Network. If not, see . use core::marker::PhantomData; -use frame_support::{weights::Weight}; -use pallet_common::{CommonWeightInfo, dispatch::dispatch_weight, RefungibleExtensionsWeightInfo}; +use frame_support::weights::Weight; use pallet_balances_adapter::{ - Config as NativeFungibleConfig, common::CommonWeights as NativeFungibleWeights, + common::CommonWeights as NativeFungibleWeights, Config as NativeFungibleConfig, }; -use pallet_fungible::{Config as FungibleConfig, common::CommonWeights as FungibleWeights}; -use pallet_nonfungible::{Config as NonfungibleConfig, common::CommonWeights as NonfungibleWeights}; - +use pallet_common::{dispatch::dispatch_weight, CommonWeightInfo, RefungibleExtensionsWeightInfo}; +use pallet_fungible::{common::CommonWeights as FungibleWeights, Config as FungibleConfig}; +use pallet_nonfungible::{ + common::CommonWeights as NonfungibleWeights, Config as NonfungibleConfig, +}; #[cfg(feature = "refungible")] use pallet_refungible::{ - Config as RefungibleConfig, weights::WeightInfo, common::CommonWeights as RefungibleWeights, + common::CommonWeights as RefungibleWeights, weights::WeightInfo, Config as RefungibleConfig, }; -use up_data_structs::{CreateItemExData, CreateItemData}; +use up_data_structs::{CreateItemData, CreateItemExData}; pub mod xcm; --- a/runtime/opal/src/lib.rs +++ b/runtime/opal/src/lib.rs @@ -27,14 +27,11 @@ extern crate alloc; +use ::staging_xcm::latest::NetworkId; use frame_support::parameter_types; - -use sp_version::RuntimeVersion; use sp_runtime::create_runtime_str; - +use sp_version::RuntimeVersion; use up_common::types::*; - -use ::xcm::latest::NetworkId; mod runtime_common; --- a/runtime/opal/src/xcm_barrier.rs +++ b/runtime/opal/src/xcm_barrier.rs @@ -16,7 +16,7 @@ use frame_support::{match_types, traits::Everything}; use xcm::latest::{Junctions::*, MultiLocation}; -use xcm_builder::{AllowTopLevelPaidExecutionFrom, TakeWeightCredit, AllowExplicitUnpaidExecutionFrom}; +use staging_xcm_builder::{AllowTopLevelPaidExecutionFrom, TakeWeightCredit, AllowExplicitUnpaidExecutionFrom}; match_types! { pub type ParentOnly: impl Contains = { --- a/runtime/quartz/src/lib.rs +++ b/runtime/quartz/src/lib.rs @@ -27,14 +27,11 @@ extern crate alloc; +use ::staging_xcm::latest::NetworkId; use frame_support::parameter_types; - -use sp_version::RuntimeVersion; use sp_runtime::create_runtime_str; - +use sp_version::RuntimeVersion; use up_common::types::*; - -use ::xcm::latest::NetworkId; mod runtime_common; --- a/runtime/quartz/src/xcm_barrier.rs +++ b/runtime/quartz/src/xcm_barrier.rs @@ -15,8 +15,8 @@ // along with Unique Network. If not, see . use frame_support::{match_types, traits::Everything}; -use xcm::latest::{Junctions::*, MultiLocation}; -use xcm_builder::{ +use staging_xcm::latest::{Junctions::*, MultiLocation}; +use staging_xcm_builder::{ AllowKnownQueryResponses, AllowSubscriptionsFrom, TakeWeightCredit, AllowTopLevelPaidExecutionFrom, AllowExplicitUnpaidExecutionFrom, }; --- a/runtime/tests/src/lib.rs +++ b/runtime/tests/src/lib.rs @@ -16,27 +16,26 @@ #![allow(clippy::from_over_into)] -use sp_core::{H160, H256, U256}; use frame_support::{ + pallet_prelude::Weight, parameter_types, - traits::{Everything, ConstU32, ConstU64, fungible::Inspect}, + traits::{fungible::Inspect, ConstU32, ConstU64, Everything}, weights::IdentityFee, - pallet_prelude::Weight, }; -use sp_runtime::{ - traits::{BlakeTwo256, IdentityLookup}, - testing::Header, -}; -use pallet_transaction_payment::CurrencyAdapter; use frame_system as system; +use pallet_ethereum::PostLogContent; use pallet_evm::{ - AddressMapping, account::CrossAccountId, EnsureAddressNever, SubstrateBlockHashMapping, - BackwardsAddressMapping, + account::CrossAccountId, AddressMapping, BackwardsAddressMapping, EnsureAddressNever, + SubstrateBlockHashMapping, }; -use pallet_ethereum::PostLogContent; -use codec::{Encode, Decode, MaxEncodedLen}; +use pallet_transaction_payment::CurrencyAdapter; +use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; - +use sp_core::{H160, H256, U256}; +use sp_runtime::{ + testing::Header, + traits::{BlakeTwo256, IdentityLookup}, +}; use up_data_structs::mapping::{CrossTokenAddressMapping, EvmTokenAddressMapping}; #[path = "../../common/dispatch.rs"] --- a/runtime/tests/src/tests.rs +++ b/runtime/tests/src/tests.rs @@ -15,19 +15,22 @@ // along with Unique Network. If not, see . // Tests to be written here -use crate::{Test, TestCrossAccountId, CollectionCreationPrice, RuntimeOrigin, Unique, new_test_ext}; +use frame_support::{assert_err, assert_noop, assert_ok}; +use pallet_common::Error as CommonError; +use pallet_evm::account::CrossAccountId; +use pallet_unique::Error as UniqueError; +use sp_std::convert::TryInto; use up_data_structs::{ - COLLECTION_NUMBER_LIMIT, CollectionId, CreateItemData, CreateFungibleData, CreateNftData, - CreateReFungibleData, MAX_DECIMAL_POINTS, COLLECTION_ADMINS_LIMIT, TokenId, - MAX_TOKEN_OWNERSHIP, CreateCollectionData, CollectionMode, AccessMode, CollectionPermissions, - PropertyKeyPermission, PropertyPermission, Property, CollectionPropertiesVec, - CollectionPropertiesPermissionsVec, + AccessMode, CollectionId, CollectionMode, CollectionPermissions, + CollectionPropertiesPermissionsVec, CollectionPropertiesVec, CreateCollectionData, + CreateFungibleData, CreateItemData, CreateNftData, CreateReFungibleData, Property, + PropertyKeyPermission, PropertyPermission, TokenId, COLLECTION_ADMINS_LIMIT, + COLLECTION_NUMBER_LIMIT, MAX_DECIMAL_POINTS, MAX_TOKEN_OWNERSHIP, +}; + +use crate::{ + new_test_ext, CollectionCreationPrice, RuntimeOrigin, Test, TestCrossAccountId, Unique, }; -use frame_support::{assert_noop, assert_ok, assert_err}; -use sp_std::convert::TryInto; -use pallet_evm::account::CrossAccountId; -use pallet_common::Error as CommonError; -use pallet_unique::Error as UniqueError; fn add_balance(user: u64, value: u64) { const DONOR_USER: u64 = 999; @@ -2617,9 +2620,10 @@ } mod check_token_permissions { - use super::*; use pallet_common::LazyValue; + use super::*; + fn test bool>( i: usize, test_case: &pallet_common::tests::TestCase, --- a/runtime/unique/src/lib.rs +++ b/runtime/unique/src/lib.rs @@ -27,14 +27,11 @@ extern crate alloc; +use ::staging_xcm::latest::NetworkId; use frame_support::parameter_types; - -use sp_version::RuntimeVersion; use sp_runtime::create_runtime_str; - +use sp_version::RuntimeVersion; use up_common::types::*; - -use ::xcm::latest::NetworkId; mod runtime_common; --- a/runtime/unique/src/xcm_barrier.rs +++ b/runtime/unique/src/xcm_barrier.rs @@ -15,8 +15,8 @@ // along with Unique Network. If not, see . use frame_support::{match_types, traits::Everything}; -use xcm::latest::{Junctions::*, MultiLocation}; -use xcm_builder::{ +use staging_xcm::latest::{Junctions::*, MultiLocation}; +use staging_xcm_builder::{ AllowKnownQueryResponses, AllowSubscriptionsFrom, TakeWeightCredit, AllowTopLevelPaidExecutionFrom, AllowExplicitUnpaidExecutionFrom, }; --- a/test-pallets/utils/src/lib.rs +++ b/test-pallets/utils/src/lib.rs @@ -16,18 +16,19 @@ #![cfg_attr(not(feature = "std"), no_std)] -pub use pallet::*; use frame_support::pallet_prelude::*; use frame_system::pallet_prelude::*; +pub use pallet::*; #[frame_support::pallet(dev_mode)] pub mod pallet { use frame_support::{ + dispatch::{GetDispatchInfo, PostDispatchInfo}, pallet_prelude::*, - dispatch::{Dispatchable, GetDispatchInfo, PostDispatchInfo}, - traits::{UnfilteredDispatchable, IsSubType, OriginTrait}, + traits::{IsSubType, OriginTrait, UnfilteredDispatchable}, }; use frame_system::pallet_prelude::*; + use sp_runtime::traits::Dispatchable; use sp_std::vec::Vec; #[pallet::config]