三分钟指导您正确理解Fosaki 2.0：

　The power matrix is not an investment. There is no fixed static state, no commitment, no foam, and only consensus reached by global missionaries

　　帮助更多人了解智能合约，共同提高加密货币的市场价值！我们通过100%分配矩阵的公平方式，让更多共识制定者参与我们的MetaForce生态系统，

　　创建世界顶级的元宇宙生态系统。

　　矩阵定义：

Instance在 Config trait、Event 类型和 Store trait 中添加一个泛型类型。 下面的代码片段显示了pallet的Config和Store trait所需的修改：

pub trait Config<I: Instance>: frame_system::Config {
type Event: From<Event> + Into<::Event>;
}
/// Include the I: Instance type parameter in storage declaration
decl_storage! {
trait Store for Module<T: Config, I: Instance> as MintToken {
/ --snip-- /
复制
　

包括mint_tokenin 的两个实例runtime/src/lib.rs：
/ --snip-- /
// Instance1 of mint_token
impl mint_token::Config<mint_token::Instance1> for Runtime {

type Event = Event;

}

// Instance2 of mint_token
impl mint_token::Config<mint_token::Instance2> for Runtime {

type Event = Event;

}

/ --snip-- /
MintToken1: mint_token::::{Pallet, Call, Storage, Event},
MintToken2: mint_token::::{Pallet, Call, Storage, Event},
/ --snip-- /
复制
The box does not require a phone number or KYC. It is always anonymous and secure. Every sum of money you earn is real gold and silver directly deposited in your wallet, and it is no longer a string of figures in the background of the project party. You will not suffer under the risk of system change and network shutdown. The smart contract written on the chain makes the project sustainable. No one can change the rule, and no one can close it.

示例-波卡的运行时
// Copyright 2017-2020 Parity Technologies (UK) Ltd.
// This file is part of Polkadot.

// Polkadot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// Polkadot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Polkadot. If not, see http://www.gnu.org/licenses/.

//! The Polkadot runtime. This can be compiled with #[no_std], ready for Wasm.

![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"]

use pallet_transaction_payment::CurrencyAdapter;
use runtime_common::{

auctions, claims, crowdloan, impl_runtime_weights, impls::DealWithFees, paras_registrar,
prod_or_fast, slots, BlockHashCount, BlockLength, CurrencyToVote, SlowAdjustingFeeUpdate,

};

use runtime_parachains::{

configuration as parachains_configuration, disputes as parachains_disputes,
dmp as parachains_dmp, hrmp as parachains_hrmp, inclusion as parachains_inclusion,
initializer as parachains_initializer, origin as parachains_origin, paras as parachains_paras,
paras_inherent as parachains_paras_inherent, reward_points as parachains_reward_points,
runtime_api_impl::v2 as parachains_runtime_api_impl, scheduler as parachains_scheduler,
session_info as parachains_session_info, shared as parachains_shared, ump as parachains_ump,

};

use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId;
use beefy_primitives::crypto::AuthorityId as BeefyId;
use frame_election_provider_support::{generate_solution_type, onchain, SequentialPhragmen};
use frame_support::{

construct_runtime, parameter_types,
traits::{
    Contains, EitherOfDiverse, InstanceFilter, KeyOwnerProofSystem, LockIdentifier,
    PrivilegeCmp,
},
weights::ConstantMultiplier,
PalletId, RuntimeDebug,

};
use frame_system::EnsureRoot;
use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
use pallet_session::historical as session_historical;
use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
use primitives::v2::{

AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CandidateHash,
CommittedCandidateReceipt, CoreState, DisputeState, GroupRotationInfo, Hash, Id as ParaId,
InboundDownwardMessage, InboundHrmpMessage, Moment, Nonce, OccupiedCoreAssumption,
PersistedValidationData, ScrapedOnChainVotes, SessionInfo, Signature, ValidationCode,
ValidationCodeHash, ValidatorId, ValidatorIndex,

};
use sp_core::OpaqueMetadata;
use sp_mmr_primitives as mmr;
use sp_runtime::{

create_runtime_str,
curve::PiecewiseLinear,
generic, impl_opaque_keys,
traits::{
    AccountIdLookup, BlakeTwo256, Block as BlockT, ConvertInto, Extrinsic as ExtrinsicT,
    OpaqueKeys, SaturatedConversion, Verify,
},
transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},
ApplyExtrinsicResult, KeyTypeId, Perbill, Percent, Permill,

};
use sp_staking::SessionIndex;
use sp_std::{cmp::Ordering, collections::btree_map::BTreeMap, prelude::*};

[cfg(any(feature = "std", test))]

use sp_version::NativeVersion;
use sp_version::RuntimeVersion;
use static_assertions::const_assert;

pub use frame_system::Call as SystemCall;
pub use pallet_balances::Call as BalancesCall;
pub use pallet_election_provider_multi_phase::Call as EPMCall;

[cfg(feature = "std")]

pub use pallet_staking::StakerStatus;
pub use pallet_timestamp::Call as TimestampCall;

[cfg(any(feature = "std", test))]

pub use sp_runtime::BuildStorage;

/// Constant values used within the runtime.
use polkadot_runtime_constants::{currency::, fee::, time::*};

// Weights used in the runtime.
mod weights;

mod bag_thresholds;

pub mod xcm_config;

impl_runtime_weights!(polkadot_runtime_constants);

// Make the WASM binary available.

[cfg(feature = "std")]

include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));

// Polkadot version identifier;
/// Runtime version (Polkadot).

[sp_version::runtime_version]

pub const VERSION: RuntimeVersion = RuntimeVersion {

spec_name: create_runtime_str!("polkadot"),
impl_name: create_runtime_str!("parity-polkadot"),
authoring_version: 0,
spec_version: 9230,
impl_version: 0,
#[cfg(not(feature = "disable-runtime-api"))]
apis: RUNTIME_API_VERSIONS,
#[cfg(feature = "disable-runtime-api")]
apis: version::create_apis_vec![[]],
transaction_version: 12,
state_version: 0,

};

/// The BABE epoch configuration at genesis.
pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration =

babe_primitives::BabeEpochConfiguration {
    c: PRIMARY_PROBABILITY,
    allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots,
};

/// Native version.

[cfg(any(feature = "std", test))]

pub fn native_version() -> NativeVersion {

NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }

}

pub struct BaseFilter;
impl Contains for BaseFilter {

fn contains(call: &Call) -> bool {
    match call {
        // These modules are all allowed to be called by transactions:
        Call::Democracy(_) |
        Call::Council(_) |
        Call::TechnicalCommittee(_) |
        Call::TechnicalMembership(_) |
        Call::Treasury(_) |
        Call::PhragmenElection(_) |
        Call::System(_) |
        Call::Scheduler(_) |
        Call::Preimage(_) |
        Call::Indices(_) |
        Call::Babe(_) |
        Call::Timestamp(_) |
        Call::Balances(_) |
        Call::Authorship(_) |
        Call::Staking(_) |
        Call::Session(_) |
        Call::Grandpa(_) |
        Call::ImOnline(_) |
        Call::Utility(_) |
        Call::Claims(_) |
        Call::Vesting(_) |
        Call::Identity(_) |
        Call::Proxy(_) |
        Call::Multisig(_) |
        Call::Bounties(_) |
        Call::ChildBounties(_) |
        Call::Tips(_) |
        Call::ElectionProviderMultiPhase(_) |
        Call::Configuration(_) |
        Call::ParasShared(_) |
        Call::ParaInclusion(_) |
        Call::Paras(_) |
        Call::Initializer(_) |
        Call::ParaInherent(_) |
        Call::ParasDisputes(_) |
        Call::Dmp(_) |
        Call::Ump(_) |
        Call::Hrmp(_) |
        Call::Slots(_) |
        Call::Registrar(_) |
        Call::Auctions(_) |
        Call::Crowdloan(_) |
        Call::VoterList(_) |
        Call::XcmPallet(_) => true,
        // All pallets are allowed, but exhaustive match is defensive
        // in the case of adding new pallets.
    }
}

}

type MoreThanHalfCouncil = EitherOfDiverse<

EnsureRoot<AccountId>,
pallet_collective::EnsureProportionMoreThan<AccountId, CouncilCollective, 1, 2>,

;

parameter_types! {

pub const Version: RuntimeVersion = VERSION;
pub const SS58Prefix: u8 = 0;

}

impl frame_system::Config for Runtime {

type BaseCallFilter = BaseFilter;
type BlockWeights = BlockWeights;
type BlockLength = BlockLength;
type Origin = Origin;
type Call = Call;
type Index = Nonce;
type BlockNumber = BlockNumber;
type Hash = Hash;
type Hashing = BlakeTwo256;
type AccountId = AccountId;
type Lookup = AccountIdLookup<AccountId, ()>;
type Header = generic::Header<BlockNumber, BlakeTwo256>;
type Event = Event;
type BlockHashCount = BlockHashCount;
type DbWeight = RocksDbWeight;
type Version = Version;
type PalletInfo = PalletInfo;
type AccountData = pallet_balances::AccountData<Balance>;
type OnNewAccount = ();
type OnKilledAccount = ();
type SystemWeightInfo = weights::frame_system::WeightInfo<Runtime>;
type SS58Prefix = SS58Prefix;
type OnSetCode = ();
type MaxConsumers = frame_support::traits::ConstU32<16>;

}

parameter_types! {

pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
    BlockWeights::get().max_block;
pub const MaxScheduledPerBlock: u32 = 50;
pub const NoPreimagePostponement: Option<u32> = Some(10);

}

type ScheduleOrigin = EitherOfDiverse<

EnsureRoot<AccountId>,
pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 1, 2>,

;

/// Used the compare the privilege of an origin inside the scheduler.
pub struct OriginPrivilegeCmp;

impl PrivilegeCmp for OriginPrivilegeCmp {

fn cmp_privilege(left: &OriginCaller, right: &OriginCaller) -> Option<Ordering> {
    if left == right {
        return Some(Ordering::Equal)
    }

    match (left, right) {
        // Root is greater than anything.
        (OriginCaller::system(frame_system::RawOrigin::Root), _) => Some(Ordering::Greater),
        // Check which one has more yes votes.
        (
            OriginCaller::Council(pallet_collective::RawOrigin::Members(l_yes_votes, l_count)),
            OriginCaller::Council(pallet_collective::RawOrigin::Members(r_yes_votes, r_count)),
        ) => Some((l_yes_votes * r_count).cmp(&(r_yes_votes * l_count))),
        // For every other origin we don't care, as they are not used for `ScheduleOrigin`.
        _ => None,
    }
}

}

impl pallet_scheduler::Config for Runtime {

type Event = Event;
type Origin = Origin;
type PalletsOrigin = OriginCaller;
type Call = Call;
type MaximumWeight = MaximumSchedulerWeight;
type ScheduleOrigin = ScheduleOrigin;
type MaxScheduledPerBlock = MaxScheduledPerBlock;
type WeightInfo = weights::pallet_scheduler::WeightInfo<Runtime>;
type OriginPrivilegeCmp = OriginPrivilegeCmp;
type PreimageProvider = Preimage;
type NoPreimagePostponement = NoPreimagePostponement;

}

parameter_types! {

pub const PreimageMaxSize: u32 = 4096 * 1024;
pub const PreimageBaseDeposit: Balance = deposit(2, 64);
pub const PreimageByteDeposit: Balance = deposit(0, 1);

}

impl pallet_preimage::Config for Runtime {

type WeightInfo = pallet_preimage::weights::SubstrateWeight<Runtime>;
type Event = Event;
type Currency = Balances;
type ManagerOrigin = EnsureRoot<AccountId>;
type MaxSize = PreimageMaxSize;
type BaseDeposit = PreimageBaseDeposit;
type ByteDeposit = PreimageByteDeposit;

}

parameter_types! {

pub EpochDuration: u64 = prod_or_fast!(
    EPOCH_DURATION_IN_SLOTS as u64,
    2 * MINUTES as u64,
    "DOT_EPOCH_DURATION"
);
pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
pub ReportLongevity: u64 =
    BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * EpochDuration::get();

}

impl pallet_babe::Config for Runtime {

type EpochDuration = EpochDuration;
type ExpectedBlockTime = ExpectedBlockTime;

// session module is the trigger
type EpochChangeTrigger = pallet_babe::ExternalTrigger;

type DisabledValidators = Session;

type KeyOwnerProofSystem = Historical;

type KeyOwnerProof = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
    KeyTypeId,
    pallet_babe::AuthorityId,
)>>::Proof;

type KeyOwnerIdentification = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(
    KeyTypeId,
    pallet_babe::AuthorityId,
)>>::IdentificationTuple;

type HandleEquivocation =
    pallet_babe::EquivocationHandler<Self::KeyOwnerIdentification, Offences, ReportLongevity>;

type WeightInfo = ();

type MaxAuthorities = MaxAuthorities;

}

parameter_types! {

pub const IndexDeposit: Balance = 10 * DOLLARS;

}

impl pallet_indices::Config for Runtime {

type AccountIndex = AccountIndex;
type Currency = Balances;
type Deposit = IndexDeposit;
type Event = Event;
type WeightInfo = weights::pallet_indices::WeightInfo<Runtime>;

}

parameter_types! {

pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT;
pub const MaxLocks: u32 = 50;
pub const MaxReserves: u32 = 50;

}

impl pallet_balances::Config for Runtime {

type Balance = Balance;
type DustRemoval = ();
type Event = Event;
type ExistentialDeposit = ExistentialDeposit;
type AccountStore = System;
type MaxLocks = MaxLocks;
type MaxReserves = MaxReserves;
type ReserveIdentifier = [u8; 8];
type WeightInfo = weights::pallet_balances::WeightInfo<Runtime>;

}

parameter_types! {

pub const TransactionByteFee: Balance = 10 * MILLICENTS;
/// This value increases the priority of `Operational` transactions by adding
/// a "virtual tip" that's equal to the `OperationalFeeMultiplier * final_fee`.
pub const OperationalFeeMultiplier: u8 = 5;

}

impl pallet_transaction_payment::Config for Runtime {

type OnChargeTransaction = CurrencyAdapter<Balances, DealWithFees<Runtime>>;
type OperationalFeeMultiplier = OperationalFeeMultiplier;
type WeightToFee = WeightToFee;
type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;
type FeeMultiplierUpdate = SlowAdjustingFeeUpdate<Self>;

}

parameter_types! {

pub const MinimumPeriod: u64 = SLOT_DURATION / 2;

}
impl pallet_timestamp::Config for Runtime {

type Moment = u64;
type OnTimestampSet = Babe;
type MinimumPeriod = MinimumPeriod;
type WeightInfo = weights::pallet_timestamp::WeightInfo<Runtime>;

}

parameter_types! {

pub const UncleGenerations: u32 = 0;

}

// TODO: substrate#2986 implement this properly
impl pallet_authorship::Config for Runtime {

type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
type UncleGenerations = UncleGenerations;
type FilterUncle = ();
type EventHandler = (Staking, ImOnline);

}

impl_opaque_keys! {

pub struct SessionKeys {
    pub grandpa: Grandpa,
    pub babe: Babe,
    pub im_online: ImOnline,
    pub para_validator: Initializer,
    pub para_assignment: ParaSessionInfo,
    pub authority_discovery: AuthorityDiscovery,
}

}

impl pallet_session::Config for Runtime {

type Event = Event;
type ValidatorId = AccountId;
type ValidatorIdOf = pallet_staking::StashOf<Self>;
type ShouldEndSession = Babe;
type NextSessionRotation = Babe;
type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
type Keys = SessionKeys;
type WeightInfo = weights::pallet_session::WeightInfo<Runtime>;

}

impl pallet_session::historical::Config for Runtime {

type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
type FullIdentificationOf = pallet_staking::ExposureOf<Runtime>;

}

parameter_types! {

// phase durations. 1/4 of the last session for each.
// in testing: 1min or half of the session for each
pub SignedPhase: u32 = prod_or_fast!(
    EPOCH_DURATION_IN_SLOTS / 4,
    (1 * MINUTES).min(EpochDuration::get().saturated_into::<u32>() / 2),
    "DOT_SIGNED_PHASE"
);
pub UnsignedPhase: u32 = prod_or_fast!(
    EPOCH_DURATION_IN_SLOTS / 4,
    (1 * MINUTES).min(EpochDuration::get().saturated_into::<u32>() / 2),
    "DOT_UNSIGNED_PHASE"
);

// signed config
pub const SignedMaxSubmissions: u32 = 16;
pub const SignedMaxRefunds: u32 = 16 / 4;
// 40 DOTs fixed deposit..
pub const SignedDepositBase: Balance = deposit(2, 0);
// 0.01 DOT per KB of solution data.
pub const SignedDepositByte: Balance = deposit(0, 10) / 1024;
// Each good submission will get 1 DOT as reward
pub SignedRewardBase: Balance = 1 * UNITS;
pub BetterUnsignedThreshold: Perbill = Perbill::from_rational(5u32, 10_000);

// 4 hour session, 1 hour unsigned phase, 32 offchain executions.
pub OffchainRepeat: BlockNumber = UnsignedPhase::get() / 32;

/// We take the top 22500 nominators as electing voters..
pub const MaxElectingVoters: u32 = 22_500;
/// ... and all of the validators as electable targets. Whilst this is the case, we cannot and
/// shall not increase the size of the validator intentions.
pub const MaxElectableTargets: u16 = u16::MAX;

}

generate_solution_type!(

#[compact]
pub struct NposCompactSolution16::<
    VoterIndex = u32,
    TargetIndex = u16,
    Accuracy = sp_runtime::PerU16,
    MaxVoters = MaxElectingVoters,
>(16)

);

pub struct OnChainSeqPhragmen;
impl onchain::Config for OnChainSeqPhragmen {

type System = Runtime;
type Solver = SequentialPhragmen<AccountId, runtime_common::elections::OnChainAccuracy>;
type DataProvider = Staking;
type WeightInfo = weights::frame_election_provider_support::WeightInfo<Runtime>;

}

impl pallet_election_provider_multi_phase::MinerConfig for Runtime {

type AccountId = AccountId;
type MaxLength = OffchainSolutionLengthLimit;
type MaxWeight = OffchainSolutionWeightLimit;
type Solution = NposCompactSolution16;
type MaxVotesPerVoter = <
    <Self as pallet_election_provider_multi_phase::Config>::DataProvider
    as
    frame_election_provider_support::ElectionDataProvider
>::MaxVotesPerVoter;

// The unsigned submissions have to respect the weight of the submit_unsigned call, thus their
// weight estimate function is wired to this call's weight.
fn solution_weight(v: u32, t: u32, a: u32, d: u32) -> Weight {
    <
        <Self as pallet_election_provider_multi_phase::Config>::WeightInfo
        as
        pallet_election_provider_multi_phase::WeightInfo
    >::submit_unsigned(v, t, a, d)
}

}

impl pallet_election_provider_multi_phase::Config for Runtime {

type Event = Event;
type Currency = Balances;
type EstimateCallFee = TransactionPayment;
type SignedPhase = SignedPhase;
type UnsignedPhase = UnsignedPhase;
type SignedMaxSubmissions = SignedMaxSubmissions;
type SignedMaxRefunds = SignedMaxRefunds;
type SignedRewardBase = SignedRewardBase;
type SignedDepositBase = SignedDepositBase;
type SignedDepositByte = SignedDepositByte;
type SignedDepositWeight = ();
type SignedMaxWeight =
    <Self::MinerConfig as pallet_election_provider_multi_phase::MinerConfig>::MaxWeight;
type MinerConfig = Self;
type SlashHandler = (); // burn slashes
type RewardHandler = (); // nothing to do upon rewards
type BetterUnsignedThreshold = BetterUnsignedThreshold;
type BetterSignedThreshold = ();
type OffchainRepeat = OffchainRepeat;
type MinerTxPriority = NposSolutionPriority;
type DataProvider = Staking;
type Fallback = pallet_election_provider_multi_phase::NoFallback<Self>;
type GovernanceFallback = onchain::UnboundedExecution<OnChainSeqPhragmen>;
type Solver = SequentialPhragmen<
    AccountId,
    pallet_election_provider_multi_phase::SolutionAccuracyOf<Self>,
    (),
>;
type BenchmarkingConfig = runtime_common::elections::BenchmarkConfig;
type ForceOrigin = EitherOfDiverse<
    EnsureRoot<AccountId>,
    pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 2, 3>,
>;
type WeightInfo = weights::pallet_election_provider_multi_phase::WeightInfo<Self>;
type MaxElectingVoters = MaxElectingVoters;
type MaxElectableTargets = MaxElectableTargets;

}

parameter_types! {

pub const BagThresholds: &'static [u64] = &bag_thresholds::THRESHOLDS;

}

impl pallet_bags_list::Config for Runtime {

type Event = Event;
type ScoreProvider = Staking;
type WeightInfo = weights::pallet_bags_list::WeightInfo<Runtime>;
type BagThresholds = BagThresholds;
type Score = sp_npos_elections::VoteWeight;

}

// TODO #6469: This shouldn't be static, but a lazily cached value, not built unless needed, and
// re-built in case input parameters have changed. The ideal_stake should be determined by the
// amount of parachain slots being bid on: this should be around (75 - 25.min(slots / 4))%.
pallet_staking_reward_curve::build! {

const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
    min_inflation: 0_025_000,
    max_inflation: 0_100_000,
    // 3:2:1 staked : parachains : float.
    // while there's no parachains, then this is 75% staked : 25% float.
    ideal_stake: 0_750_000,
    falloff: 0_050_000,
    max_piece_count: 40,
    test_precision: 0_005_000,
);

}

parameter_types! {

// Six sessions in an era (24 hours).
pub const SessionsPerEra: SessionIndex = 6;
// 28 eras for unbonding (28 days).
pub const BondingDuration: sp_staking::EraIndex = 28;
pub const SlashDeferDuration: sp_staking::EraIndex = 27;
pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
pub const MaxNominatorRewardedPerValidator: u32 = 256;
pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(17);
// 16
pub const MaxNominations: u32 = <NposCompactSolution16 as frame_election_provider_support::NposSolution>::LIMIT as u32;

}

type SlashCancelOrigin = EitherOfDiverse<

EnsureRoot<AccountId>,
pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 3, 4>,

;

impl pallet_staking::Config for Runtime {

type MaxNominations = MaxNominations;
type Currency = Balances;
type CurrencyBalance = Balance;
type UnixTime = Timestamp;
type CurrencyToVote = CurrencyToVote;
type RewardRemainder = Treasury;
type Event = Event;
type Slash = Treasury;
type Reward = ();
type SessionsPerEra = SessionsPerEra;
type BondingDuration = BondingDuration;
type SlashDeferDuration = SlashDeferDuration;
// A super-majority of the council can cancel the slash.
type SlashCancelOrigin = SlashCancelOrigin;
type SessionInterface = Self;
type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
type NextNewSession = Session;
type ElectionProvider = ElectionProviderMultiPhase;
type GenesisElectionProvider = onchain::UnboundedExecution<OnChainSeqPhragmen>;
type VoterList = VoterList;
type MaxUnlockingChunks = frame_support::traits::ConstU32<32>;
type BenchmarkingConfig = runtime_common::StakingBenchmarkingConfig;
type OnStakerSlash = ();
type WeightInfo = weights::pallet_staking::WeightInfo<Runtime>;

}

parameter_types! {

// Minimum 4 CENTS/byte
pub const BasicDeposit: Balance = deposit(1, 258);
pub const FieldDeposit: Balance = deposit(0, 66);
pub const SubAccountDeposit: Balance = deposit(1, 53);
pub const MaxSubAccounts: u32 = 100;
pub const MaxAdditionalFields: u32 = 100;
pub const MaxRegistrars: u32 = 20;

}

impl pallet_identity::Config for Runtime {

type Event = Event;
type Currency = Balances;
type BasicDeposit = BasicDeposit;
type FieldDeposit = FieldDeposit;
type SubAccountDeposit = SubAccountDeposit;
type MaxSubAccounts = MaxSubAccounts;
type MaxAdditionalFields = MaxAdditionalFields;
type MaxRegistrars = MaxRegistrars;
type Slashed = Treasury;
type ForceOrigin = MoreThanHalfCouncil;
type RegistrarOrigin = MoreThanHalfCouncil;
type WeightInfo = weights::pallet_identity::WeightInfo<Runtime>;

}

parameter_types! {

pub LaunchPeriod: BlockNumber = prod_or_fast!(28 * DAYS, 1, "DOT_LAUNCH_PERIOD");
pub VotingPeriod: BlockNumber = prod_or_fast!(28 * DAYS, 1 * MINUTES, "DOT_VOTING_PERIOD");
pub FastTrackVotingPeriod: BlockNumber = prod_or_fast!(3 * HOURS, 1 * MINUTES, "DOT_FAST_TRACK_VOTING_PERIOD");
pub const MinimumDeposit: Balance = 100 * DOLLARS;
pub EnactmentPeriod: BlockNumber = prod_or_fast!(28 * DAYS, 1, "DOT_ENACTMENT_PERIOD");
pub CooloffPeriod: BlockNumber = prod_or_fast!(7 * DAYS, 1, "DOT_COOLOFF_PERIOD");
pub const InstantAllowed: bool = true;
pub const MaxVotes: u32 = 100;
pub const MaxProposals: u32 = 100;

}

impl pallet_democracy::Config for Runtime {

type Proposal = Call;
type Event = Event;
type Currency = Balances;
type EnactmentPeriod = EnactmentPeriod;
type VoteLockingPeriod = EnactmentPeriod;
type LaunchPeriod = LaunchPeriod;
type VotingPeriod = VotingPeriod;
type MinimumDeposit = MinimumDeposit;
/// A straight majority of the council can decide what their next motion is.
type ExternalOrigin = EitherOfDiverse<
    pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 1, 2>,
    frame_system::EnsureRoot<AccountId>,
>;
/// A 60% super-majority can have the next scheduled referendum be a straight majority-carries vote.
type ExternalMajorityOrigin = EitherOfDiverse<
    pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 3, 5>,
    frame_system::EnsureRoot<AccountId>,
>;
/// A unanimous council can have the next scheduled referendum be a straight default-carries
/// (NTB) vote.
type ExternalDefaultOrigin = EitherOfDiverse<
    pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 1, 1>,
    frame_system::EnsureRoot<AccountId>,
>;
/// Two thirds of the technical committee can have an `ExternalMajority/ExternalDefault` vote
/// be tabled immediately and with a shorter voting/enactment period.
type FastTrackOrigin = EitherOfDiverse<
    pallet_collective::EnsureProportionAtLeast<AccountId, TechnicalCollective, 2, 3>,
    frame_system::EnsureRoot<AccountId>,
>;
type InstantOrigin = EitherOfDiverse<
    pallet_collective::EnsureProportionAtLeast<AccountId, TechnicalCollective, 1, 1>,
    frame_system::EnsureRoot<AccountId>,
>;
type InstantAllowed = InstantAllowed;
type FastTrackVotingPeriod = FastTrackVotingPeriod;
// To cancel a proposal which has been passed, 2/3 of the council must agree to it.
type CancellationOrigin = EitherOfDiverse<
    pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 2, 3>,
    EnsureRoot<AccountId>,
>;
// To cancel a proposal before it has been passed, the technical committee must be unanimous or
// Root must agree.
type CancelProposalOrigin = EitherOfDiverse<
    pallet_collective::EnsureProportionAtLeast<AccountId, TechnicalCollective, 1, 1>,
    EnsureRoot<AccountId>,
>;
type BlacklistOrigin = EnsureRoot<AccountId>;
// Any single technical committee member may veto a coming council proposal, however they can
// only do it once and it lasts only for the cooloff period.
type VetoOrigin = pallet_collective::EnsureMember<AccountId, TechnicalCollective>;
type CooloffPeriod = CooloffPeriod;
type PreimageByteDeposit = PreimageByteDeposit;
type OperationalPreimageOrigin = pallet_collective::EnsureMember<AccountId, CouncilCollective>;
type Slash = Treasury;
type Scheduler = Scheduler;
type PalletsOrigin = OriginCaller;
type MaxVotes = MaxVotes;
type WeightInfo = weights::pallet_democracy::WeightInfo<Runtime>;
type MaxProposals = MaxProposals;

}

parameter_types! {

pub CouncilMotionDuration: BlockNumber = prod_or_fast!(7 * DAYS, 2 * MINUTES, "DOT_MOTION_DURATION");
pub const CouncilMaxProposals: u32 = 100;
pub const CouncilMaxMembers: u32 = 100;

}

pub type CouncilCollective = pallet_collective::Instance1;
impl pallet_collective::Config for Runtime {

type Origin = Origin;
type Proposal = Call;
type Event = Event;
type MotionDuration = CouncilMotionDuration;
type MaxProposals = CouncilMaxProposals;
type MaxMembers = CouncilMaxMembers;
type DefaultVote = pallet_collective::PrimeDefaultVote;
type WeightInfo = weights::pallet_collective_council::WeightInfo<Runtime>;

}

parameter_types! {

pub const CandidacyBond: Balance = 100 * DOLLARS;
// 1 storage item created, key size is 32 bytes, value size is 16+16.
pub const VotingBondBase: Balance = deposit(1, 64);
// additional data per vote is 32 bytes (account id).
pub const VotingBondFactor: Balance = deposit(0, 32);
/// Weekly council elections; scaling up to monthly eventually.
pub TermDuration: BlockNumber = prod_or_fast!(7 * DAYS, 2 * MINUTES, "DOT_TERM_DURATION");
/// 13 members initially, to be increased to 23 eventually.
pub const DesiredMembers: u32 = 13;
pub const DesiredRunnersUp: u32 = 20;
pub const PhragmenElectionPalletId: LockIdentifier = *b"phrelect";

}
// Make sure that there are no more than MaxMembers members elected via phragmen.
const_assert!(DesiredMembers::get() <= CouncilMaxMembers::get());

impl pallet_elections_phragmen::Config for Runtime {

type Event = Event;
type PalletId = PhragmenElectionPalletId;
type Currency = Balances;
type ChangeMembers = Council;
type InitializeMembers = Council;
type CurrencyToVote = frame_support::traits::U128CurrencyToVote;
type CandidacyBond = CandidacyBond;
type VotingBondBase = VotingBondBase;
type VotingBondFactor = VotingBondFactor;
type LoserCandidate = Treasury;
type KickedMember = Treasury;
type DesiredMembers = DesiredMembers;
type DesiredRunnersUp = DesiredRunnersUp;
type TermDuration = TermDuration;
type WeightInfo = weights::pallet_elections_phragmen::WeightInfo<Runtime>;

}

parameter_types! {

pub const TechnicalMotionDuration: BlockNumber = 7 * DAYS;
pub const TechnicalMaxProposals: u32 = 100;
pub const TechnicalMaxMembers: u32 = 100;

}

pub type TechnicalCollective = pallet_collective::Instance2;
impl pallet_collective::Config for Runtime {

type Origin = Origin;
type Proposal = Call;
type Event = Event;
type MotionDuration = TechnicalMotionDuration;
type MaxProposals = TechnicalMaxProposals;
type MaxMembers = TechnicalMaxMembers;
type DefaultVote = pallet_collective::PrimeDefaultVote;
type WeightInfo = weights::pallet_collective_technical_committee::WeightInfo<Runtime>;

}

impl pallet_membership::Config<pallet_membership::Instance1> for Runtime {

type Event = Event;
type AddOrigin = MoreThanHalfCouncil;
type RemoveOrigin = MoreThanHalfCouncil;
type SwapOrigin = MoreThanHalfCouncil;
type ResetOrigin = MoreThanHalfCouncil;
type PrimeOrigin = MoreThanHalfCouncil;
type MembershipInitialized = TechnicalCommittee;
type MembershipChanged = TechnicalCommittee;
type MaxMembers = TechnicalMaxMembers;
type WeightInfo = weights::pallet_membership::WeightInfo<Runtime>;

}

parameter_types! {

pub const ProposalBond: Permill = Permill::from_percent(5);
pub const ProposalBondMinimum: Balance = 100 * DOLLARS;
pub const ProposalBondMaximum: Balance = 500 * DOLLARS;
pub const SpendPeriod: BlockNumber = 24 * DAYS;
pub const Burn: Permill = Permill::from_percent(1);
pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");

pub const TipCountdown: BlockNumber = 1 * DAYS;
pub const TipFindersFee: Percent = Percent::from_percent(20);
pub const TipReportDepositBase: Balance = 1 * DOLLARS;
pub const DataDepositPerByte: Balance = 1 * CENTS;
pub const MaxApprovals: u32 = 100;
pub const MaxAuthorities: u32 = 100_000;
pub const MaxKeys: u32 = 10_000;
pub const MaxPeerInHeartbeats: u32 = 10_000;
pub const MaxPeerDataEncodingSize: u32 = 1_000;

}

type ApproveOrigin = EitherOfDiverse<

EnsureRoot<AccountId>,
pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 3, 5>,

;

impl pallet_treasury::Config for Runtime {

type PalletId = TreasuryPalletId;
type Currency = Balances;
type ApproveOrigin = ApproveOrigin;
type RejectOrigin = MoreThanHalfCouncil;
type Event = Event;
type OnSlash = Treasury;
type ProposalBond = ProposalBond;
type ProposalBondMinimum = ProposalBondMinimum;
type ProposalBondMaximum = ProposalBondMaximum;
type SpendPeriod = SpendPeriod;
type Burn = Burn;
type BurnDestination = ();
type SpendFunds = Bounties;
type MaxApprovals = MaxApprovals;
type WeightInfo = weights::pallet_treasury::WeightInfo<Runtime>;
type SpendOrigin = frame_support::traits::NeverEnsureOrigin<Balance>;

}

parameter_types! {

pub const BountyDepositBase: Balance = 1 * DOLLARS;
pub const BountyDepositPayoutDelay: BlockNumber = 8 * DAYS;
pub const BountyUpdatePeriod: BlockNumber = 90 * DAYS;
pub const MaximumReasonLength: u32 = 16384;
pub const CuratorDepositMultiplier: Permill = Permill::from_percent(50);
pub const CuratorDepositMin: Balance = 10 * DOLLARS;
pub const CuratorDepositMax: Balance = 200 * DOLLARS;
pub const BountyValueMinimum: Balance = 10 * DOLLARS;

}
复制
原创声明，本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。