git.delta.rocks / unique-network / refs/commits / 333b2b4b7046

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 sp_std::prelude::*;12use sp_core::OpaqueMetadata;13use sp_runtime::{14	ApplyExtrinsicResult, transaction_validity::TransactionValidity, generic, create_runtime_str,15	impl_opaque_keys, MultiSignature,16};17use sp_runtime::traits::{18	BlakeTwo256, Block as BlockT, IdentityLookup, Verify, ConvertInto, IdentifyAccount19};20use sp_api::impl_runtime_apis;21use sp_consensus_aura::sr25519::AuthorityId as AuraId;22use grandpa::AuthorityList as GrandpaAuthorityList;23use grandpa::fg_primitives;24use sp_version::RuntimeVersion;25#[cfg(feature = "std")]26use sp_version::NativeVersion;2728// A few exports that help ease life for downstream crates.29#[cfg(any(feature = "std", test))]30pub use sp_runtime::BuildStorage;31pub use timestamp::Call as TimestampCall;32pub use balances::Call as BalancesCall;33pub use sp_runtime::{Permill, Perbill};34pub use frame_support::{35	StorageValue, construct_runtime, parameter_types,36	traits::Randomness,37	weights::Weight,38};3940/// Importing a template pallet41pub use template;4243/// An index to a block.44pub type BlockNumber = u32;4546/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.47pub type Signature = MultiSignature;4849/// Some way of identifying an account on the chain. We intentionally make it equivalent50/// to the public key of our transaction signing scheme.51pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;5253/// The type for looking up accounts. We don't expect more than 4 billion of them, but you54/// never know...55pub type AccountIndex = u32;5657/// Balance of an account.58pub type Balance = u128;5960/// Index of a transaction in the chain.61pub type Index = u32;6263/// A hash of some data used by the chain.64pub type Hash = sp_core::H256;6566/// Digest item type.67pub type DigestItem = generic::DigestItem<Hash>;6869/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know70/// the specifics of the runtime. They can then be made to be agnostic over specific formats71/// of data like extrinsics, allowing for them to continue syncing the network through upgrades72/// to even the core data structures.73pub mod opaque {74	use super::*;7576	pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;7778	/// Opaque block header type.79	pub type Header = generic::Header<BlockNumber, BlakeTwo256>;80	/// Opaque block type.81	pub type Block = generic::Block<Header, UncheckedExtrinsic>;82	/// Opaque block identifier type.83	pub type BlockId = generic::BlockId<Block>;8485	impl_opaque_keys! {86		pub struct SessionKeys {87			pub aura: Aura,88			pub grandpa: Grandpa,89		}90	}91}9293/// This runtime version.94pub const VERSION: RuntimeVersion = RuntimeVersion {95	spec_name: create_runtime_str!("node-template"),96	impl_name: create_runtime_str!("node-template"),97	authoring_version: 1,98	spec_version: 1,99	impl_version: 1,100	apis: RUNTIME_API_VERSIONS,101};102103pub const MILLISECS_PER_BLOCK: u64 = 6000;104105pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;106107// These time units are defined in number of blocks.108pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);109pub const HOURS: BlockNumber = MINUTES * 60;110pub const DAYS: BlockNumber = HOURS * 24;111112/// The version information used to identify this runtime when compiled natively.113#[cfg(feature = "std")]114pub fn native_version() -> NativeVersion {115	NativeVersion {116		runtime_version: VERSION,117		can_author_with: Default::default(),118	}119}120121parameter_types! {122	pub const BlockHashCount: BlockNumber = 250;123	pub const MaximumBlockWeight: Weight = 1_000_000_000;124	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);125	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;126	pub const Version: RuntimeVersion = VERSION;127}128129impl system::Trait for Runtime {130	/// The identifier used to distinguish between accounts.131	type AccountId = AccountId;132	/// The aggregated dispatch type that is available for extrinsics.133	type Call = Call;134	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.135	type Lookup = IdentityLookup<AccountId>;136	/// The index type for storing how many extrinsics an account has signed.137	type Index = Index;138	/// The index type for blocks.139	type BlockNumber = BlockNumber;140	/// The type for hashing blocks and tries.141	type Hash = Hash;142	/// The hashing algorithm used.143	type Hashing = BlakeTwo256;144	/// The header type.145	type Header = generic::Header<BlockNumber, BlakeTwo256>;146	/// The ubiquitous event type.147	type Event = Event;148	/// The ubiquitous origin type.149	type Origin = Origin;150	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).151	type BlockHashCount = BlockHashCount;152	/// Maximum weight of each block.153	type MaximumBlockWeight = MaximumBlockWeight;154	/// Maximum size of all encoded transactions (in bytes) that are allowed in one block.155	type MaximumBlockLength = MaximumBlockLength;156	/// Portion of the block weight that is available to all normal transactions.157	type AvailableBlockRatio = AvailableBlockRatio;158	/// Version of the runtime.159	type Version = Version;160	/// Converts a module to the index of the module in `construct_runtime!`.161	///162	/// This type is being generated by `construct_runtime!`.163	type ModuleToIndex = ModuleToIndex;164	/// What to do if a new account is created.165	type OnNewAccount = ();166	/// What to do if an account is fully reaped from the system.167	type OnKilledAccount = ();168	/// The data to be stored in an account.169	type AccountData = balances::AccountData<Balance>;170}171172impl aura::Trait for Runtime {173	type AuthorityId = AuraId;174}175176impl grandpa::Trait for Runtime {177	type Event = Event;178}179180parameter_types! {181	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;182}183184impl timestamp::Trait for Runtime {185	/// A timestamp: milliseconds since the unix epoch.186	type Moment = u64;187	type OnTimestampSet = Aura;188	type MinimumPeriod = MinimumPeriod;189}190191parameter_types! {192	pub const ExistentialDeposit: u128 = 500;193}194195impl balances::Trait for Runtime {196	/// The type for recording an account's balance.197	type Balance = Balance;198	/// The ubiquitous event type.199	type Event = Event;200	type DustRemoval = ();201	type ExistentialDeposit = ExistentialDeposit;202	type AccountStore = System;203}204205parameter_types! {206	pub const TransactionBaseFee: Balance = 0;207	pub const TransactionByteFee: Balance = 1;208}209210impl transaction_payment::Trait for Runtime {211	type Currency = balances::Module<Runtime>;212	type OnTransactionPayment = ();213	type TransactionBaseFee = TransactionBaseFee;214	type TransactionByteFee = TransactionByteFee;215	type WeightToFee = ConvertInto;216	type FeeMultiplierUpdate = ();217}218219impl sudo::Trait for Runtime {220	type Event = Event;221	type Call = Call;222}223224/// Used for the module template in `./template.rs`225impl template::Trait for Runtime {226	type Event = Event;227}228229construct_runtime!(230	pub enum Runtime where231		Block = Block,232		NodeBlock = opaque::Block,233		UncheckedExtrinsic = UncheckedExtrinsic234	{235		System: system::{Module, Call, Config, Storage, Event<T>},236		RandomnessCollectiveFlip: randomness_collective_flip::{Module, Call, Storage},237		Timestamp: timestamp::{Module, Call, Storage, Inherent},238		Aura: aura::{Module, Config<T>, Inherent(Timestamp)},239		Grandpa: grandpa::{Module, Call, Storage, Config, Event},240		Balances: balances::{Module, Call, Storage, Config<T>, Event<T>},241		TransactionPayment: transaction_payment::{Module, Storage},242		Sudo: sudo::{Module, Call, Config<T>, Storage, Event<T>},243		// Used for the module template in `./template.rs`244		TemplateModule: template::{Module, Call, Storage, Event<T>},245	}246);247248/// The address format for describing accounts.249pub type Address = AccountId;250/// Block header type as expected by this runtime.251pub type Header = generic::Header<BlockNumber, BlakeTwo256>;252/// Block type as expected by this runtime.253pub type Block = generic::Block<Header, UncheckedExtrinsic>;254/// A Block signed with a Justification255pub type SignedBlock = generic::SignedBlock<Block>;256/// BlockId type as expected by this runtime.257pub type BlockId = generic::BlockId<Block>;258/// The SignedExtension to the basic transaction logic.259pub type SignedExtra = (260	system::CheckVersion<Runtime>,261	system::CheckGenesis<Runtime>,262	system::CheckEra<Runtime>,263	system::CheckNonce<Runtime>,264	system::CheckWeight<Runtime>,265	transaction_payment::ChargeTransactionPayment<Runtime>266);267/// Unchecked extrinsic type as expected by this runtime.268pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;269/// Extrinsic type that has already been checked.270pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>;271/// Executive: handles dispatch to the various modules.272pub type Executive = 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 apply_trusted_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {301			Executive::apply_trusted_extrinsic(extrinsic)302		}303304		fn finalize_block() -> <Block as BlockT>::Header {305			Executive::finalize_block()306		}307308		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {309			data.create_extrinsics()310		}311312		fn check_inherents(313			block: Block,314			data: sp_inherents::InherentData,315		) -> sp_inherents::CheckInherentsResult {316			data.check_extrinsics(&block)317		}318319		fn random_seed() -> <Block as BlockT>::Hash {320			RandomnessCollectiveFlip::random_seed()321		}322	}323324	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {325		fn validate_transaction(tx: <Block as BlockT>::Extrinsic) -> TransactionValidity {326			Executive::validate_transaction(tx)327		}328	}329330	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {331		fn offchain_worker(header: &<Block as BlockT>::Header) {332			Executive::offchain_worker(header)333		}334	}335336	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {337		fn slot_duration() -> u64 {338			Aura::slot_duration()339		}340341		fn authorities() -> Vec<AuraId> {342			Aura::authorities()343		}344	}345346	impl sp_session::SessionKeys<Block> for Runtime {347		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {348			opaque::SessionKeys::generate(seed)349		}350351		fn decode_session_keys(352			encoded: Vec<u8>,353		) -> Option<Vec<(Vec<u8>, sp_core::crypto::KeyTypeId)>> {354			opaque::SessionKeys::decode_into_raw_public_keys(&encoded)355		}356	}357358	impl fg_primitives::GrandpaApi<Block> for Runtime {359		fn grandpa_authorities() -> GrandpaAuthorityList {360			Grandpa::grandpa_authorities()361		}362	}363}