git.delta.rocks / unique-network / refs/commits / 155e1bb08754

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 contracts_rpc_runtime_api::ContractExecResult;12use grandpa::fg_primitives;13use grandpa::{AuthorityId as GrandpaId, AuthorityList as GrandpaAuthorityList};14use sp_api::impl_runtime_apis;15use sp_consensus_aura::sr25519::AuthorityId as AuraId;16use sp_core::{crypto::KeyTypeId, OpaqueMetadata};17use sp_runtime::{18    create_runtime_str, generic, impl_opaque_keys,19    transaction_validity::{TransactionSource, TransactionValidity},20    ApplyExtrinsicResult, MultiSignature,21	traits::{22        BlakeTwo256, Block as BlockT, IdentifyAccount, IdentityLookup, NumberFor, Saturating, Verify,23	},24};25use sp_std::prelude::*;26#[cfg(feature = "std")]27use sp_version::NativeVersion;28use sp_version::RuntimeVersion;2930// A few exports that help ease life for downstream crates.31pub use balances::Call as BalancesCall;32pub use contracts::Schedule as ContractsSchedule;33pub use frame_support::{34    construct_runtime, parameter_types,35    traits::{Currency, Get, ExistenceRequirement, KeyOwnerProofSystem, OnUnbalanced, Randomness, WithdrawReason},36    weights::{37        DispatchInfo, PostDispatchInfo, constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},38        IdentityFee, Weight, WeightToFeePolynomial, GetDispatchInfo, Pays,39    },40    StorageValue,41	dispatch::DispatchResult,42};43use system::{self as system};44#[cfg(any(feature = "std", test))]45pub use sp_runtime::BuildStorage;46use sp_runtime::{47	Perbill,48};495051pub use timestamp::Call as TimestampCall;5253/// Importing a nft pallet54pub use nft;5556/// An index to a block.57pub type BlockNumber = u32;5859/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.60pub type Signature = MultiSignature;6162/// Some way of identifying an account on the chain. We intentionally make it equivalent63/// to the public key of our transaction signing scheme.64pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;6566/// The type for looking up accounts. We don't expect more than 4 billion of them, but you67/// never know...68pub type AccountIndex = u32;6970/// Balance of an account.71pub type Balance = u128;7273/// Index of a transaction in the chain.74pub type Index = u32;7576/// A hash of some data used by the chain.77pub type Hash = sp_core::H256;7879/// Digest item type.80pub type DigestItem = generic::DigestItem<Hash>;8182/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know83/// the specifics of the runtime. They can then be made to be agnostic over specific formats84/// of data like extrinsics, allowing for them to continue syncing the network through upgrades85/// to even the core data structures.86pub mod opaque {87    use super::*;8889    pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;9091    /// Opaque block header type.92    pub type Header = generic::Header<BlockNumber, BlakeTwo256>;93    /// Opaque block type.94    pub type Block = generic::Block<Header, UncheckedExtrinsic>;95    /// Opaque block identifier type.96    pub type BlockId = generic::BlockId<Block>;9798    impl_opaque_keys! {99        pub struct SessionKeys {100            pub aura: Aura,101            pub grandpa: Grandpa,102        }103    }104}105106/// This runtime version.107pub const VERSION: RuntimeVersion = RuntimeVersion {108    spec_name: create_runtime_str!("nft"),109    impl_name: create_runtime_str!("nft"),110    authoring_version: 1,111    spec_version: 1,112    impl_version: 1,113    apis: RUNTIME_API_VERSIONS,114    transaction_version: 1,115};116117pub const MILLISECS_PER_BLOCK: u64 = 6000;118119pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;120121// These time units are defined in number of blocks.122pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);123pub const HOURS: BlockNumber = MINUTES * 60;124pub const DAYS: BlockNumber = HOURS * 24;125126/// The version information used to identify this runtime when compiled natively.127#[cfg(feature = "std")]128pub fn native_version() -> NativeVersion {129    NativeVersion {130        runtime_version: VERSION,131        can_author_with: Default::default(),132    }133}134135parameter_types! {136    pub const BlockHashCount: BlockNumber = 2400;137    /// We allow for 2 seconds of compute with a 6 second average block time.138    pub const MaximumBlockWeight: Weight = 2 * WEIGHT_PER_SECOND;139    pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);140    /// Assume 10% of weight for average on_initialize calls.141    pub MaximumExtrinsicWeight: Weight = AvailableBlockRatio::get()142        .saturating_sub(Perbill::from_percent(10)) * MaximumBlockWeight::get();143    pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;144    pub const Version: RuntimeVersion = VERSION;145}146147impl system::Trait for Runtime {148    /// The basic call filter to use in dispatchable.149    type BaseCallFilter = ();150    /// The identifier used to distinguish between accounts.151    type AccountId = AccountId;152    /// The aggregated dispatch type that is available for extrinsics.153    type Call = Call;154    /// The lookup mechanism to get account ID from whatever is passed in dispatchers.155    type Lookup = IdentityLookup<AccountId>;156    /// The index type for storing how many extrinsics an account has signed.157    type Index = Index;158    /// The index type for blocks.159    type BlockNumber = BlockNumber;160    /// The type for hashing blocks and tries.161    type Hash = Hash;162    /// The hashing algorithm used.163    type Hashing = BlakeTwo256;164    /// The header type.165    type Header = generic::Header<BlockNumber, BlakeTwo256>;166    /// The ubiquitous event type.167    type Event = Event;168    /// The ubiquitous origin type.169    type Origin = Origin;170    /// Maximum number of block number to block hash mappings to keep (oldest pruned first).171    type BlockHashCount = BlockHashCount;172    /// Maximum weight of each block.173    type MaximumBlockWeight = MaximumBlockWeight;174    /// The weight of database operations that the runtime can invoke.175    type DbWeight = RocksDbWeight;176    /// The weight of the overhead invoked on the block import process, independent of the177    /// extrinsics included in that block.178    type BlockExecutionWeight = BlockExecutionWeight;179    /// The base weight of any extrinsic processed by the runtime, independent of the180    /// logic of that extrinsic. (Signature verification, nonce increment, fee, etc...)181    type ExtrinsicBaseWeight = ExtrinsicBaseWeight;182    /// The maximum weight that a single extrinsic of `Normal` dispatch class can have,183    /// idependent of the logic of that extrinsics. (Roughly max block weight - average on184    /// initialize cost).185    type MaximumExtrinsicWeight = MaximumExtrinsicWeight;186    /// Maximum size of all encoded transactions (in bytes) that are allowed in one block.187    type MaximumBlockLength = MaximumBlockLength;188    /// Portion of the block weight that is available to all normal transactions.189    type AvailableBlockRatio = AvailableBlockRatio;190    /// Version of the runtime.191    type Version = Version;192    /// Converts a module to the index of the module in `construct_runtime!`.193    ///194    /// This type is being generated by `construct_runtime!`.195    type ModuleToIndex = ModuleToIndex;196    /// What to do if a new account is created.197    type OnNewAccount = ();198    /// What to do if an account is fully reaped from the system.199    type OnKilledAccount = ();200    /// The data to be stored in an account.201    type AccountData = balances::AccountData<Balance>;202}203204impl aura::Trait for Runtime {205    type AuthorityId = AuraId;206}207208impl grandpa::Trait for Runtime {209    type Event = Event;210    type Call = Call;211212    type KeyOwnerProofSystem = ();213214    type KeyOwnerProof =215        <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, GrandpaId)>>::Proof;216217    type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(218        KeyTypeId,219        GrandpaId,220    )>>::IdentificationTuple;221222    type HandleEquivocation = ();223}224225parameter_types! {226    pub const MinimumPeriod: u64 = SLOT_DURATION / 2;227}228229impl timestamp::Trait for Runtime {230    /// A timestamp: milliseconds since the unix epoch.231    type Moment = u64;232    type OnTimestampSet = Aura;233    type MinimumPeriod = MinimumPeriod;234}235236parameter_types! {237    // pub const ExistentialDeposit: u128 = 500;238    pub const ExistentialDeposit: u128 = 0;239}240241impl balances::Trait for Runtime {242    /// The type for recording an account's balance.243    type Balance = Balance;244    /// The ubiquitous event type.245    type Event = Event;246    type DustRemoval = ();247    type ExistentialDeposit = ExistentialDeposit;248    type AccountStore = System;249}250251pub const MILLICENTS: Balance = 1_000_000_000;252pub const CENTS: Balance = 1_000 * MILLICENTS;253pub const DOLLARS: Balance = 100 * CENTS;254255parameter_types! {256    pub const TombstoneDeposit: Balance = 16 * MILLICENTS;257    pub const RentByteFee: Balance = 4 * MILLICENTS;258    pub const RentDepositOffset: Balance = 1000 * MILLICENTS;259    pub const SurchargeReward: Balance = 150 * MILLICENTS;260}261262impl contracts::Trait for Runtime {263    type Call = Call;264    type Time = Timestamp;265    type Randomness = RandomnessCollectiveFlip;266    type Currency = Balances;267    type Event = Event;268    type DetermineContractAddress = contracts::SimpleAddressDeterminer<Runtime>;269    type TrieIdGenerator = contracts::TrieIdFromParentCounter<Runtime>;270    type RentPayment = ();271    type SignedClaimHandicap = contracts::DefaultSignedClaimHandicap;272    type TombstoneDeposit = TombstoneDeposit;273    type StorageSizeOffset = contracts::DefaultStorageSizeOffset;274    type RentByteFee = RentByteFee;275    type RentDepositOffset = RentDepositOffset;276    type SurchargeReward = SurchargeReward;277    type MaxDepth = contracts::DefaultMaxDepth;278    type MaxValueSize = contracts::DefaultMaxValueSize;279    type WeightPrice = transaction_payment::Module<Self>;280}281282parameter_types! {283    pub const TransactionByteFee: Balance = 1;284}285286impl transaction_payment::Trait for Runtime {287    type Currency = balances::Module<Runtime>;288    type OnTransactionPayment = ();289    type TransactionByteFee = TransactionByteFee;290    type WeightToFee = IdentityFee<Balance>;291    type FeeMultiplierUpdate = ();292}293294impl sudo::Trait for Runtime {295    type Event = Event;296    type Call = Call;297}298299/// Used for the module nft in `./nft.rs`300impl nft::Trait for Runtime {301    type Event = Event;302}303304construct_runtime!(305    pub enum Runtime where306        Block = Block,307        NodeBlock = opaque::Block,308        UncheckedExtrinsic = UncheckedExtrinsic309    {310        System: system::{Module, Call, Config, Storage, Event<T>},311        RandomnessCollectiveFlip: randomness_collective_flip::{Module, Call, Storage},312        Contracts: contracts::{Module, Call, Config, Storage, Event<T>},313        Timestamp: timestamp::{Module, Call, Storage, Inherent},314        Aura: aura::{Module, Config<T>, Inherent(Timestamp)},315        Grandpa: grandpa::{Module, Call, Storage, Config, Event},316        Balances: balances::{Module, Call, Storage, Config<T>, Event<T>},317        TransactionPayment: transaction_payment::{Module, Storage},318        Sudo: sudo::{Module, Call, Config<T>, Storage, Event<T>},319        Nft: nft::{Module, Call, Storage, Event<T>},320    }321);322323/// The address format for describing accounts.324pub type Address = AccountId;325/// Block header type as expected by this runtime.326pub type Header = generic::Header<BlockNumber, BlakeTwo256>;327/// Block type as expected by this runtime.328pub type Block = generic::Block<Header, UncheckedExtrinsic>;329/// A Block signed with a Justification330pub type SignedBlock = generic::SignedBlock<Block>;331/// BlockId type as expected by this runtime.332pub type BlockId = generic::BlockId<Block>;333/// The SignedExtension to the basic transaction logic.334pub type SignedExtra = (335    system::CheckSpecVersion<Runtime>,336    system::CheckTxVersion<Runtime>,337    system::CheckGenesis<Runtime>,338    system::CheckEra<Runtime>,339    system::CheckNonce<Runtime>,340    system::CheckWeight<Runtime>,341    nft::ChargeTransactionPayment<Runtime>,342);343/// Unchecked extrinsic type as expected by this runtime.344pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;345/// Extrinsic type that has already been checked.346pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>;347/// Executive: handles dispatch to the various modules.348pub type Executive =349    frame_executive::Executive<Runtime, Block, system::ChainContext<Runtime>, Runtime, AllModules>;350351impl_runtime_apis! {352353    impl contracts_rpc_runtime_api::ContractsApi<Block, AccountId, Balance, BlockNumber>354    for Runtime355    {356        fn call(357            origin: AccountId,358            dest: AccountId,359            value: Balance,360            gas_limit: u64,361            input_data: Vec<u8>,362        ) -> ContractExecResult {363            let exec_result =364                Contracts::bare_call(origin, dest.into(), value, gas_limit, input_data);365            match exec_result {366                Ok(v) => ContractExecResult::Success {367                    status: v.status,368                    data: v.data,369                },370                Err(_) => ContractExecResult::Error,371            }372        }373374        fn get_storage(375            address: AccountId,376            key: [u8; 32],377        ) -> contracts_primitives::GetStorageResult {378            Contracts::get_storage(address, key)379        }380381        fn rent_projection(382            address: AccountId,383        ) -> contracts_primitives::RentProjectionResult<BlockNumber> {384            Contracts::rent_projection(address)385        }386    }387388    impl sp_api::Core<Block> for Runtime {389        fn version() -> RuntimeVersion {390            VERSION391        }392393        fn execute_block(block: Block) {394            Executive::execute_block(block)395        }396397        fn initialize_block(header: &<Block as BlockT>::Header) {398            Executive::initialize_block(header)399        }400    }401402    impl sp_api::Metadata<Block> for Runtime {403        fn metadata() -> OpaqueMetadata {404            Runtime::metadata().into()405        }406    }407408    impl sp_block_builder::BlockBuilder<Block> for Runtime {409        fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {410            Executive::apply_extrinsic(extrinsic)411        }412413        fn finalize_block() -> <Block as BlockT>::Header {414            Executive::finalize_block()415        }416417        fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {418            data.create_extrinsics()419        }420421        fn check_inherents(422            block: Block,423            data: sp_inherents::InherentData,424        ) -> sp_inherents::CheckInherentsResult {425            data.check_extrinsics(&block)426        }427428        fn random_seed() -> <Block as BlockT>::Hash {429            RandomnessCollectiveFlip::random_seed()430        }431    }432433    impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {434        fn validate_transaction(435            source: TransactionSource,436            tx: <Block as BlockT>::Extrinsic,437        ) -> TransactionValidity {438            Executive::validate_transaction(source, tx)439        }440    }441442    impl sp_offchain::OffchainWorkerApi<Block> for Runtime {443        fn offchain_worker(header: &<Block as BlockT>::Header) {444            Executive::offchain_worker(header)445        }446    }447448    impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {449        fn slot_duration() -> u64 {450            Aura::slot_duration()451        }452453        fn authorities() -> Vec<AuraId> {454            Aura::authorities()455        }456    }457458    impl sp_session::SessionKeys<Block> for Runtime {459        fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {460            opaque::SessionKeys::generate(seed)461        }462463        fn decode_session_keys(464            encoded: Vec<u8>,465        ) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {466            opaque::SessionKeys::decode_into_raw_public_keys(&encoded)467        }468    }469470    impl fg_primitives::GrandpaApi<Block> for Runtime {471        fn grandpa_authorities() -> GrandpaAuthorityList {472            Grandpa::grandpa_authorities()473        }474475        fn submit_report_equivocation_extrinsic(476            _equivocation_proof: fg_primitives::EquivocationProof<477                <Block as BlockT>::Hash,478                NumberFor<Block>,479            >,480            _key_owner_proof: fg_primitives::OpaqueKeyOwnershipProof,481        ) -> Option<()> {482            None483        }484485        fn generate_key_ownership_proof(486            _set_id: fg_primitives::SetId,487            _authority_id: GrandpaId,488        ) -> Option<fg_primitives::OpaqueKeyOwnershipProof> {489            // NOTE: this is the only implementation possible since we've490            // defined our key owner proof type as a bottom type (i.e. a type491            // with no values).492            None493        }494    }495}496