Struct basilisk_runtime::Runtime

pub struct Runtime;

Implementations

impl Runtime

pub fn metadata() -> RuntimeMetadataPrefixed

Trait Implementations

impl AccountNonceApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32> for Runtime

fn account_nonce(account: AccountId) -> Index

Get current account nonce of given AccountId.

impl AuraApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>, Public> for Runtime

fn slot_duration() -> SlotDuration

Returns the slot duration for Aura.

fn authorities() -> Vec<AuraId>

impl BenchmarkV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn benchmark_metadata(extra: bool) -> (Vec<BenchmarkList>, Vec<StorageInfo>)

Get the benchmark metadata available for this runtime.

fn dispatch_benchmark(
    config: BenchmarkConfig
) -> Result<Vec<BenchmarkBatch>, RuntimeString>

Dispatch the given benchmark.

impl BenchmarkingSetup<Runtime, ()> for SelectedBenchmark

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for SelectedBenchmark

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for SelectedBenchmark

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for SelectedBenchmark

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for SelectedBenchmark

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for SelectedBenchmark

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for SelectedBenchmark

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for accept_offer

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for add_currency

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for add_nondustable_account

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for add_royalty

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for buy

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for buy

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for claim

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for dust_account

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for force_transfer

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for get_spot_price

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for make_offer

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for remove_currency

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for remove_nondustable_account

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for sell

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for set_balance

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for set_currency

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for set_price

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for transfer

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for transfer_all

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for transfer_keep_alive

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for transfer_native_currency

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for transfer_native_currency_worst_case

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for transfer_non_native_currency

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for update_balance_native_currency_creating

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for update_balance_native_currency_killing

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for update_balance_non_native_currency

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for update_vesting_schedules

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for vested_transfer

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BenchmarkingSetup<Runtime, ()> for withdraw_offer

fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>

Return the components and their ranges which should be tested in this benchmark.

fn instance(
    &self,
    components: &[(BenchmarkParameter, u32)],
    verify: bool
) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>

Set up the storage, and prepare a closure to run the benchmark.

impl BlockBuilderV6<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn apply_extrinsic(
    extrinsic: <Block as BlockT>::Extrinsic
) -> ApplyExtrinsicResult

Apply the given extrinsic.

fn finalize_block() -> <Block as BlockT>::Header

Finish the current block.

fn inherent_extrinsics(data: InherentData) -> Vec<<Block as BlockT>::Extrinsic>

Generate inherent extrinsics. The inherent data will vary from chain to chain.

fn check_inherents(block: Block, data: InherentData) -> CheckInherentsResult

Check that the inherents are valid. The inherent data will vary from chain to chain.

impl Clone for Runtime

fn clone(&self) -> Runtime

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CollectCollationInfoV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn collect_collation_info(header: &<Block as BlockT>::Header) -> CollationInfo

Collect information about a collation.

impl Config<()> for Runtime

type Balance = u128

The type for recording an account’s balance.

type Event = Event

The ubiquitous event type.

type MaxLocks = MaxLocks

The maximum number of locks that should exist on an account. Not strictly enforced, but used for weight estimation.

type DustRemoval = Pallet<Runtime, ()>

Handler for the unbalanced reduction when removing a dust account.

type ExistentialDeposit = NativeExistentialDeposit

The minimum amount required to keep an account open.

type AccountStore = Pallet<Runtime>

The means of storing the balances of an account.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this pallet.

type MaxReserves = MaxReserves

The maximum number of named reserves that can exist on an account.

type ReserveIdentifier = ()

The id type for named reserves.

impl Config<()> for Runtime

type PalletId = TreasuryPalletId

The treasury’s pallet id, used for deriving its sovereign account ID.

type Currency = Pallet<Runtime, ()>

The staking balance.

type ApproveOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 2, 3>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Origin from which approvals must come.

type RejectOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Origin from which rejections must come.

type Event = Event

The overarching event type.

type OnSlash = Pallet<Runtime, ()>

Handler for the unbalanced decrease when slashing for a rejected proposal or bounty.

type ProposalBond = ProposalBond

Fraction of a proposal’s value that should be bonded in order to place the proposal. An accepted proposal gets these back. A rejected proposal does not.

type ProposalBondMinimum = ProposalBondMinimum

Minimum amount of funds that should be placed in a deposit for making a proposal.

type ProposalBondMaximum = ProposalBondMaximum

Maximum amount of funds that should be placed in a deposit for making a proposal.

type SpendPeriod = SpendPeriod

Period between successive spends.

type Burn = Burn

Percentage of spare funds (if any) that are burnt per spend period.

type BurnDestination = ()

Handler for the unbalanced decrease when treasury funds are burned.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this pallet.

type SpendFunds = ()

Runtime hooks to external pallet using treasury to compute spend funds.

type MaxApprovals = MaxApprovals

The maximum number of approvals that can wait in the spending queue.

type SpendOrigin = NeverEnsureOrigin<u128>

The origin required for approving spends from the treasury outside of the proposal process. The Success value is the maximum amount that this origin is allowed to spend at a time.

impl Config<()> for Runtime

type Event = Event

The overarching event type.

type DataDepositPerByte = DataDepositPerByte

The amount held on deposit per byte within the tip report reason or bounty description.

type MaximumReasonLength = MaximumReasonLength

Maximum acceptable reason length.

type Tippers = Pallet<Runtime>

Origin from which tippers must come.

type TipCountdown = TipCountdown

The period for which a tip remains open after is has achieved threshold tippers.

type TipFindersFee = TipFindersFee

The percent of the final tip which goes to the original reporter of the tip.

type TipReportDepositBase = TipReportDepositBase

The amount held on deposit for placing a tip report.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

impl Config<()> for Runtime

type Event = Event

The overarching event type.

type CollectionId = u128

Identifier for the collection of item.

type ItemId = u128

The type used to identify a unique item within a collection.

type Currency = CurrencyAdapter<Runtime, RelayChainAssetId>

The currency mechanism, used for paying for reserves.

type ForceOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 2, 3>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin which may forcibly create or destroy an item or otherwise alter privileged attributes.

type CreateOrigin = AsEnsureOriginWithArg<NeverEnsureOrigin<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Standard collection creation is only allowed if the origin attempting it and the collection are in this set.

type Locker = ()

Locker trait to enable Locking mechanism downstream.

type CollectionDeposit = CollectionDeposit

The basic amount of funds that must be reserved for collection.

type ItemDeposit = ItemDeposit

The basic amount of funds that must be reserved for an item.

type MetadataDepositBase = UniquesMetadataDepositBase

The basic amount of funds that must be reserved when adding metadata to your item.

type AttributeDepositBase = AttributeDepositBase

The basic amount of funds that must be reserved when adding an attribute to an item.

type DepositPerByte = DepositPerByte

The additional funds that must be reserved for the number of bytes store in metadata, either “normal” metadata or attribute metadata.

type StringLimit = UniquesStringLimit

The maximum length of data stored on-chain.

type KeyLimit = KeyLimit

The maximum length of an attribute key.

type ValueLimit = ValueLimit

The maximum length of an attribute value.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

type Helper = ()

A set of helper functions for benchmarking.

impl Config<Instance1> for Runtime

type Origin = Origin

The outer origin type.

type Proposal = Call

The outer call dispatch type.

type Event = Event

The outer event type.

type MotionDuration = CouncilMotionDuration

The time-out for council motions.

type MaxProposals = CouncilMaxProposals

Maximum number of proposals allowed to be active in parallel.

type MaxMembers = CouncilMaxMembers

The maximum number of members supported by the pallet. Used for weight estimation.

type DefaultVote = PrimeDefaultVote

Default vote strategy of this collective.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

impl Config<Instance1> for Runtime

type AssetId = u32

Asset type.

type MultiCurrency = Pallet<Runtime>

Currency for transfers.

type PalletId = WarehouseLMPalletId

Pallet id.

type MinTotalFarmRewards = MinTotalFarmRewards

Minimum total rewards to distribute from global farm during liquidity mining.

type MinPlannedYieldingPeriods = MinPlannedYieldingPeriods

Minimum number of periods to run liquidity mining program.

type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>

The block number provider

type AmmPoolId = <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId

Id used to identify amm pool in liquidity mining pallet.

type MaxFarmEntriesPerDeposit = MaxEntriesPerDeposit

Maximum number of yield farms same LP shares can be re/deposited into. This value always MUST BE >= 1.

type MaxYieldFarmsPerGlobalFarm = MaxYieldFarmsPerGlobalFarm

Max number of yield farms can exist in global farm. This includes all farms in the storage(active, stopped, terminated).

type AssetRegistry = Pallet<Runtime>

Asset Registry - used to check if asset is correctly registered in asset registry and provides information about existential deposit of the asset.

type NonDustableWhitelistHandler = Pallet<Runtime>

Account whitelist manager to exclude pool accounts from dusting mechanism.

type PriceAdjustment = DefaultPriceAdjustment

type Event = Event

impl Config<Instance2> for Runtime

type Origin = Origin

The outer origin type.

type Proposal = Call

The outer call dispatch type.

type Event = Event

The outer event type.

type MotionDuration = TechnicalMotionDuration

The time-out for council motions.

type MaxProposals = TechnicalMaxProposals

Maximum number of proposals allowed to be active in parallel.

type MaxMembers = TechnicalMaxMembers

The maximum number of members supported by the pallet. Used for weight estimation.

type DefaultVote = PrimeDefaultVote

Default vote strategy of this collective.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type XcmExecutor = XcmExecutor<XcmConfig>

impl Config for Runtime

type Event = Event

type XcmExecutor = XcmExecutor<XcmConfig>

Something to execute an XCM message. We need this to service the XCMoXCMP queue.

type ChannelInfo = Pallet<Runtime>

Information on the avaialble XCMP channels.

type VersionWrapper = Pallet<Runtime>

Means of converting an Xcm into a VersionedXcm.

type ExecuteOverweightOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin that is allowed to execute overweight messages.

type ControllerOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin that is allowed to resume or suspend the XCMP queue.

type ControllerOriginConverter = (SovereignSignedViaLocation<(ParentIsPreset<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, SiblingParachainConvertsVia<Sibling, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, AccountId32Aliases<RelayNetwork, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>, PalletInstanceGeneralIndexAsAccountId<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, TinkernetMultisigAccountIdDeriver<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>), Origin>, RelayChainAsNative<RelayChainOrigin, Origin>, SiblingParachainAsNative<Origin, Origin>, SignedAccountId32AsNative<RelayNetwork, Origin>, XcmPassthrough<Origin>, DeriveOriginFromPalletInstanceGeneralIndex<Origin, TinkernetMultisigSignedDeriver<Origin>>)

The conversion function used to attempt to convert an XCM MultiLocation origin to a superuser origin.

type WeightInfo = BasiliskWeight<Runtime>

The weight information of this pallet.

impl Config for Runtime

type Event = Event

Because this pallet emits events, it depends on the runtime’s definition of an event.

type AcceptedCurrencyOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin which can add/remove accepted currencies

type Currencies = Pallet<Runtime>

Multi Currency

type SpotPriceProvider = XYKSpotPrice<Runtime>

Spot price provider

type WeightInfo = BasiliskWeight<Runtime>

Weight information for the extrinsics.

type WithdrawFeeForSetCurrency = MultiPaymentCurrencySetFee

Should fee be paid for setting a currency

type WeightToFee = WeightToFee

Convert a weight value into a deductible fee based on the currency type.

type NativeAssetId = NativeAssetId

Native Asset

type FeeReceiver = TreasuryAccount

Account where fees are deposited

impl Config for Runtime

type Event = Event

The overarching event type.

type Call = Call

The overarching call type.

type Currency = Pallet<Runtime, ()>

The currency mechanism.

type ProxyType = ProxyType

A kind of proxy; specified with the proxy and passed in to the IsProxyable fitler. The instance filter determines whether a given call may be proxied under this type.

type ProxyDepositBase = ProxyDepositBase

The base amount of currency needed to reserve for creating a proxy.

type ProxyDepositFactor = ProxyDepositFactor

The amount of currency needed per proxy added.

type MaxProxies = MaxProxies

The maximum amount of proxies allowed for a single account.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

type MaxPending = MaxPending

The maximum amount of time-delayed announcements that are allowed to be pending.

type CallHasher = BlakeTwo256

The type of hash used for hashing the call.

type AnnouncementDepositBase = AnnouncementDepositBase

The base amount of currency needed to reserve for creating an announcement.

type AnnouncementDepositFactor = AnnouncementDepositFactor

The amount of currency needed per announcement made.

impl Config for Runtime

Tokens Configurations

type Event = Event

type Balance = u128

The balance type

type Amount = i128

The amount type, should be signed version of Balance

type CurrencyId = u32

The currency ID type

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this module.

type ExistentialDeposits = Pallet<Runtime>

The minimum amount required to keep an account. It’s deprecated to config 0 as ED for any currency_id, zero ED will retain account even if its total is zero. Since accounts of orml_tokens are also used as providers of System::AccountInfo, zero ED may cause some problems.

type OnDust = Pallet<Runtime>

Handler to burn or transfer account’s dust

type MaxLocks = MaxLocks

type MaxReserves = MaxReserves

The maximum number of named reserves that can exist on an account.

type ReserveIdentifier = ()

The id type for named reserves.

type DustRemovalWhitelist = DustRemovalWhitelist

type OnNewTokenAccount = AddTxAssetOnAccount<Runtime>

Handler for when an account was created

type OnKilledTokenAccount = RemoveTxAssetOnKilled<Runtime>

Handler for when an account was created

impl Config for Runtime

type Event = Event

type MultiCurrency = OrmlTokensAdapter<Runtime>

type NativeCurrency = BasicCurrencyAdapter<Runtime, Pallet<Runtime, ()>, i128, u32>

type GetNativeCurrencyId = NativeAssetId

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this module.

impl Config for Runtime

type Event = Event

type Balance = u128

Balance type

type Amount = i128

The amount type, should be signed version of Balance

type CurrencyId = u32

Asset type

type MultiCurrency = Pallet<Runtime>

Currency for transfers

type MinCurrencyDeposits = Pallet<Runtime>

The minimum amount required to keep an account.

type Reward = DustingReward

Reward amount

type NativeCurrencyId = NativeAssetId

Native Asset Id

type BlacklistUpdateOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin which can manage whiltelist.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this module.

impl Config for Runtime

type Event = Event

type RegistryOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 2, 3>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin which can work with asset-registry.

type AssetId = u32

Asset type

type Balance = u128

Balance type

type AssetNativeLocation = AssetLocation

Asset location type

type StringLimit = RegistryStrLimit

The maximum length of a name or symbol stored on-chain.

type SequentialIdStartAt = SequentialIdOffset

type NativeAssetId = NativeAssetId

Native Asset Id

type WeightInfo = BasiliskWeight<Runtime>

Weight information for the extrinsics

impl Config for Runtime

type Event = Event

type AssetRegistry = Pallet<Runtime>

Registry support

type AssetPairAccountId = AssetPairAccountId<Runtime>

Share token support

type Currency = Pallet<Runtime>

Multi currency for transfer of currencies

type NativeAssetId = NativeAssetId

Native Asset Id

type WeightInfo = BasiliskWeight<Runtime>

Weight information for the extrinsics.

type GetExchangeFee = ExchangeFee

Trading fee rate

type MinTradingLimit = MinTradingLimit

Minimum trading limit

type MinPoolLiquidity = MinPoolLiquidity

Minimum pool liquidity

type MaxInRatio = MaxInRatio

Max fraction of pool to sell in single transaction

type MaxOutRatio = MaxOutRatio

Max fraction of pool to buy in single transaction

type CanCreatePool = DisallowWhenLBPPoolRunning<Runtime>

Called to ensure that pool can be created

type AMMHandler = ()

AMM handlers

type DiscountedFee = DiscountedFee

Discounted fee

type NonDustableWhitelistHandler = Pallet<Runtime>

Account whitelist manager to exclude pool accounts from dusting mechanism.

impl Config for Runtime

type Event = Event

type MultiCurrency = Pallet<Runtime>

Multi currency for transfer of currencies

type LockedBalance = MultiCurrencyLockedBalance<Runtime>

Universal locked balance getter for tracking of fee collector balance

type CreatePoolOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 2, 3>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin which can create a new pool

type LBPWeightFunction = LBPWeightFunction

Function for calculation of LBP weights

type AssetPairAccountId = AssetPairAccountId<Runtime>

Mapping of asset pairs to unique pool identities

type MinTradingLimit = MinTradingLimit

Minimum trading limit, sole purpose of this is to keep the math working

type MinPoolLiquidity = MinPoolLiquidity

Minimum pool liquidity, sole purpose of this is to keep the math working

type MaxInRatio = MaxInRatio

Max fraction of pool to sell in single transaction

type MaxOutRatio = MaxOutRatio

Max fraction of pool to buy in single transaction

type WeightInfo = BasiliskWeight<Runtime>

Weight information for the extrinsics

type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>

The block number provider

impl Config for Runtime

type Event = Event

The overarching event type.

type OnSystemEvent = OnValidationDataHandler<Runtime>

Something which can be notified when the validation data is set.

type SelfParaId = Pallet<Runtime>

Returns the parachain ID we are running with.

type OutboundXcmpMessageSource = Pallet<Runtime>

The place where outbound XCMP messages come from. This is queried in finalize_block.

type DmpMessageHandler = Pallet<Runtime>

The message handler that will be invoked when messages are received via DMP.

type ReservedDmpWeight = ReservedDmpWeight

The weight we reserve at the beginning of the block for processing DMP messages.

type XcmpMessageHandler = Pallet<Runtime>

The message handler that will be invoked when messages are received via XCMP.

type ReservedXcmpWeight = ReservedXcmpWeight

The weight we reserve at the beginning of the block for processing XCMP messages.

type CheckAssociatedRelayNumber = RelayNumberStrictlyIncreases

Something that can check the associated relay parent block number.

impl Config for Runtime

type AuthorityId = Public

The identifier type for an authority.

type MaxAuthorities = MaxAuthorities

The maximum number of authorities that the pallet can hold.

type DisabledValidators = ()

A way to check whether a given validator is disabled and should not be authoring blocks. Blocks authored by a disabled validator will lead to a panic as part of this module’s initialization.

impl Config for Runtime

type Event = Event

The overarching event type.

type XcmExecutor = XcmExecutor<XcmConfig>

type ExecuteOverweightOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Origin which is allowed to execute overweight messages.

impl Config for Runtime

type Event = Event

type WeightInfo = BasiliskWeight<Runtime>

type NftCollectionId = u128

type NftItemId = u128

type CollectionType = CollectionType

type Permissions = NftPermissions

type ReserveCollectionIdUpTo = ReserveCollectionIdUpTo

Collection IDs reserved for runtime up to the following constant

impl Config for Runtime

type ExternalOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

A straight majority of the council can decide what their next motion is.

type ExternalMajorityOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

A majority can have the next scheduled referendum be a straight majority-carries vote

type ExternalDefaultOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 1>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

A unanimous council can have the next scheduled referendum be a straight default-carries (NTB) vote.

type FastTrackOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Two thirds of the technical committee can have an ExternalMajority/ExternalDefault vote be tabled immediately and with a shorter voting/enactment period.

type Proposal = Call

type Event = Event

type Currency = Pallet<Runtime, ()>

Currency type for this pallet.

type EnactmentPeriod = EnactmentPeriod

The period between a proposal being approved and enacted.

type LaunchPeriod = LaunchPeriod

How often (in blocks) new public referenda are launched.

type VotingPeriod = VotingPeriod

How often (in blocks) to check for new votes.

type MinimumDeposit = MinimumDeposit

The minimum amount to be used as a deposit for a public referendum proposal.

type InstantOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 1>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Origin from which the next majority-carries (or more permissive) referendum may be tabled to vote immediately and asynchronously in a similar manner to the emergency origin. It retains its threshold method.

type InstantAllowed = InstantAllowed

Indicator for whether an emergency origin is even allowed to happen. Some chains may want to set this permanently to false, others may want to condition it on things such as an upgrade having happened recently.

type FastTrackVotingPeriod = FastTrackVotingPeriod

Minimum voting period allowed for a fast-track referendum.

type CancellationOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 2, 3>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Origin from which any referendum may be cancelled in an emergency.

type CancelProposalOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 1>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Origin from which a proposal may be cancelled and its backers slashed.

type BlacklistOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Origin from which proposals may be blacklisted.

type VetoOrigin = EnsureMember<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2>

Origin for anyone able to veto proposals.

type CooloffPeriod = CooloffPeriod

Period in blocks where an external proposal may not be re-submitted after being vetoed.

type PreimageByteDeposit = PreimageByteDeposit

The amount of balance that must be deposited per byte of preimage stored.

type OperationalPreimageOrigin = EnsureMember<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1>

An origin that can provide a preimage using operational extrinsics.

type Slash = Pallet<Runtime, ()>

Handler for the unbalanced reduction when slashing a preimage deposit.

type Scheduler = Pallet<Runtime>

The Scheduler.

type PalletsOrigin = OriginCaller

Overarching type of all pallets origins.

type MaxVotes = MaxVotes

The maximum number of votes for an account.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this pallet.

type MaxProposals = MaxProposals

The maximum number of public proposals that can exist at any time.

type VoteLockingPeriod = VoteLockingPeriod

The minimum period of vote locking.

impl Config for Runtime

type Event = Event

type PalletId = ElectionsPhragmenPalletId

Identifier for the elections-phragmen pallet’s lock

type Currency = Pallet<Runtime, ()>

The currency that people are electing with.

type ChangeMembers = Pallet<Runtime, Instance1>

What to do when the members change.

type InitializeMembers = ()

What to do with genesis members

type CurrencyToVote = U128CurrencyToVote

Convert a balance into a number used for election calculation. This must fit into a u64 but is allowed to be sensibly lossy.

type CandidacyBond = CandidacyBond

How much should be locked up in order to submit one’s candidacy.

type VotingBondBase = VotingBondBase

Base deposit associated with voting.

type VotingBondFactor = VotingBondFactor

The amount of bond that need to be locked for each vote (32 bytes).

type LoserCandidate = Pallet<Runtime, ()>

Handler for the unbalanced reduction when a candidate has lost (and is not a runner-up)

type KickedMember = Pallet<Runtime, ()>

Handler for the unbalanced reduction when a member has been kicked.

type DesiredMembers = DesiredMembers

Number of members to elect.

type DesiredRunnersUp = DesiredRunnersUp

Number of runners_up to keep.

type TermDuration = TermDuration

How long each seat is kept. This defines the next block number at which an election round will happen. If set to zero, no elections are ever triggered and the module will be in passive mode.

type MaxCandidates = MaxElectionCandidates

The maximum number of candidates in a phragmen election.

type MaxVoters = MaxElectionVoters

The maximum number of voters to allow in a phragmen election.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type Origin = Origin

The aggregated origin which the dispatch will take.

type PalletsOrigin = OriginCaller

The caller origin, overarching type of all pallets origins.

type Call = Call

The aggregated call type.

type MaximumWeight = MaximumSchedulerWeight

The maximum weight that may be scheduled per block for any dispatchables of less priority than schedule::HARD_DEADLINE.

type ScheduleOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

Required origin to schedule or cancel calls.

type MaxScheduledPerBlock = MaxScheduledPerBlock

The maximum number of scheduled calls in the queue for a single block. Not strictly enforced, but used for weight estimation.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this pallet.

type OriginPrivilegeCmp = EqualPrivilegeOnly

Compare the privileges of origins.

type PreimageProvider = Pallet<Runtime>

The preimage provider with which we look up call hashes to get the call.

type NoPreimagePostponement = NoPreimagePostponement

If Some then the number of blocks to postpone execution for when the item is delayed.

impl Config for Runtime

type Event = Event

The overarching event type.

type Call = Call

The overarching call type.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this pallet.

type PalletsOrigin = OriginCaller

The caller origin, overarching type of all pallets origins.

impl Config for Runtime

type FindAuthor = FindAccountFromAuthorIndex<Runtime, Pallet<Runtime>>

Find the author of a block.

type UncleGenerations = UncleGenerations

The number of blocks back we should accept uncles. This means that we will deal with uncle-parents that are UncleGenerations + 1 before now.

type FilterUncle = ()

A filter for uncles within a block. This is for implementing further constraints on what uncles can be included, other than their ancestry.

type EventHandler = (Pallet<Runtime>,)

An event handler for authored blocks.

impl Config for Runtime

type Event = Event

Overarching event type.

type Currency = Pallet<Runtime, ()>

The currency mechanism.

type UpdateOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

Origin that can dictate updating parameters of this pallet.

type PotId = PotId

Account Identifier from which the internal Pot is generated.

type MaxCandidates = MaxCandidates

Maximum number of candidates that we should have. This is enforced in code.

type MinCandidates = MinCandidates

Minimum number of candidates that we should have. This is used for disaster recovery.

type MaxInvulnerables = MaxInvulnerables

Maximum number of invulnerables. This is enforced in code.

type KickThreshold = Period

type ValidatorId = <Runtime as Config>::AccountId

A stable ID for a validator.

type ValidatorIdOf = IdentityCollator

A conversion from account ID to validator ID.

type ValidatorRegistration = Pallet<Runtime>

Validate a user is registered

type WeightInfo = BasiliskWeight<Runtime>

The weight information of this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type ValidatorId = <Runtime as Config>::AccountId

A stable ID for a validator.

type ValidatorIdOf = IdentityCollator

A conversion from account ID to validator ID.

type ShouldEndSession = PeriodicSessions<Period, Offset>

Indicator for when to end the session.

type NextSessionRotation = PeriodicSessions<Period, Offset>

Something that can predict the next session rotation. This should typically come from the same logical unit that provides ShouldEndSession, yet, it gives a best effort estimate. It is helpful to implement EstimateNextNewSession.

type SessionManager = Pallet<Runtime>

Handler for managing new session.

type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders

Handler when a session has changed.

type Keys = SessionKeys

The keys.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

type Balance = u128

The balance type.

type CurrencyId = u32

Currency Id.

type CurrencyIdConvert = CurrencyIdConvert

Convert T::CurrencyId to MultiLocation.

type AccountIdToMultiLocation = AccountIdToMultiLocation

Convert T::AccountId to MultiLocation.

type SelfLocation = SelfLocation

Self chain location.

type XcmExecutor = XcmExecutor<XcmConfig>

XCM executor.

type Weigher = FixedWeightBounds<BaseXcmWeight, Call, MaxInstructions>

Means of measuring the weight consumed by an XCM message locally.

type BaseXcmWeight = BaseXcmWeight

Base XCM weight.

type LocationInverter = LocationInverter<Ancestry>

Means of inverting a location.

type MaxAssetsForTransfer = MaxAssetsForTransfer

The maximum number of distinct assets allowed to be transferred in a single helper extrinsic.

type MultiLocationsFilter = Everything

MultiLocation filter

type ReserveProvider = AbsoluteReserveProvider

The way to retreave the reserve of a MultiAsset. This can be configured to accept absolute or relative paths for self tokens

type MinXcmFee = ParachainMinFee

Minimum xcm execution fee paid on destination chain.

impl Config for Runtime

type Event = Event

type Currency = Pallet<Runtime, ()>

type MinVestedTransfer = MinVestedTransfer

The minimum amount transferred to call vested_transfer.

type VestedTransferOrigin = RootAsVestingPallet

Required origin for vested transfer.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this module.

type MaxVestingSchedules = MaxVestingSchedules

The maximum vesting schedules

type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>

impl Config for Runtime

type Event = Event

type Currency = CurrencyAdapter<Runtime, RelayChainAssetId>

type WeightInfo = BasiliskWeight<Runtime>

type MinimumOfferAmount = MinimumOfferAmount

type RoyaltyBondAmount = RoyaltyBondAmount

impl Config for Runtime

type Event = Event

type RelaychainBlockNumberProvider = RelayChainBlockNumberProvider<Runtime>

Provider of relay chain block number

impl Config for Runtime

type Event = Event

type MultiCurrency = Pallet<Runtime>

Currency for transfers.

type CreateOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 1>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin account that can create new liquidity mining program.

type PalletId = LMPalletId

Pallet id.

type NftCollectionId = LiquidityMiningNftCollectionId

NFT collection id for liq. mining deposit nfts. Has to be within the range of reserved NFT class IDs.

type AMM = Pallet<Runtime>

AMM helper functions.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsic in this module.

type NFTHandler = Pallet<Runtime>

Non fungible handling

type LiquidityMiningHandler = Pallet<Runtime, Instance1>

Liquidity mining handler for managing liquidity mining functionalities

type NonDustableWhitelistHandler = Pallet<Runtime>

Account whitelist manager to exclude pool accounts from dusting mechanism.

impl Config for Runtime

type WeightInfo = ()

The Weight information for this pallet.

type Event = Event

The overarching event type.

type Currency = Pallet<Runtime, ()>

Currency type for this pallet.

type ManagerOrigin = EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

An origin that can request a preimage be placed on-chain without a deposit or fee, or manage existing preimages.

type MaxSize = PreimageMaxSize

Max size allowed for a preimage.

type BaseDeposit = PreimageBaseDeposit

The base deposit for placing a preimage on chain.

type ByteDeposit = PreimageByteDeposit

The per-byte deposit for placing a preimage on chain.

impl Config for Runtime

type Event = Event

The overarching event type.

type Currency = Pallet<Runtime, ()>

The currency trait.

type BasicDeposit = BasicDeposit

The amount held on deposit for a registered identity

type FieldDeposit = FieldDeposit

The amount held on deposit per additional field for a registered identity.

type SubAccountDeposit = SubAccountDeposit

The amount held on deposit for a registered subaccount. This should account for the fact that one storage item’s value will increase by the size of an account ID, and there will be another trie item whose value is the size of an account ID plus 32 bytes.

type MaxSubAccounts = MaxSubAccounts

The maximum number of sub-accounts allowed per identified account.

type MaxAdditionalFields = MaxAdditionalFields

Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O required to access an identity, but can be pretty high.

type MaxRegistrars = MaxRegistrars

Maxmimum number of registrars allowed in the system. Needed to bound the complexity of, e.g., updating judgements.

type Slashed = Pallet<Runtime, ()>

What to do with slashed funds.

type ForceOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin which may forcibly set or remove a name. Root can always do this.

type RegistrarOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin which may add or remove registrars. Root can always do this.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type Call = Call

The overarching call type.

type Currency = Pallet<Runtime, ()>

The currency mechanism.

type DepositBase = DepositBase

The base amount of currency needed to reserve for creating a multisig execution or to store a dispatch call for later.

type DepositFactor = DepositFactor

The amount of currency needed per unit threshold when creating a multisig execution.

type MaxSignatories = MaxSignatories

The maximum amount of signatories allowed in the multisig.

type WeightInfo = ()

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

type UpdateOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance2, 1, 2>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The origin which may set filter.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for the extrinsics in this module.

impl Config for Runtime

type Event = Event

type AssetId = u32

Asset id type

type Balance = u128

Balance type

type MaxNumberOfTrades = MaxNumberOfTrades

Max limit for the number of trades within a route

type Currency = MultiInspectAdapter<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, u32, u128, Pallet<Runtime, ()>, Pallet<Runtime>, NativeAssetId>

Currency for checking balances

type AMM = (Pallet<Runtime>, Pallet<Runtime>)

Handlers for AMM pools to calculate and execute trades

type WeightInfo = BasiliskWeight<Runtime>

Weight information for the extrinsics.

impl Config for Runtime

type Event = Event

impl Config for Runtime

type Event = Event

type SovereignOrigin = EitherOfDiverse<EnsureProportionAtLeast<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Instance1, 2, 3>, EnsureRoot<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>>

The required origin for sending XCM as parachain sovereign.

impl Config for Runtime

type Event = Event

The overarching event type.

type SendXcmOrigin = EnsureXcmOrigin<Origin, SignedToAccountId32<Origin, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, RelayNetwork>>

Required origin for sending XCM messages. If successful, it resolves to MultiLocation which exists as an interior location within this chain’s XCM context.

type XcmRouter = (ParentAsUmp<Pallet<Runtime>, ()>, Pallet<Runtime>)

The type used to actually dispatch an XCM to its destination.

type ExecuteXcmOrigin = EnsureXcmOrigin<Origin, SignedToAccountId32<Origin, <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, RelayNetwork>>

Required origin for executing XCM messages, including the teleport functionality. If successful, then it resolves to MultiLocation which exists as an interior location within this chain’s XCM context.

type XcmExecuteFilter = Everything

Our XCM filter which messages to be executed using XcmExecutor must pass.

type XcmExecutor = XcmExecutor<XcmConfig>

Something to execute an XCM message.

type XcmTeleportFilter = Nothing

Our XCM filter which messages to be teleported using the dedicated extrinsic must pass.

type XcmReserveTransferFilter = Everything

Our XCM filter which messages to be reserve-transferred using the dedicated extrinsic must pass.

type Weigher = FixedWeightBounds<BaseXcmWeight, Call, MaxInstructions>

Means of measuring the weight consumed by an XCM message locally.

type LocationInverter = LocationInverter<Ancestry>

Means of inverting a location.

type Origin = Origin

The outer Origin type.

type Call = Call

The outer Call type.

const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100u32

type AdvertisedXcmVersion = CurrentXcmVersion

The latest supported version that we advertise. Generally just set it to pallet_xcm::CurrentXcmVersion.

impl Config for Runtime

type BaseCallFilter = BaseFilter

The basic call filter to use in dispatchable.

type Origin = Origin

The ubiquitous origin type.

type Call = Call

The aggregated dispatch type that is available for extrinsics.

type Index = u32

The index type for storing how many extrinsics an account has signed.

type BlockNumber = u32

The index type for blocks.

type Hash = H256

The type for hashing blocks and tries.

type Hashing = BlakeTwo256

The hashing algorithm used.

type AccountId = <<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId

The identifier used to distinguish between accounts.

type Lookup = IdentityLookup<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId>

The lookup mechanism to get account ID from whatever is passed in dispatchers.

type Header = Header<u32, BlakeTwo256>

The header type.

type Event = Event

The ubiquitous event type.

type BlockHashCount = BlockHashCount

Maximum number of block number to block hash mappings to keep (oldest pruned first).

type DbWeight = RocksDbWeight

The weight of database operations that the runtime can invoke.

type Version = Version

The weight of the overhead invoked on the block import process, independent of the extrinsics included in that block. Version of the runtime.

type PalletInfo = PalletInfo

Converts a module to the index of the module in construct_runtime!.

This type is being generated by construct_runtime!.

type AccountData = AccountData<u128>

The data to be stored in an account.

type OnNewAccount = ()

What to do if a new account is created.

type OnKilledAccount = ()

What to do if an account is fully reaped from the system.

type SystemWeightInfo = BasiliskWeight<Runtime>

Weight information for the extrinsics of this pallet.

type BlockWeights = BlockWeights

Block & extrinsics weights: base values and limits.

type BlockLength = BlockLength

The maximum length of a block (in bytes).

type SS58Prefix = SS58Prefix

The designated SS58 prefix of this chain.

type OnSetCode = ParachainSetCode<Runtime>

What to do if the runtime wants to change the code to something new.

type MaxConsumers = ConstU32<16>

The maximum number of consumers allowed on a single account.

impl Config for Runtime

type Moment = u64

A timestamp: milliseconds since the unix epoch.

type OnTimestampSet = ()

Something which can be notified when the timestamp is set. Set this to () if not needed.

type MinimumPeriod = MinimumPeriod

The minimum period between blocks. Beware that this is different to the expected period that the block production apparatus provides. Your chosen consensus system will generally work with this to determine a sensible block time. e.g. For Aura, it will be double this period on default settings.

type WeightInfo = BasiliskWeight<Runtime>

Weight information for extrinsics in this pallet.

impl Config for Runtime

type Event = Event

The overarching event type.

type OnChargeTransaction = TransferFees<Pallet<Runtime>, Pallet<Runtime>, DepositAll<Runtime>>

Handler for withdrawing, refunding and depositing the transaction fee. Transaction fees are withdrawn before the transaction is executed. After the transaction was executed the transaction weight can be adjusted, depending on the used resources by the transaction. If the transaction weight is lower than expected, parts of the transaction fee might be refunded. In the end the fees can be deposited.

type OperationalFeeMultiplier = ()

A fee mulitplier for Operational extrinsics to compute “virtual tip” to boost their priority

type WeightToFee = WeightToFee

Convert a weight value into a deductible fee based on the currency type.

type LengthToFee = ConstantMultiplier<u128, TransactionByteFee>

Convert a length value into a deductible fee based on the currency type.

type FeeMultiplierUpdate = TargetedFeeAdjustment<Runtime, TargetBlockFullness, AdjustmentVariable, MinimumMultiplier>

Update the multiplier of the next block, based on the previous block’s weight.

impl CoreV4<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn version() -> RuntimeVersion

Returns the version of the runtime.

fn execute_block(block: Block)

Execute the given block.

fn initialize_block(header: &<Block as BlockT>::Header)

Initialize a block with the given header.

impl Debug for Runtime

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EnsureInherentsAreFirst<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn ensure_inherents_are_first(block: &Block) -> Result<(), u32>

Ensure the position of inherent is correct, i.e. they are before non-inherents.

impl GetNodeBlockType for Runtime

type NodeBlock = Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>

The NodeBlock type.

impl GetRuntimeBlockType for Runtime

type RuntimeBlock = Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>

The RuntimeBlock type.

impl MetadataV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn metadata() -> OpaqueMetadata

Returns the metadata of a runtime.

impl OffchainWorkerApiV2<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn offchain_worker(header: &<Block as BlockT>::Header)

Starts the off-chain task for given block header.

impl PartialEq<Runtime> for Runtime

fn eq(&self, other: &Runtime) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SessionKeysV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn decode_session_keys(encoded: Vec<u8>) -> Option<Vec<(Vec<u8>, KeyTypeId)>>

Decode the given public session keys.

fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8>

Generate a set of session keys with optionally using the given seed. The keys should be stored within the keystore exposed via runtime externalities.

impl TaggedTransactionQueueV3<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn validate_transaction(
    source: TransactionSource,
    tx: <Block as BlockT>::Extrinsic,
    block_hash: <Block as BlockT>::Hash
) -> TransactionValidity

Validate the transaction.

impl TransactionPaymentApiV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>, u128> for Runtime

fn query_info(
    uxt: <Block as BlockT>::Extrinsic,
    len: u32
) -> RuntimeDispatchInfo<Balance>

fn query_fee_details(
    uxt: <Block as BlockT>::Extrinsic,
    len: u32
) -> FeeDetails<Balance>

impl TryRuntimeV1<Block<Header<u32, BlakeTwo256>, UncheckedExtrinsic<<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId, Call, MultiSignature, (CheckSpecVersion<Runtime>, CheckTxVersion<Runtime>, CheckGenesis<Runtime>, CheckMortality<Runtime>, CheckNonce<Runtime>, CheckWeight<Runtime>, ChargeTransactionPayment<Runtime>, CurrencyBalanceCheck<Runtime>)>>> for Runtime

fn on_runtime_upgrade() -> (Weight, Weight)

dry-run runtime upgrades, returning the total weight consumed.

fn execute_block(
    block: Block,
    state_root_check: bool,
    try_state: TryStateSelect
) -> Weight

Execute the given block, but don’t check that its state root matches that of yours.

impl TypeInfo for Runtime

type Identity = Runtime

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl ValidateUnsigned for Runtime

type Call = Call

The call to validate

fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError>

Validate the call right before dispatch.

fn validate_unsigned(
    source: TransactionSource,
    call: &Self::Call
) -> TransactionValidity

Return the validity of the call

impl Config for Runtime

impl Config for Runtime

impl Config for Runtime

impl Config for Runtime

impl Copy for Runtime

impl Eq for Runtime

impl StructuralEq for Runtime

impl StructuralPartialEq for Runtime