Added ORML NFT pallet to runtime and applied to the node template
Editied ./runtime/cargo.toml and ./runtime/src/lib.rs shown below for edits required.
Proofs of NFT use via https://polkadot.js.org/apps/ extrinsics in comments.
Last active
November 9, 2020 23:58
-
-
Save nuke-web3/a0f9d6b67a9dd0ac2be7bbbb25a5f136 to your computer and use it in GitHub Desktop.
Submission for NFT Challenge heelo world polkadot
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| [package] | |
| authors = ['Substrate DevHub <https://github.com/substrate-developer-hub>'] | |
| edition = '2018' | |
| homepage = 'https://substrate.dev' | |
| license = 'Unlicense' | |
| name = 'node-template-runtime' | |
| repository = 'https://github.com/substrate-developer-hub/substrate-node-template/' | |
| version = '2.0.0' | |
| [package.metadata.docs.rs] | |
| targets = ['x86_64-unknown-linux-gnu'] | |
| [build-dependencies] | |
| wasm-builder-runner = { package = 'substrate-wasm-builder-runner', version = '1.0.5' } | |
| # alias "parity-scale-code" to "codec" | |
| [dependencies.codec] | |
| default-features = false | |
| features = ['derive'] | |
| package = 'parity-scale-codec' | |
| version = '1.3.4' | |
| [dependencies] | |
| hex-literal = { optional = true, version = '0.3.1' } | |
| serde = { features = ['derive'], optional = true, version = '1.0.101' } | |
| # local dependencies | |
| pallet-template = { path = '../pallets/template', default-features = false, version = '2.0.0' } | |
| # Substrate dependencies | |
| frame-benchmarking = { default-features = false, optional = true, version = '2.0.0' } | |
| frame-executive = { default-features = false, version = '2.0.0' } | |
| frame-support = { default-features = false, version = '2.0.0' } | |
| frame-system = { default-features = false, version = '2.0.0' } | |
| frame-system-benchmarking = { default-features = false, optional = true, version = '2.0.0' } | |
| frame-system-rpc-runtime-api = { default-features = false, version = '2.0.0' } | |
| pallet-aura = { default-features = false, version = '2.0.0' } | |
| pallet-balances = { default-features = false, version = '2.0.0' } | |
| pallet-grandpa = { default-features = false, version = '2.0.0' } | |
| pallet-randomness-collective-flip = { default-features = false, version = '2.0.0' } | |
| pallet-sudo = { default-features = false, version = '2.0.0' } | |
| pallet-timestamp = { default-features = false, version = '2.0.0' } | |
| pallet-transaction-payment = { default-features = false, version = '2.0.0' } | |
| pallet-transaction-payment-rpc-runtime-api = { default-features = false, version = '2.0.0' } | |
| sp-api = { default-features = false, version = '2.0.0' } | |
| sp-block-builder = { default-features = false, version = '2.0.0' } | |
| sp-consensus-aura = { default-features = false, version = '0.8.0' } | |
| sp-core = { default-features = false, version = '2.0.0' } | |
| sp-inherents = { default-features = false, version = '2.0.0' } | |
| sp-offchain = { default-features = false, version = '2.0.0' } | |
| sp-runtime = { default-features = false, version = '2.0.0' } | |
| sp-session = { default-features = false, version = '2.0.0' } | |
| sp-std = { default-features = false, version = '2.0.0' } | |
| sp-transaction-pool = { default-features = false, version = '2.0.0' } | |
| sp-version = { default-features = false, version = '2.0.0' } | |
| orml-nft = { default-features = false, version = '0.3.4' } | |
| [features] | |
| default = ['std'] | |
| runtime-benchmarks = [ | |
| 'hex-literal', | |
| 'frame-benchmarking', | |
| 'frame-support/runtime-benchmarks', | |
| 'frame-system-benchmarking', | |
| 'frame-system/runtime-benchmarks', | |
| 'pallet-balances/runtime-benchmarks', | |
| 'pallet-timestamp/runtime-benchmarks', | |
| 'sp-runtime/runtime-benchmarks', | |
| ] | |
| std = [ | |
| 'codec/std', | |
| 'serde', | |
| 'frame-executive/std', | |
| 'frame-support/std', | |
| 'frame-system/std', | |
| 'frame-system-rpc-runtime-api/std', | |
| 'pallet-aura/std', | |
| 'pallet-balances/std', | |
| 'pallet-grandpa/std', | |
| 'pallet-randomness-collective-flip/std', | |
| 'pallet-sudo/std', | |
| 'pallet-template/std', | |
| 'pallet-timestamp/std', | |
| 'pallet-transaction-payment/std', | |
| 'pallet-transaction-payment-rpc-runtime-api/std', | |
| 'sp-api/std', | |
| 'sp-block-builder/std', | |
| 'sp-consensus-aura/std', | |
| 'sp-core/std', | |
| 'sp-inherents/std', | |
| 'sp-offchain/std', | |
| 'sp-runtime/std', | |
| 'sp-session/std', | |
| 'sp-std/std', | |
| 'sp-transaction-pool/std', | |
| 'sp-version/std', | |
| 'orml-nft/std', | |
| ] |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| #![cfg_attr(not(feature = "std"), no_std)] | |
| // `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256. | |
| #![recursion_limit="256"] | |
| // Make the WASM binary available. | |
| #[cfg(feature = "std")] | |
| include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); | |
| use sp_std::prelude::*; | |
| use sp_core::{crypto::KeyTypeId, OpaqueMetadata}; | |
| use sp_runtime::{ | |
| ApplyExtrinsicResult, generic, create_runtime_str, impl_opaque_keys, MultiSignature, | |
| transaction_validity::{TransactionValidity, TransactionSource}, | |
| }; | |
| use sp_runtime::traits::{ | |
| BlakeTwo256, Block as BlockT, IdentityLookup, Verify, IdentifyAccount, NumberFor, Saturating, | |
| }; | |
| use sp_api::impl_runtime_apis; | |
| use sp_consensus_aura::sr25519::AuthorityId as AuraId; | |
| use pallet_grandpa::{AuthorityId as GrandpaId, AuthorityList as GrandpaAuthorityList}; | |
| use pallet_grandpa::fg_primitives; | |
| use sp_version::RuntimeVersion; | |
| #[cfg(feature = "std")] | |
| use sp_version::NativeVersion; | |
| // A few exports that help ease life for downstream crates. | |
| #[cfg(any(feature = "std", test))] | |
| pub use sp_runtime::BuildStorage; | |
| pub use pallet_timestamp::Call as TimestampCall; | |
| pub use pallet_balances::Call as BalancesCall; | |
| pub use sp_runtime::{Permill, Perbill}; | |
| pub use frame_support::{ | |
| construct_runtime, parameter_types, StorageValue, | |
| traits::{KeyOwnerProofSystem, Randomness}, | |
| weights::{ | |
| Weight, IdentityFee, | |
| constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND}, | |
| }, | |
| }; | |
| /// Import the template pallet. | |
| pub use pallet_template; | |
| /// An index to a block. | |
| pub type BlockNumber = u32; | |
| /// Alias to 512-bit hash when used in the context of a transaction signature on the chain. | |
| pub type Signature = MultiSignature; | |
| /// Some way of identifying an account on the chain. We intentionally make it equivalent | |
| /// to the public key of our transaction signing scheme. | |
| pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId; | |
| /// The type for looking up accounts. We don't expect more than 4 billion of them, but you | |
| /// never know... | |
| pub type AccountIndex = u32; | |
| /// Balance of an account. | |
| pub type Balance = u128; | |
| /// Index of a transaction in the chain. | |
| pub type Index = u32; | |
| /// A hash of some data used by the chain. | |
| pub type Hash = sp_core::H256; | |
| /// Digest item type. | |
| pub type DigestItem = generic::DigestItem<Hash>; | |
| /// Opaque types. These are used by the CLI to instantiate machinery that don't need to know | |
| /// the specifics of the runtime. They can then be made to be agnostic over specific formats | |
| /// of data like extrinsics, allowing for them to continue syncing the network through upgrades | |
| /// to even the core data structures. | |
| pub mod opaque { | |
| use super::*; | |
| pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic; | |
| /// Opaque block header type. | |
| pub type Header = generic::Header<BlockNumber, BlakeTwo256>; | |
| /// Opaque block type. | |
| pub type Block = generic::Block<Header, UncheckedExtrinsic>; | |
| /// Opaque block identifier type. | |
| pub type BlockId = generic::BlockId<Block>; | |
| impl_opaque_keys! { | |
| pub struct SessionKeys { | |
| pub aura: Aura, | |
| pub grandpa: Grandpa, | |
| } | |
| } | |
| } | |
| pub const VERSION: RuntimeVersion = RuntimeVersion { | |
| spec_name: create_runtime_str!("node-template"), | |
| impl_name: create_runtime_str!("node-template"), | |
| authoring_version: 1, | |
| spec_version: 1, | |
| impl_version: 1, | |
| apis: RUNTIME_API_VERSIONS, | |
| transaction_version: 1, | |
| }; | |
| pub const MILLISECS_PER_BLOCK: u64 = 6000; | |
| pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK; | |
| // Time is measured by number of blocks. | |
| pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber); | |
| pub const HOURS: BlockNumber = MINUTES * 60; | |
| pub const DAYS: BlockNumber = HOURS * 24; | |
| /// The version information used to identify this runtime when compiled natively. | |
| #[cfg(feature = "std")] | |
| pub fn native_version() -> NativeVersion { | |
| NativeVersion { | |
| runtime_version: VERSION, | |
| can_author_with: Default::default(), | |
| } | |
| } | |
| parameter_types! { | |
| pub const BlockHashCount: BlockNumber = 2400; | |
| /// We allow for 2 seconds of compute with a 6 second average block time. | |
| pub const MaximumBlockWeight: Weight = 2 * WEIGHT_PER_SECOND; | |
| pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75); | |
| /// Assume 10% of weight for average on_initialize calls. | |
| pub MaximumExtrinsicWeight: Weight = AvailableBlockRatio::get() | |
| .saturating_sub(Perbill::from_percent(10)) * MaximumBlockWeight::get(); | |
| pub const MaximumBlockLength: u32 = 5 * 1024 * 1024; | |
| pub const Version: RuntimeVersion = VERSION; | |
| } | |
| // Configure FRAME pallets to include in runtime. | |
| impl frame_system::Trait for Runtime { | |
| /// The basic call filter to use in dispatchable. | |
| type BaseCallFilter = (); | |
| /// The identifier used to distinguish between accounts. | |
| type AccountId = AccountId; | |
| /// The aggregated dispatch type that is available for extrinsics. | |
| type Call = Call; | |
| /// The lookup mechanism to get account ID from whatever is passed in dispatchers. | |
| type Lookup = IdentityLookup<AccountId>; | |
| /// The index type for storing how many extrinsics an account has signed. | |
| type Index = Index; | |
| /// The index type for blocks. | |
| type BlockNumber = BlockNumber; | |
| /// The type for hashing blocks and tries. | |
| type Hash = Hash; | |
| /// The hashing algorithm used. | |
| type Hashing = BlakeTwo256; | |
| /// The header type. | |
| type Header = generic::Header<BlockNumber, BlakeTwo256>; | |
| /// The ubiquitous event type. | |
| type Event = Event; | |
| /// The ubiquitous origin type. | |
| type Origin = Origin; | |
| /// Maximum number of block number to block hash mappings to keep (oldest pruned first). | |
| type BlockHashCount = BlockHashCount; | |
| /// Maximum weight of each block. | |
| type MaximumBlockWeight = MaximumBlockWeight; | |
| /// The weight of database operations that the runtime can invoke. | |
| type DbWeight = RocksDbWeight; | |
| /// The weight of the overhead invoked on the block import process, independent of the | |
| /// extrinsics included in that block. | |
| type BlockExecutionWeight = BlockExecutionWeight; | |
| /// The base weight of any extrinsic processed by the runtime, independent of the | |
| /// logic of that extrinsic. (Signature verification, nonce increment, fee, etc...) | |
| type ExtrinsicBaseWeight = ExtrinsicBaseWeight; | |
| /// The maximum weight that a single extrinsic of `Normal` dispatch class can have, | |
| /// idependent of the logic of that extrinsics. (Roughly max block weight - average on | |
| /// initialize cost). | |
| type MaximumExtrinsicWeight = MaximumExtrinsicWeight; | |
| /// Maximum size of all encoded transactions (in bytes) that are allowed in one block. | |
| type MaximumBlockLength = MaximumBlockLength; | |
| /// Portion of the block weight that is available to all normal transactions. | |
| type AvailableBlockRatio = AvailableBlockRatio; | |
| /// Version of the runtime. | |
| type Version = Version; | |
| /// Converts a module to the index of the module in `construct_runtime!`. | |
| /// | |
| /// This type is being generated by `construct_runtime!`. | |
| type PalletInfo = PalletInfo; | |
| /// What to do if a new account is created. | |
| type OnNewAccount = (); | |
| /// What to do if an account is fully reaped from the system. | |
| type OnKilledAccount = (); | |
| /// The data to be stored in an account. | |
| type AccountData = pallet_balances::AccountData<Balance>; | |
| /// Weight information for the extrinsics of this pallet. | |
| type SystemWeightInfo = (); | |
| } | |
| impl pallet_aura::Trait for Runtime { | |
| type AuthorityId = AuraId; | |
| } | |
| impl pallet_grandpa::Trait for Runtime { | |
| type Event = Event; | |
| type Call = Call; | |
| type KeyOwnerProofSystem = (); | |
| type KeyOwnerProof = | |
| <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, GrandpaId)>>::Proof; | |
| type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<( | |
| KeyTypeId, | |
| GrandpaId, | |
| )>>::IdentificationTuple; | |
| type HandleEquivocation = (); | |
| type WeightInfo = (); | |
| } | |
| parameter_types! { | |
| pub const MinimumPeriod: u64 = SLOT_DURATION / 2; | |
| } | |
| impl pallet_timestamp::Trait for Runtime { | |
| /// A timestamp: milliseconds since the unix epoch. | |
| type Moment = u64; | |
| type OnTimestampSet = Aura; | |
| type MinimumPeriod = MinimumPeriod; | |
| type WeightInfo = (); | |
| } | |
| parameter_types! { | |
| pub const ExistentialDeposit: u128 = 500; | |
| pub const MaxLocks: u32 = 50; | |
| } | |
| impl pallet_balances::Trait for Runtime { | |
| type MaxLocks = MaxLocks; | |
| /// The type for recording an account's balance. | |
| type Balance = Balance; | |
| /// The ubiquitous event type. | |
| type Event = Event; | |
| type DustRemoval = (); | |
| type ExistentialDeposit = ExistentialDeposit; | |
| type AccountStore = System; | |
| type WeightInfo = (); | |
| } | |
| parameter_types! { | |
| pub const TransactionByteFee: Balance = 1; | |
| } | |
| impl pallet_transaction_payment::Trait for Runtime { | |
| type Currency = Balances; | |
| type OnTransactionPayment = (); | |
| type TransactionByteFee = TransactionByteFee; | |
| type WeightToFee = IdentityFee<Balance>; | |
| type FeeMultiplierUpdate = (); | |
| } | |
| impl pallet_sudo::Trait for Runtime { | |
| type Event = Event; | |
| type Call = Call; | |
| } | |
| /// Configure the template pallet in pallets/template. | |
| impl pallet_template::Trait for Runtime { | |
| type Event = Event; | |
| } | |
| impl orml_nft::Trait for Runtime { | |
| type ClassId = u64; | |
| type TokenId = u64; | |
| type ClassData = (); | |
| type TokenData = (); | |
| } | |
| // Create the runtime by composing the FRAME pallets that were previously configured. | |
| construct_runtime!( | |
| pub enum Runtime where | |
| Block = Block, | |
| NodeBlock = opaque::Block, | |
| UncheckedExtrinsic = UncheckedExtrinsic | |
| { | |
| System: frame_system::{Module, Call, Config, Storage, Event<T>}, | |
| RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Module, Call, Storage}, | |
| Timestamp: pallet_timestamp::{Module, Call, Storage, Inherent}, | |
| Aura: pallet_aura::{Module, Config<T>, Inherent}, | |
| Grandpa: pallet_grandpa::{Module, Call, Storage, Config, Event}, | |
| Balances: pallet_balances::{Module, Call, Storage, Config<T>, Event<T>}, | |
| TransactionPayment: pallet_transaction_payment::{Module, Storage}, | |
| Sudo: pallet_sudo::{Module, Call, Config<T>, Storage, Event<T>}, | |
| // Include the custom logic from the template pallet in the runtime. | |
| TemplateModule: pallet_template::{Module, Call, Storage, Event<T>}, | |
| OrmlNFT: orml_nft::{Module, Storage, Call}, | |
| } | |
| ); | |
| /// The address format for describing accounts. | |
| pub type Address = AccountId; | |
| /// Block header type as expected by this runtime. | |
| pub type Header = generic::Header<BlockNumber, BlakeTwo256>; | |
| /// Block type as expected by this runtime. | |
| pub type Block = generic::Block<Header, UncheckedExtrinsic>; | |
| /// A Block signed with a Justification | |
| pub type SignedBlock = generic::SignedBlock<Block>; | |
| /// BlockId type as expected by this runtime. | |
| pub type BlockId = generic::BlockId<Block>; | |
| /// The SignedExtension to the basic transaction logic. | |
| pub type SignedExtra = ( | |
| frame_system::CheckSpecVersion<Runtime>, | |
| frame_system::CheckTxVersion<Runtime>, | |
| frame_system::CheckGenesis<Runtime>, | |
| frame_system::CheckEra<Runtime>, | |
| frame_system::CheckNonce<Runtime>, | |
| frame_system::CheckWeight<Runtime>, | |
| pallet_transaction_payment::ChargeTransactionPayment<Runtime> | |
| ); | |
| /// Unchecked extrinsic type as expected by this runtime. | |
| pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>; | |
| /// Extrinsic type that has already been checked. | |
| pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>; | |
| /// Executive: handles dispatch to the various modules. | |
| pub type Executive = frame_executive::Executive< | |
| Runtime, | |
| Block, | |
| frame_system::ChainContext<Runtime>, | |
| Runtime, | |
| AllModules, | |
| >; | |
| impl_runtime_apis! { | |
| impl sp_api::Core<Block> for Runtime { | |
| fn version() -> RuntimeVersion { | |
| VERSION | |
| } | |
| fn execute_block(block: Block) { | |
| Executive::execute_block(block) | |
| } | |
| fn initialize_block(header: &<Block as BlockT>::Header) { | |
| Executive::initialize_block(header) | |
| } | |
| } | |
| impl sp_api::Metadata<Block> for Runtime { | |
| fn metadata() -> OpaqueMetadata { | |
| Runtime::metadata().into() | |
| } | |
| } | |
| impl sp_block_builder::BlockBuilder<Block> for Runtime { | |
| fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult { | |
| Executive::apply_extrinsic(extrinsic) | |
| } | |
| fn finalize_block() -> <Block as BlockT>::Header { | |
| Executive::finalize_block() | |
| } | |
| fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> { | |
| data.create_extrinsics() | |
| } | |
| fn check_inherents( | |
| block: Block, | |
| data: sp_inherents::InherentData, | |
| ) -> sp_inherents::CheckInherentsResult { | |
| data.check_extrinsics(&block) | |
| } | |
| fn random_seed() -> <Block as BlockT>::Hash { | |
| RandomnessCollectiveFlip::random_seed() | |
| } | |
| } | |
| impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime { | |
| fn validate_transaction( | |
| source: TransactionSource, | |
| tx: <Block as BlockT>::Extrinsic, | |
| ) -> TransactionValidity { | |
| Executive::validate_transaction(source, tx) | |
| } | |
| } | |
| impl sp_offchain::OffchainWorkerApi<Block> for Runtime { | |
| fn offchain_worker(header: &<Block as BlockT>::Header) { | |
| Executive::offchain_worker(header) | |
| } | |
| } | |
| impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime { | |
| fn slot_duration() -> u64 { | |
| Aura::slot_duration() | |
| } | |
| fn authorities() -> Vec<AuraId> { | |
| Aura::authorities() | |
| } | |
| } | |
| impl sp_session::SessionKeys<Block> for Runtime { | |
| fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> { | |
| opaque::SessionKeys::generate(seed) | |
| } | |
| fn decode_session_keys( | |
| encoded: Vec<u8>, | |
| ) -> Option<Vec<(Vec<u8>, KeyTypeId)>> { | |
| opaque::SessionKeys::decode_into_raw_public_keys(&encoded) | |
| } | |
| } | |
| impl fg_primitives::GrandpaApi<Block> for Runtime { | |
| fn grandpa_authorities() -> GrandpaAuthorityList { | |
| Grandpa::grandpa_authorities() | |
| } | |
| fn submit_report_equivocation_unsigned_extrinsic( | |
| _equivocation_proof: fg_primitives::EquivocationProof< | |
| <Block as BlockT>::Hash, | |
| NumberFor<Block>, | |
| >, | |
| _key_owner_proof: fg_primitives::OpaqueKeyOwnershipProof, | |
| ) -> Option<()> { | |
| None | |
| } | |
| fn generate_key_ownership_proof( | |
| _set_id: fg_primitives::SetId, | |
| _authority_id: GrandpaId, | |
| ) -> Option<fg_primitives::OpaqueKeyOwnershipProof> { | |
| // NOTE: this is the only implementation possible since we've | |
| // defined our key owner proof type as a bottom type (i.e. a type | |
| // with no values). | |
| None | |
| } | |
| } | |
| impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime { | |
| fn account_nonce(account: AccountId) -> Index { | |
| System::account_nonce(account) | |
| } | |
| } | |
| impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime { | |
| fn query_info( | |
| uxt: <Block as BlockT>::Extrinsic, | |
| len: u32, | |
| ) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo<Balance> { | |
| TransactionPayment::query_info(uxt, len) | |
| } | |
| } | |
| #[cfg(feature = "runtime-benchmarks")] | |
| impl frame_benchmarking::Benchmark<Block> for Runtime { | |
| fn dispatch_benchmark( | |
| config: frame_benchmarking::BenchmarkConfig | |
| ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> { | |
| use frame_benchmarking::{Benchmarking, BenchmarkBatch, add_benchmark, TrackedStorageKey}; | |
| use frame_system_benchmarking::Module as SystemBench; | |
| impl frame_system_benchmarking::Trait for Runtime {} | |
| let whitelist: Vec<TrackedStorageKey> = vec![ | |
| // Block Number | |
| hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(), | |
| // Total Issuance | |
| hex_literal::hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(), | |
| // Execution Phase | |
| hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(), | |
| // Event Count | |
| hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(), | |
| // System Events | |
| hex_literal::hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(), | |
| ]; | |
| let mut batches = Vec::<BenchmarkBatch>::new(); | |
| let params = (&config, &whitelist); | |
| add_benchmark!(params, batches, frame_system, SystemBench::<Runtime>); | |
| add_benchmark!(params, batches, pallet_balances, Balances); | |
| add_benchmark!(params, batches, pallet_timestamp, Timestamp); | |
| if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) } | |
| Ok(batches) | |
| } | |
| } | |
| } |
Author
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Using my custom pallet: