git.delta.rocks / unique-network / refs/commits / a1ee59a87cde

1//! The Substrate Node Template runtime. This can be compiled with `#[no_std]`, ready for Wasm.23#![cfg_attr(not(feature = "std"), no_std)]4// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.5#![recursion_limit = "256"]67// Make the WASM binary available.8#[cfg(feature = "std")]9include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));1011use grandpa::fg_primitives;12use grandpa::AuthorityList as GrandpaAuthorityList;13use sp_api::impl_runtime_apis;14use sp_consensus_aura::sr25519::AuthorityId as AuraId;15use sp_core::OpaqueMetadata;16use sp_runtime::traits::{17    BlakeTwo256, Block as BlockT, ConvertInto, IdentifyAccount, IdentityLookup, Verify,18};19use sp_runtime::{20    create_runtime_str, generic, impl_opaque_keys,21    transaction_validity::{TransactionSource, TransactionValidity},22    ApplyExtrinsicResult, MultiSignature,23};24use sp_std::prelude::*;25#[cfg(feature = "std")]26use sp_version::NativeVersion;27use sp_version::RuntimeVersion;2829// A few exports that help ease life for downstream crates.30pub use balances::Call as BalancesCall;31pub use frame_support::{32    construct_runtime, parameter_types, traits::Randomness, weights::Weight, StorageValue,33};34#[cfg(any(feature = "std", test))]35pub use sp_runtime::BuildStorage;36pub use sp_runtime::{Perbill, Permill};37pub use timestamp::Call as TimestampCall;3839/// Importing a template pallet40pub use nft;4142/// An index to a block.43pub type BlockNumber = u32;4445/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.46pub type Signature = MultiSignature;4748/// Some way of identifying an account on the chain. We intentionally make it equivalent49/// to the public key of our transaction signing scheme.50pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;5152/// The type for looking up accounts. We don't expect more than 4 billion of them, but you53/// never know...54pub type AccountIndex = u32;5556/// Balance of an account.57pub type Balance = u128;5859/// Index of a transaction in the chain.60pub type Index = u32;6162/// A hash of some data used by the chain.63pub type Hash = sp_core::H256;6465/// Digest item type.66pub type DigestItem = generic::DigestItem<Hash>;6768/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know69/// the specifics of the runtime. They can then be made to be agnostic over specific formats70/// of data like extrinsics, allowing for them to continue syncing the network through upgrades71/// to even the core data structures.72pub mod opaque {73    use super::*;7475    pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;7677    /// Opaque block header type.78    pub type Header = generic::Header<BlockNumber, BlakeTwo256>;79    /// Opaque block type.80    pub type Block = generic::Block<Header, UncheckedExtrinsic>;81    /// Opaque block identifier type.82    pub type BlockId = generic::BlockId<Block>;8384    impl_opaque_keys! {85        pub struct SessionKeys {86            pub aura: Aura,87            pub grandpa: Grandpa,88        }89    }90}9192/// This runtime version.93pub const VERSION: RuntimeVersion = RuntimeVersion {94    spec_name: create_runtime_str!("nft"),95    impl_name: create_runtime_str!("nft"),96    authoring_version: 1,97    spec_version: 1,98    impl_version: 1,99    apis: RUNTIME_API_VERSIONS,100};101102pub const MILLISECS_PER_BLOCK: u64 = 6000;103104pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;105106// These time units are defined in number of blocks.107pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);108pub const HOURS: BlockNumber = MINUTES * 60;109pub const DAYS: BlockNumber = HOURS * 24;110111/// The version information used to identify this runtime when compiled natively.112#[cfg(feature = "std")]113pub fn native_version() -> NativeVersion {114    NativeVersion {115        runtime_version: VERSION,116        can_author_with: Default::default(),117    }118}119120parameter_types! {121    pub const BlockHashCount: BlockNumber = 250;122    pub const MaximumBlockWeight: Weight = 1_000_000_000;123    pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);124    pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;125    pub const Version: RuntimeVersion = VERSION;126}127128impl system::Trait for Runtime {129    /// The identifier used to distinguish between accounts.130    type AccountId = AccountId;131    /// The aggregated dispatch type that is available for extrinsics.132    type Call = Call;133    /// The lookup mechanism to get account ID from whatever is passed in dispatchers.134    type Lookup = IdentityLookup<AccountId>;135    /// The index type for storing how many extrinsics an account has signed.136    type Index = Index;137    /// The index type for blocks.138    type BlockNumber = BlockNumber;139    /// The type for hashing blocks and tries.140    type Hash = Hash;141    /// The hashing algorithm used.142    type Hashing = BlakeTwo256;143    /// The header type.144    type Header = generic::Header<BlockNumber, BlakeTwo256>;145    /// The ubiquitous event type.146    type Event = Event;147    /// The ubiquitous origin type.148    type Origin = Origin;149    /// Maximum number of block number to block hash mappings to keep (oldest pruned first).150    type BlockHashCount = BlockHashCount;151    /// Maximum weight of each block.152    type MaximumBlockWeight = MaximumBlockWeight;153    /// Maximum size of all encoded transactions (in bytes) that are allowed in one block.154    type MaximumBlockLength = MaximumBlockLength;155    /// Portion of the block weight that is available to all normal transactions.156    type AvailableBlockRatio = AvailableBlockRatio;157    /// Version of the runtime.158    type Version = Version;159    /// Converts a module to the index of the module in `construct_runtime!`.160    ///161    /// This type is being generated by `construct_runtime!`.162    type ModuleToIndex = ModuleToIndex;163    /// What to do if a new account is created.164    type OnNewAccount = ();165    /// What to do if an account is fully reaped from the system.166    type OnKilledAccount = ();167    /// The data to be stored in an account.168    type AccountData = balances::AccountData<Balance>;169}170171impl aura::Trait for Runtime {172    type AuthorityId = AuraId;173}174175impl grandpa::Trait for Runtime {176    type Event = Event;177}178179parameter_types! {180    pub const MinimumPeriod: u64 = SLOT_DURATION / 2;181}182183impl timestamp::Trait for Runtime {184    /// A timestamp: milliseconds since the unix epoch.185    type Moment = u64;186    type OnTimestampSet = Aura;187    type MinimumPeriod = MinimumPeriod;188}189190parameter_types! {191    pub const ExistentialDeposit: u128 = 500;192}193194impl balances::Trait for Runtime {195    /// The type for recording an account's balance.196    type Balance = Balance;197    /// The ubiquitous event type.198    type Event = Event;199    type DustRemoval = ();200    type ExistentialDeposit = ExistentialDeposit;201    type AccountStore = System;202}203204parameter_types! {205    pub const TransactionBaseFee: Balance = 0;206    pub const TransactionByteFee: Balance = 1;207}208209impl transaction_payment::Trait for Runtime {210    type Currency = balances::Module<Runtime>;211    type OnTransactionPayment = ();212    type TransactionBaseFee = TransactionBaseFee;213    type TransactionByteFee = TransactionByteFee;214    type WeightToFee = ConvertInto;215    type FeeMultiplierUpdate = ();216}217218impl sudo::Trait for Runtime {219    type Event = Event;220    type Call = Call;221}222223/// Used for the module template in `./template.rs`224impl nft::Trait for Runtime {225    type Event = Event;226}227228construct_runtime!(229    pub enum Runtime where230        Block = Block,231        NodeBlock = opaque::Block,232        UncheckedExtrinsic = UncheckedExtrinsic233    {234        System: system::{Module, Call, Config, Storage, Event<T>},235        RandomnessCollectiveFlip: randomness_collective_flip::{Module, Call, Storage},236        Timestamp: timestamp::{Module, Call, Storage, Inherent},237        Aura: aura::{Module, Config<T>, Inherent(Timestamp)},238        Grandpa: grandpa::{Module, Call, Storage, Config, Event},239        Balances: balances::{Module, Call, Storage, Config<T>, Event<T>},240        TransactionPayment: transaction_payment::{Module, Storage},241        Sudo: sudo::{Module, Call, Config<T>, Storage, Event<T>},242        // Used for the module template in `./template.rs`243        Nft: nft::{Module, Call, Storage, Event<T>},244    }245);246247/// The address format for describing accounts.248pub type Address = AccountId;249/// Block header type as expected by this runtime.250pub type Header = generic::Header<BlockNumber, BlakeTwo256>;251/// Block type as expected by this runtime.252pub type Block = generic::Block<Header, UncheckedExtrinsic>;253/// A Block signed with a Justification254pub type SignedBlock = generic::SignedBlock<Block>;255/// BlockId type as expected by this runtime.256pub type BlockId = generic::BlockId<Block>;257/// The SignedExtension to the basic transaction logic.258pub type SignedExtra = (259    system::CheckVersion<Runtime>,260    system::CheckGenesis<Runtime>,261    system::CheckEra<Runtime>,262    system::CheckNonce<Runtime>,263    system::CheckWeight<Runtime>,264    transaction_payment::ChargeTransactionPayment<Runtime>,265);266/// Unchecked extrinsic type as expected by this runtime.267pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;268/// Extrinsic type that has already been checked.269pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>;270/// Executive: handles dispatch to the various modules.271pub type Executive =272    frame_executive::Executive<Runtime, Block, system::ChainContext<Runtime>, Runtime, AllModules>;273274impl_runtime_apis! {275    impl sp_api::Core<Block> for Runtime {276        fn version() -> RuntimeVersion {277            VERSION278        }279280        fn execute_block(block: Block) {281            Executive::execute_block(block)282        }283284        fn initialize_block(header: &<Block as BlockT>::Header) {285            Executive::initialize_block(header)286        }287    }288289    impl sp_api::Metadata<Block> for Runtime {290        fn metadata() -> OpaqueMetadata {291            Runtime::metadata().into()292        }293    }294295    impl sp_block_builder::BlockBuilder<Block> for Runtime {296        fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {297            Executive::apply_extrinsic(extrinsic)298        }299300        fn finalize_block() -> <Block as BlockT>::Header {301            Executive::finalize_block()302        }303304        fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {305            data.create_extrinsics()306        }307308        fn check_inherents(309            block: Block,310            data: sp_inherents::InherentData,311        ) -> sp_inherents::CheckInherentsResult {312            data.check_extrinsics(&block)313        }314315        fn random_seed() -> <Block as BlockT>::Hash {316            RandomnessCollectiveFlip::random_seed()317        }318    }319320    impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {321        fn validate_transaction(322            source: TransactionSource,323            tx: <Block as BlockT>::Extrinsic,324        ) -> TransactionValidity {325            Executive::validate_transaction(source, tx)326        }327    }328329    impl sp_offchain::OffchainWorkerApi<Block> for Runtime {330        fn offchain_worker(header: &<Block as BlockT>::Header) {331            Executive::offchain_worker(header)332        }333    }334335    impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {336        fn slot_duration() -> u64 {337            Aura::slot_duration()338        }339340        fn authorities() -> Vec<AuraId> {341            Aura::authorities()342        }343    }344345    impl sp_session::SessionKeys<Block> for Runtime {346        fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {347            opaque::SessionKeys::generate(seed)348        }349350        fn decode_session_keys(351            encoded: Vec<u8>,352        ) -> Option<Vec<(Vec<u8>, sp_core::crypto::KeyTypeId)>> {353            opaque::SessionKeys::decode_into_raw_public_keys(&encoded)354        }355    }356357    impl fg_primitives::GrandpaApi<Block> for Runtime {358        fn grandpa_authorities() -> GrandpaAuthorityList {359            Grandpa::grandpa_authorities()360        }361    }362}