git.delta.rocks / unique-network / refs/commits / 4dd148686c6b

1group_imports = "stdexternalcrate"
1hard_tabs = true2hard_tabs = true
2reorder_imports = false3imports_granularity = "crate"
34

17// Original License17// Original License
18use std::sync::Arc;18use std::sync::Arc;
1919
20use codec::Decode;20use anyhow::anyhow;
21use app_promotion_rpc::AppPromotionApi as AppPromotionRuntimeApi;
22pub use app_promotion_unique_rpc::AppPromotionApiServer;
21use jsonrpsee::{23use jsonrpsee::{core::RpcResult as Result, proc_macros::rpc};
22	core::{RpcResult as Result},
23	proc_macros::rpc,
24};
25use anyhow::anyhow;24use parity_scale_codec::Decode;
25use sp_api::{ApiExt, BlockT, ProvideRuntimeApi};
26use sp_blockchain::HeaderBackend;
26use sp_runtime::traits::{AtLeast32BitUnsigned, Member};27use sp_runtime::traits::{AtLeast32BitUnsigned, Member};
27use up_data_structs::{28use up_data_structs::{
28	RpcCollection, CollectionId, CollectionStats, CollectionLimits, TokenId, Property,29	CollectionId, CollectionLimits, CollectionStats, Property, PropertyKeyPermission,
29	PropertyKeyPermission, TokenData, TokenChild,30	RpcCollection, TokenChild, TokenData, TokenId,
30};31};
31use sp_api::{BlockT, ProvideRuntimeApi, ApiExt};
32use sp_blockchain::HeaderBackend;
33use up_rpc::UniqueApi as UniqueRuntimeApi;32use up_rpc::UniqueApi as UniqueRuntimeApi;
34use app_promotion_rpc::AppPromotionApi as AppPromotionRuntimeApi;
35
36pub use app_promotion_unique_rpc::AppPromotionApiServer;
3733
38#[cfg(feature = "pov-estimate")]34#[cfg(feature = "pov-estimate")]
39pub mod pov_estimate;35pub mod pov_estimate;
549	keys.map(|keys| keys.into_iter().map(|key| key.into_bytes()).collect())545	keys.map(|keys| keys.into_iter().map(|key| key.into_bytes()).collect())
550}546}
551547
552fn decode_collection_from_bytes<T: codec::Decode>(548fn decode_collection_from_bytes<T: parity_scale_codec::Decode>(
553	bytes: &[u8],549	bytes: &[u8],
554) -> core::result::Result<T, codec::Error> {550) -> core::result::Result<T, parity_scale_codec::Error> {
555	let mut reader = codec::IoReader(bytes);551	let mut reader = parity_scale_codec::IoReader(bytes);
556	T::decode(&mut reader)552	T::decode(&mut reader)
557}553}
558554
559fn detect_type_and_decode_collection<AccountId: Decode>(555fn detect_type_and_decode_collection<AccountId: Decode>(
560	bytes: &[u8],556	bytes: &[u8],
561) -> core::result::Result<RpcCollection<AccountId>, codec::Error> {557) -> core::result::Result<RpcCollection<AccountId>, parity_scale_codec::Error> {
562	use up_data_structs::{CollectionVersion1, RpcCollectionVersion1};558	use up_data_structs::{CollectionVersion1, RpcCollectionVersion1};
563559
564	decode_collection_from_bytes::<RpcCollection<AccountId>>(bytes)560	decode_collection_from_bytes::<RpcCollection<AccountId>>(bytes)
574570
575#[cfg(test)]571#[cfg(test)]
576mod tests {572mod tests {
577	use super::*;573	use hex_literal::hex;
578	use codec::IoReader;574	use parity_scale_codec::IoReader;
579	use hex_literal::hex;
580	use up_data_structs::{CollectionVersion1, RawEncoded};575	use up_data_structs::{CollectionVersion1, RawEncoded};
576
577	use super::*;
581578
582	const ENCODED_COLLECTION_V1: [u8; 180] = hex!("aab94a1ee784bc17f68d76d4d48d736916ca6ff6315b8c1fa1175726c8345a390000285000720069006d00610020004c00690076006500d04500730065006d00700069006f00200064006900200063007200650061007a0069006f006e006500200064006900200075006e00610020006e0075006f0076006100200063006f006c006c0065007a0069006f006e00650020006400690020004e004600540021000c464e5400000000000000000000000000000000");579	const ENCODED_COLLECTION_V1: [u8; 180] = hex!("aab94a1ee784bc17f68d76d4d48d736916ca6ff6315b8c1fa1175726c8345a390000285000720069006d00610020004c00690076006500d04500730065006d00700069006f00200064006900200063007200650061007a0069006f006e006500200064006900200075006e00610020006e0075006f0076006100200063006f006c006c0065007a0069006f006e00650020006400690020004e004600540021000c464e5400000000000000000000000000000000");
583	const ENCODED_RPC_COLLECTION_V2: [u8; 618] = hex!("d00dcc24bf66750d3809aa26884b930ec8a3094d6f6f19fdc62020b2fbec013400604d0069006e007400460065007300740020002d002000460075006e006e007900200061006e0069006d0061006c0073008c430072006f00730073006f0076006500720020006200650074007700650065006e00200061006e0069006d0061006c00730020002d00200066006f0072002000660075006e00104d46464100000000000000000000010001000100000004385f6f6c645f636f6e7374446174610001000c5c5f6f6c645f636f6e73744f6e436861696e536368656d6139047b226e6573746564223a7b226f6e436861696e4d65746144617461223a7b226e6573746564223a7b224e46544d657461223a7b226669656c6473223a7b22697066734a736f6e223a7b226964223a312c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c2248656164223a7b226964223a322c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c22426f6479223a7b226964223a332c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c225461696c223a7b226964223a342c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d7d7d7d7d7d7d485f6f6c645f736368656d6156657273696f6e18556e69717565685f6f6c645f7661726961626c654f6e436861696e536368656d6111017b22636f6c6c656374696f6e436f766572223a22516d53557a7139354c357a556777795a584d3731576a3762786b36557048515468633162536965347766706e5435227d000000");580	const ENCODED_RPC_COLLECTION_V2: [u8; 618] = hex!("d00dcc24bf66750d3809aa26884b930ec8a3094d6f6f19fdc62020b2fbec013400604d0069006e007400460065007300740020002d002000460075006e006e007900200061006e0069006d0061006c0073008c430072006f00730073006f0076006500720020006200650074007700650065006e00200061006e0069006d0061006c00730020002d00200066006f0072002000660075006e00104d46464100000000000000000000010001000100000004385f6f6c645f636f6e7374446174610001000c5c5f6f6c645f636f6e73744f6e436861696e536368656d6139047b226e6573746564223a7b226f6e436861696e4d65746144617461223a7b226e6573746564223a7b224e46544d657461223a7b226669656c6473223a7b22697066734a736f6e223a7b226964223a312c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c2248656164223a7b226964223a322c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c22426f6479223a7b226964223a332c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d2c225461696c223a7b226964223a342c2272756c65223a227265717569726564222c2274797065223a22737472696e67227d7d7d7d7d7d7d485f6f6c645f736368656d6156657273696f6e18556e69717565685f6f6c645f7661726961626c654f6e436861696e536368656d6111017b22636f6c6c656374696f6e436f766572223a22516d53557a7139354c357a556777795a584d3731576a3762786b36557048515468633162536965347766706e5435227d000000");

1616
17use std::sync::Arc;17use std::sync::Arc;
1818
19use codec::{Encode, Decode};19use anyhow::anyhow;
20use sp_externalities::Extensions;
21
22use up_pov_estimate_rpc::{PovEstimateApi as PovEstimateRuntimeApi};20use jsonrpsee::{core::RpcResult as Result, proc_macros::rpc};
23use up_common::types::opaque::RuntimeId;21use parity_scale_codec::{Decode, Encode};
24
25use sc_service::{NativeExecutionDispatch, config::ExecutionStrategy};22use sc_client_api::backend::Backend;
26use sp_state_machine::{StateMachine, TrieBackendBuilder};23use sc_executor::NativeElseWasmExecutor;
27use trie_db::{Trie, TrieDBBuilder};24use sc_rpc_api::DenyUnsafe;
28
29use jsonrpsee::{core::RpcResult as Result, proc_macros::rpc};25use sc_service::{config::ExecutionStrategy, NativeExecutionDispatch};
30use anyhow::anyhow;26use sp_api::{AsTrieBackend, BlockId, BlockT, ProvideRuntimeApi};
31
32use sc_client_api::backend::Backend;
33use sp_blockchain::HeaderBackend;27use sp_blockchain::HeaderBackend;
34use sp_core::{28use sp_core::{
35	Bytes,
36	offchain::{29	offchain::{
37		testing::{TestOffchainExt, TestTransactionPoolExt},30		testing::{TestOffchainExt, TestTransactionPoolExt},
38		OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,31		OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
39	},32	},
40	testing::TaskExecutor,33	testing::TaskExecutor,
41	traits::TaskExecutorExt,34	traits::TaskExecutorExt,
35	Bytes,
42};36};
37use sp_externalities::Extensions;
43use sp_keystore::{testing::KeyStore, KeystoreExt};38use sp_keystore::{testing::KeyStore, KeystoreExt};
44use sp_api::{AsTrieBackend, BlockId, BlockT, ProvideRuntimeApi};39use sp_runtime::traits::Header;
45
46use sc_executor::NativeElseWasmExecutor;40use sp_state_machine::{StateMachine, TrieBackendBuilder};
47use sc_rpc_api::DenyUnsafe;41use trie_db::{Trie, TrieDBBuilder};
48
49use sp_runtime::traits::Header;42use up_common::types::opaque::RuntimeId;
50
51use up_pov_estimate_rpc::{PovInfo, TrieKeyValue};43use up_pov_estimate_rpc::{PovEstimateApi as PovEstimateRuntimeApi, PovInfo, TrieKeyValue};
5244
53use crate::define_struct_for_server_api;45use crate::define_struct_for_server_api;
5446

17#![doc = include_str!("../README.md")]17#![doc = include_str!("../README.md")]
1818
19use proc_macro::TokenStream;19use proc_macro::TokenStream;
20use quote::format_ident;20use quote::{format_ident, quote};
21use syn::{21use syn::{
22	parenthesized,
22	parse::{Parse, ParseStream},23	parse::{Parse, ParseStream},
23	Token, LitInt, parse_macro_input, ItemStruct, Error, Fields, Result, Field, Expr,24	parse_macro_input, Error, Expr, Field, Fields, ItemStruct, LitInt, Result, Token,
24	parenthesized,
25};25};
26use quote::quote;
2726
28mod kw {27mod kw {
29	syn::custom_keyword!(version);28	syn::custom_keyword!(version);

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};17use std::collections::BTreeMap;
18
19#[cfg(all(not(feature = "unique-runtime"), not(feature = "quartz-runtime")))]
18use sc_service::ChainType;20pub use opal_runtime as default_runtime;
21#[cfg(all(not(feature = "unique-runtime"), feature = "quartz-runtime"))]
19use sp_core::{sr25519, Pair, Public};22pub use quartz_runtime as default_runtime;
20use sp_runtime::traits::{IdentifyAccount, Verify};23use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};
21use std::collections::BTreeMap;24use sc_service::ChainType;
22
23use serde::{Deserialize, Serialize};25use serde::{Deserialize, Serialize};
24use serde_json::map::Map;26use serde_json::map::Map;
2527use sp_core::{sr25519, Pair, Public};
26use up_common::types::opaque::*;28use sp_runtime::traits::{IdentifyAccount, Verify};
27
28#[cfg(feature = "unique-runtime")]29#[cfg(feature = "unique-runtime")]
29pub use unique_runtime as default_runtime;30pub use unique_runtime as default_runtime;
30
31#[cfg(all(not(feature = "unique-runtime"), feature = "quartz-runtime"))]
32pub use quartz_runtime as default_runtime;31use up_common::types::opaque::*;
33
34#[cfg(all(not(feature = "unique-runtime"), not(feature = "quartz-runtime")))]
35pub use opal_runtime as default_runtime;
3632
37/// The `ChainSpec` parameterized for the unique runtime.33/// The `ChainSpec` parameterized for the unique runtime.
38#[cfg(feature = "unique-runtime")]34#[cfg(feature = "unique-runtime")]
39pub type UniqueChainSpec = sc_service::GenericChainSpec<unique_runtime::GenesisConfig, Extensions>;35pub type UniqueChainSpec =
36	sc_service::GenericChainSpec<unique_runtime::RuntimeGenesisConfig, Extensions>;
4037
41/// The `ChainSpec` parameterized for the quartz runtime.38/// The `ChainSpec` parameterized for the quartz runtime.
42#[cfg(feature = "quartz-runtime")]39#[cfg(feature = "quartz-runtime")]
43pub type QuartzChainSpec = sc_service::GenericChainSpec<quartz_runtime::GenesisConfig, Extensions>;40pub type QuartzChainSpec =
41	sc_service::GenericChainSpec<quartz_runtime::RuntimeGenesisConfig, Extensions>;
4442
45/// The `ChainSpec` parameterized for the opal runtime.43/// The `ChainSpec` parameterized for the opal runtime.
46pub type OpalChainSpec = sc_service::GenericChainSpec<opal_runtime::GenesisConfig, Extensions>;44pub type OpalChainSpec =
45	sc_service::GenericChainSpec<opal_runtime::RuntimeGenesisConfig, Extensions>;
4746
48#[cfg(feature = "unique-runtime")]47#[cfg(feature = "unique-runtime")]
49pub type DefaultChainSpec = UniqueChainSpec;48pub type DefaultChainSpec = UniqueChainSpec;

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17use crate::chain_spec;
18use std::path::PathBuf;17use std::path::PathBuf;
18
19use clap::Parser;19use clap::Parser;
20
21use crate::chain_spec;
2022
21/// Sub-commands supported by the collator.23/// Sub-commands supported by the collator.
22#[derive(Debug, Parser)]24#[derive(Debug, Parser)]

32// See the License for the specific language governing permissions and32// See the License for the specific language governing permissions and
33// limitations under the License.33// limitations under the License.
3434
35use crate::{
36	chain_spec::{self, RuntimeIdentification, ServiceId, ServiceIdentification},
37	cli::{Cli, RelayChainCli, Subcommand},
38	service::{new_partial, start_node, start_dev_node},
39};
40#[cfg(feature = "runtime-benchmarks")]
41use crate::chain_spec::default_runtime;35use std::time::Duration;
4236
43#[cfg(feature = "unique-runtime")]
44use crate::service::UniqueRuntimeExecutor;37use codec::Encode;
45
46#[cfg(feature = "quartz-runtime")]
47use crate::service::QuartzRuntimeExecutor;38use cumulus_client_cli::generate_genesis_block;
48
49use crate::service::OpalRuntimeExecutor;
50
51#[cfg(feature = "runtime-benchmarks")]
52use crate::service::DefaultRuntimeExecutor;
53
54use codec::Encode;
55use cumulus_primitives_core::ParaId;39use cumulus_primitives_core::ParaId;
56use cumulus_client_cli::generate_genesis_block;
57use log::{debug, info};40use log::{debug, info};
58use sc_cli::{41use sc_cli::{
59	ChainSpec, CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams,42	ChainSpec, CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams,
65
66use up_common::types::opaque::{Block, RuntimeId};48use up_common::types::opaque::{Block, RuntimeId};
49
50#[cfg(feature = "runtime-benchmarks")]
51use crate::chain_spec::default_runtime;
52#[cfg(feature = "runtime-benchmarks")]
53use crate::service::DefaultRuntimeExecutor;
54#[cfg(feature = "quartz-runtime")]
55use crate::service::QuartzRuntimeExecutor;
56#[cfg(feature = "unique-runtime")]
57use crate::service::UniqueRuntimeExecutor;
58use crate::{
59	chain_spec::{self, RuntimeIdentification, ServiceId, ServiceIdentification},
60	cli::{Cli, RelayChainCli, Subcommand},
61	service::{new_partial, start_dev_node, start_node, OpalRuntimeExecutor},
62};
6763
68macro_rules! no_runtime_err {64macro_rules! no_runtime_err {
69	($runtime_id:expr) => {65	($runtime_id:expr) => {

19mod service;19mod service;
20mod cli;20mod cli;
21mod command;21mod command;
22mod rpc;
2223
23fn main() -> sc_cli::Result<()> {24fn main() -> sc_cli::Result<()> {
24	command::run()25	command::run()

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17// std17// std
18use std::sync::Arc;18use std::{
19	collections::BTreeMap,
20	marker::PhantomData,
21	pin::Pin,
22	sync::{Arc, Mutex},
23	time::Duration,
24};
25
19use std::sync::Mutex;26use cumulus_client_cli::CollatorOptions;
20use std::collections::BTreeMap;27use cumulus_client_collator::service::CollatorService;
28#[cfg(not(feature = "lookahead"))]
21use std::time::Duration;29use cumulus_client_consensus_aura::collators::basic::{
30	run as run_aura, Params as BuildAuraConsensusParams,
31};
32#[cfg(feature = "lookahead")]
22use std::pin::Pin;33use cumulus_client_consensus_aura::collators::lookahead::{
34	run as run_aura, Params as BuildAuraConsensusParams,
35};
23use fc_mapping_sync::EthereumBlockNotificationSinks;36use cumulus_client_consensus_common::ParachainBlockImport as TParachainBlockImport;
24use fc_rpc::EthBlockDataCacheTask;37use cumulus_client_consensus_proposer::Proposer;
25use fc_rpc::EthTask;38use cumulus_client_network::RequireSecondedInBlockAnnounce;
26use fc_rpc_core::types::FeeHistoryCache;
27use futures::{39use cumulus_client_service::{
28	Stream, StreamExt,40	build_relay_chain_interface, prepare_node_config, start_relay_chain_tasks, DARecoveryProfile,
29	stream::select,
30	task::{Context, Poll},41	StartRelayChainTasksParams,
31};42};
32use sc_rpc::SubscriptionTaskExecutor;43use cumulus_primitives_core::ParaId;
33use sp_keystore::KeystorePtr;
34use tokio::time::Interval;
35use jsonrpsee::RpcModule;
36
37use serde::{Serialize, Deserialize};44use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface};
38
39// Cumulus Imports
40use cumulus_client_consensus_aura::{AuraConsensus, BuildAuraConsensusParams, SlotProportion};45use fc_mapping_sync::{kv::MappingSyncWorker, EthereumBlockNotificationSinks, SyncStrategy};
41use cumulus_client_consensus_common::{46use fc_rpc::{
42	ParachainConsensus, ParachainBlockImport as TParachainBlockImport,47	frontier_backend_client::SystemAccountId32StorageOverride, EthBlockDataCacheTask, EthConfig,
48	EthTask, OverrideHandle, RuntimeApiStorageOverride, SchemaV1Override, SchemaV2Override,
49	SchemaV3Override, StorageOverride,
43};50};
44use cumulus_client_service::{51use fc_rpc_core::types::{FeeHistoryCache, FilterPool};
45	prepare_node_config, start_collator, start_full_node, StartCollatorParams, StartFullNodeParams,
46};
47use cumulus_client_cli::CollatorOptions;52use fp_rpc::EthereumRuntimeRPCApi;
48use cumulus_client_network::BlockAnnounceValidator;53use fp_storage::EthereumStorageSchema;
49use cumulus_primitives_core::ParaId;54use futures::{
55	stream::select,
50use cumulus_relay_chain_inprocess_interface::build_inprocess_relay_chain;56	task::{Context, Poll},
57	Stream, StreamExt,
58};
51use cumulus_relay_chain_interface::{RelayChainInterface, RelayChainResult};59use jsonrpsee::RpcModule;
52use cumulus_relay_chain_minimal_node::build_minimal_relay_chain_node;60use polkadot_service::CollatorPair;
53
54// Substrate Imports
55use sp_api::{BlockT, HeaderT, ProvideRuntimeApi, StateBackend};61use sc_client_api::{AuxStore, Backend, BlockOf, BlockchainEvents, StorageProvider};
56use sc_executor::NativeElseWasmExecutor;62use sc_consensus::ImportQueue;
57use sc_executor::NativeExecutionDispatch;63use sc_executor::{NativeElseWasmExecutor, NativeExecutionDispatch};
58use sc_network::NetworkBlock;64use sc_network::NetworkBlock;
59use sc_network_sync::SyncingService;65use sc_network_sync::SyncingService;
66use sc_rpc::SubscriptionTaskExecutor;
60use sc_service::{Configuration, PartialComponents, TaskManager};67use sc_service::{Configuration, PartialComponents, TaskManager};
61use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};68use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle};
62use sp_runtime::traits::BlakeTwo256;69use serde::{Deserialize, Serialize};
63use substrate_prometheus_endpoint::Registry;70use sp_api::{ProvideRuntimeApi, StateBackend};
64use sc_client_api::{BlockchainEvents, BlockOf, Backend, AuxStore, StorageProvider};71use sp_block_builder::BlockBuilder;
65use sp_blockchain::{HeaderBackend, HeaderMetadata, Error as BlockChainError};72use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
66use sc_consensus::ImportQueue;73use sp_consensus_aura::sr25519::AuthorityPair as AuraAuthorityPair;
67use sp_core::H256;
68use sp_block_builder::BlockBuilder;74use sp_keystore::KeystorePtr;
69
70use polkadot_service::CollatorPair;
71
72// Frontier Imports
73use fc_rpc_core::types::FilterPool;75use sp_runtime::traits::BlakeTwo256;
74use fc_mapping_sync::{kv::MappingSyncWorker, SyncStrategy};76use substrate_prometheus_endpoint::Registry;
75use fc_rpc::{77use tokio::time::Interval;
76	StorageOverride, OverrideHandle, SchemaV1Override, SchemaV2Override, SchemaV3Override,
77	RuntimeApiStorageOverride,
78};
79use fp_rpc::EthereumRuntimeRPCApi;
80use fp_storage::EthereumStorageSchema;
81
82use up_common::types::opaque::*;78use up_common::types::{opaque::*, Nonce};
8379
84use crate::chain_spec::RuntimeIdentification;80use crate::{
81	chain_spec::RuntimeIdentification,
82	rpc::{create_eth, create_full, EthDeps, FullDeps},
83};
8584
86/// Unique native executor instance.85/// Unique native executor instance.
87#[cfg(feature = "unique-runtime")]86#[cfg(feature = "unique-runtime")]

1616
17#![cfg(feature = "runtime-benchmarks")]17#![cfg(feature = "runtime-benchmarks")]
1818
19use super::*;19use frame_benchmarking::{account, benchmarks};
20use crate::Pallet as PromototionPallet;
21use frame_support::traits::fungible::Unbalanced;20use frame_support::traits::{fungible::Unbalanced, OnInitialize};
22use sp_runtime::traits::Bounded;21use frame_system::RawOrigin;
23
24use frame_benchmarking::{benchmarks, account};22use pallet_evm_migration::Pallet as EvmMigrationPallet;
25use frame_support::traits::OnInitialize;23use pallet_unique::benchmarking::create_nft_collection;
26use frame_system::RawOrigin;24use sp_runtime::traits::Bounded;
25
27use pallet_unique::benchmarking::create_nft_collection;26use super::*;
28use pallet_evm_migration::Pallet as EvmMigrationPallet;27use crate::Pallet as PromototionPallet;
2928
30const SEED: u32 = 0;29const SEED: u32 = 0;
3130

53pub mod types;53pub mod types;
54pub mod weights;54pub mod weights;
55
56use sp_std::{vec::Vec, vec, iter::Sum, borrow::ToOwned, cell::RefCell};
57use sp_core::H160;
58use codec::EncodeLike;
59pub use types::*;
60
61use up_data_structs::CollectionId;
6255
63use frame_support::{56use frame_support::{
64	dispatch::{DispatchResult},57	dispatch::DispatchResult,
58	ensure,
65	traits::{59	pallet_prelude::*,
66		Get,
67		tokens::Balance,60	storage::Key,
61	traits::{
68		fungible::{Inspect, InspectFreeze, Mutate, MutateFreeze},62		fungible::{Inspect, InspectFreeze, Mutate, MutateFreeze},
63		tokens::Balance,
64		Get,
69	},65	},
70	ensure, BoundedVec,66	weights::Weight,
67	Blake2_128Concat, BoundedVec, PalletId, Twox64Concat,
71};68};
72
73use weights::WeightInfo;69use frame_system::pallet_prelude::*;
74
75pub use pallet::*;70pub use pallet::*;
76use pallet_evm::account::CrossAccountId;71use pallet_evm::account::CrossAccountId;
72use parity_scale_codec::EncodeLike;
73use sp_core::H160;
77use sp_runtime::{74use sp_runtime::{
78	Perbill,
79	traits::{BlockNumberProvider, CheckedAdd, CheckedSub, AccountIdConversion, Zero},75	traits::{AccountIdConversion, BlockNumberProvider, CheckedAdd, CheckedSub, Zero},
80	ArithmeticError, DispatchError,76	ArithmeticError, DispatchError, Perbill,
81};77};
78use sp_std::{borrow::ToOwned, cell::RefCell, iter::Sum, vec, vec::Vec};
79pub use types::*;
80use up_data_structs::CollectionId;
81use weights::WeightInfo;
8282
83const PENDING_LIMIT_PER_BLOCK: u32 = 3;83const PENDING_LIMIT_PER_BLOCK: u32 = 3;
8484
89pub mod pallet {89pub mod pallet {
90
90	use super::*;91	use super::*;
91	use frame_support::{
92		Blake2_128Concat, Twox64Concat, pallet_prelude::*, storage::Key, PalletId, weights::Weight,
93	};
94	use frame_system::pallet_prelude::*;
95	use sp_runtime::DispatchError;
9692
97	#[pallet::config]93	#[pallet::config]
98	pub trait Config:94	pub trait Config:

1use frame_support::{dispatch::DispatchResult};1use frame_support::dispatch::DispatchResult;
22use frame_system::pallet_prelude::*;
3use pallet_common::CollectionHandle;3use pallet_common::CollectionHandle;
4
5use sp_runtime::{DispatchError, Perbill};4use pallet_configuration::AppPromomotionConfigurationOverride;
6use up_data_structs::{CollectionId};5use pallet_evm_contract_helpers::{Config as EvmHelpersConfig, Pallet as EvmHelpersPallet};
7use sp_std::borrow::ToOwned;6use sp_core::Get;
8use pallet_evm_contract_helpers::{Pallet as EvmHelpersPallet, Config as EvmHelpersConfig};7use sp_runtime::{DispatchError, Perbill};
9use pallet_configuration::{AppPromomotionConfigurationOverride};8use sp_std::borrow::ToOwned;
10use sp_core::Get;9use up_data_structs::CollectionId;
1110
12const MAX_NUMBER_PAYOUTS: u8 = 100;11const MAX_NUMBER_PAYOUTS: u8 = 100;
13pub(crate) const DEFAULT_NUMBER_PAYOUTS: u8 = 20;12pub(crate) const DEFAULT_NUMBER_PAYOUTS: u8 = 20;

1use alloc::{vec, vec::Vec};1use alloc::{vec, vec::Vec};
2use core::marker::PhantomData;2use core::marker::PhantomData;
3use crate::{Config, NativeFungibleHandle, Pallet};3
4use frame_support::{fail, weights::Weight};4use frame_support::{fail, weights::Weight};
5use pallet_balances::{weights::SubstrateWeight as BalancesWeight, WeightInfo};5use pallet_balances::{weights::SubstrateWeight as BalancesWeight, WeightInfo};
6use pallet_common::{CommonCollectionOperations, CommonWeightInfo};6use pallet_common::{CommonCollectionOperations, CommonWeightInfo};
7use up_data_structs::TokenId;7use up_data_structs::TokenId;
8
9use crate::{Config, NativeFungibleHandle, Pallet};
810
9pub struct CommonWeights<T: Config>(PhantomData<T>);11pub struct CommonWeights<T: Config>(PhantomData<T>);
1012

1use crate::{Config, NativeFungibleHandle, Pallet, SelfWeightOf};
2use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*};1use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*};
3use pallet_balances::WeightInfo;2use pallet_balances::WeightInfo;
4use pallet_common::{3use pallet_common::{
10	execution::{PreDispatch, Result},9	execution::{PreDispatch, Result},
11	frontier_contract, WithRecorder,10	frontier_contract, WithRecorder,
12};11};
13use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};12use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight};
14use sp_core::{U256, Get};13use sp_core::{Get, U256};
14
15use crate::{Config, NativeFungibleHandle, Pallet, SelfWeightOf};
1516
16frontier_contract! {17frontier_contract! {
17	macro_rules! NativeFungibleHandle_result {...}18	macro_rules! NativeFungibleHandle_result {...}

4use core::ops::Deref;4use core::ops::Deref;
55
6use frame_support::sp_runtime::DispatchResult;6use frame_support::sp_runtime::DispatchResult;
7use pallet_evm_coder_substrate::{WithRecorder, SubstrateRecorder};7pub use pallet::*;
8pub use pallet::*;8use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};
99
10pub mod common;10pub mod common;
11pub mod erc;11pub mod erc;
55}55}
56#[frame_support::pallet]56#[frame_support::pallet]
57pub mod pallet {57pub mod pallet {
58	use super::*;
59	use alloc::string::String;58	use alloc::string::String;
59
60	use frame_support::{60	use frame_support::{
61		dispatch::PostDispatchInfo,61		dispatch::PostDispatchInfo,
62		ensure,62		ensure,
63		pallet_prelude::{DispatchResultWithPostInfo, Pays},63		pallet_prelude::*,
64		traits::{64		traits::{
65			Get,
66			fungible::{Inspect, Mutate},65			fungible::{Inspect, Mutate},
67			tokens::Preservation,66			tokens::Preservation,
67			Get,
68		},68		},
69	};69	};
70	use pallet_balances::WeightInfo;70	use pallet_balances::WeightInfo;
74	use sp_runtime::DispatchError;74	use sp_runtime::DispatchError;
75	use up_data_structs::{budget::Budget, mapping::TokenAddressMapping};75	use up_data_structs::{budget::Budget, mapping::TokenAddressMapping};
76
77	use super::*;
7678
77	#[pallet::config]79	#[pallet::config]
78	pub trait Config:80	pub trait Config:

3232
33//! Benchmarking setup for pallet-collator-selection33//! Benchmarking setup for pallet-collator-selection
3434
35use super::*;
36
37#[allow(unused)]
38use crate::{Pallet as CollatorSelection, BalanceOf};
39use frame_benchmarking::{account, benchmarks, impl_benchmark_test_suite, whitelisted_caller};35use frame_benchmarking::{account, benchmarks, impl_benchmark_test_suite, whitelisted_caller};
40use frame_support::{36use frame_support::{
41	assert_ok,37	assert_ok,
42	codec::Decode,38	parity_scale_codec::Decode,
43	traits::{39	traits::{
44		EnsureOrigin,
45		fungible::{Inspect, Mutate},40		fungible::{Inspect, Mutate},
46		Get,41		EnsureOrigin, Get,
47	},42	},
48};43};
49use frame_system::{EventRecord, RawOrigin};44use frame_system::{EventRecord, RawOrigin};

96	<<T as Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;96	<<T as Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;
97#[frame_support::pallet]97#[frame_support::pallet]
98pub mod pallet {98pub mod pallet {
99	use super::*;
100	pub use crate::weights::WeightInfo;
101	use core::ops::Div;99	use core::ops::Div;
100
102	use frame_support::{101	use frame_support::{
103		dispatch::{DispatchClass, DispatchResultWithPostInfo},102		dispatch::{DispatchClass, DispatchResultWithPostInfo},
104		inherent::Vec,
105		pallet_prelude::*,103		pallet_prelude::*,
106		sp_runtime::traits::{AccountIdConversion, CheckedSub, Saturating, Zero},104		sp_runtime::traits::{AccountIdConversion, CheckedSub, Saturating, Zero},
107		traits::{105		traits::{
108			EnsureOrigin,
109			fungible::{Balanced, BalancedHold, Inspect, InspectHold, Mutate, MutateHold},106			fungible::{Balanced, BalancedHold, Inspect, Mutate, MutateHold},
110			ValidatorRegistration,
111			tokens::{Precision, Preservation},107			tokens::{Precision, Preservation},
108			EnsureOrigin, ValidatorRegistration,
112		},109		},
113		BoundedVec, PalletId,110		BoundedVec, PalletId,
114	};111	};
115	use frame_system::pallet_prelude::*;112	use frame_system::pallet_prelude::*;
116	use pallet_session::SessionManager;113	use pallet_session::SessionManager;
117	use sp_runtime::{Perbill, traits::Convert};114	use sp_runtime::{traits::Convert, Perbill};
118	use sp_staking::SessionIndex;115	use sp_staking::SessionIndex;
116	use sp_std::vec::Vec;
117
118	use super::*;
119	pub use crate::weights::WeightInfo;
119120
120	/// A convertor from collators id. Since this pallet does not have stash/controller, this is121	/// A convertor from collators id. Since this pallet does not have stash/controller, this is
121	/// just identity.122	/// just identity.

30// See the License for the specific language governing permissions and30// See the License for the specific language governing permissions and
31// limitations under the License.31// limitations under the License.
3232
33use super::*;
34use crate as collator_selection;
35use frame_support::{33use frame_support::{
36	ord_parameter_types, parameter_types,34	ord_parameter_types, parameter_types,
37	traits::{FindAuthor, GenesisBuild, ValidatorRegistration},35	traits::{FindAuthor, GenesisBuild, ValidatorRegistration},
46	Perbill, RuntimeAppPublic,44	Perbill, RuntimeAppPublic,
47};45};
46
47use super::*;
48use crate as collator_selection;
4849
49type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;50type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
50type Block = frame_system::mocking::MockBlock<Test>;51type Block = frame_system::mocking::MockBlock<Test>;

30// See the License for the specific language governing permissions and30// See the License for the specific language governing permissions and
31// limitations under the License.31// limitations under the License.
3232
33use crate::{self as collator_selection, Config};
34use crate::{mock::*, Error};
35use frame_support::{33use frame_support::{
36	assert_noop, assert_ok,34	assert_noop, assert_ok,
37	traits::{fungible, GenesisBuild, OnInitialize},35	traits::{fungible, GenesisBuild, OnInitialize},
38};36};
37use scale_info::prelude::*;
39use sp_runtime::{traits::BadOrigin, TokenError};38use sp_runtime::{traits::BadOrigin, TokenError};
39
40use scale_info::prelude::*;40use crate::{self as collator_selection, mock::*, Config, Error};
4141
42fn get_license_and_onboard(account_id: <Test as frame_system::Config>::AccountId) {42fn get_license_and_onboard(account_id: <Test as frame_system::Config>::AccountId) {
43	assert_ok!(CollatorSelection::get_license(RuntimeOrigin::signed(43	assert_ok!(CollatorSelection::get_license(RuntimeOrigin::signed(